logic.h

/***************************************************************************
 *   Copyright (C) 2003-2005 by David Saxton                               *
 *   david@bluehaze.org                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef LOGIC_H
#define LOGIC_H

#include "element.h"

#include <qguardedptr.h>
#include <qvaluelist.h>

class Component;
class Pin;
class Simulator;

typedef QValueList<QGuardedPtr<Pin> > PinList;

typedef struct
{
        float risingTrigger; // Trigger on rising edge
        float fallingTrigger; // Trigger on falling edge
        float output; // Output voltage
        float highImpedance; // Output impedance when high
        float lowImpedance; // Output impedance when low
} LogicConfig;

/* What is this for? */
class CallbackClass {};
typedef void(CallbackClass::*CallbackPtr)( bool isHigh );

class LogicIn : public Element
{
        public:
                LogicIn( LogicConfig config );
                virtual ~LogicIn();
        
                virtual Type type() const { return Element_LogicIn; }
                virtual void setElementSet( ElementSet *c );
        
                virtual void setLogic( LogicConfig config );
                void check();
                bool isHigh() const { return m_bLastState; }
                void setCallback( CallbackClass * object, CallbackPtr func );
                static LogicConfig getConfig();
                void setLastState( bool state ) { m_bLastState = state; }
                LogicIn * nextLogic() const { return m_pNextLogic; }
                void setNextLogic( LogicIn * next ) { m_pNextLogic = next; }
                void callCallback()
                {
                        if (m_pCallbackFunction)
                                (m_pCallbackObject->*m_pCallbackFunction)(m_bLastState);
                }
        
        protected:
                virtual void updateCurrents();
                virtual void add_initial_dc();
        
                CallbackPtr m_pCallbackFunction;
                CallbackClass * m_pCallbackObject;
                bool m_bLastState;
                LogicIn * m_pNextLogic;
                LogicConfig m_config;
};


class LogicOut : public LogicIn
{
        public:
                LogicOut( LogicConfig config, bool _high );
                virtual ~LogicOut();
        
                virtual void setLogic( LogicConfig config );
                virtual void setElementSet( ElementSet *c );
                virtual void add_map();
                virtual Type type() const { return Element_LogicOut; }
        
                void setOutputHighConductance( double g );
                void setOutputLowConductance( double g );
                void setOutputHighVoltage( double v );
                double outputHighVoltage() const { return m_vHigh; }
                void setHigh( bool high );
                bool outputState() const { return b_state; }
                void setUseLogicChain( bool use );
                void setNextChanged( LogicOut * logicOut, unsigned char chain ) { m_pNextChanged[chain] = logicOut; }
                void setCanAddChanged( bool canAdd ) { m_bCanAddChanged = canAdd; }
                LogicOut * nextChanged( unsigned char chain ) const { return m_pNextChanged[chain]; }
                PinList pinList;
                PinList::iterator pinListBegin;
                PinList::iterator pinListEnd;
        
        protected:
                void configChanged();
                virtual void updateCurrents();
                virtual void add_initial_dc();
        
                // Pre-initalized levels from config
                double m_gHigh;
                double m_gLow;
                double m_vHigh;
                
                // Whether to use the user-defined logic values
                bool m_bOutputHighConductanceConst;
                bool m_bOutputLowConductanceConst;
                bool m_bOutputHighVoltageConst;
        
                double m_g_out;
                double m_v_out;
                double m_old_g_out;
                double m_old_v_out;
                bool b_state;
                bool m_bCanAddChanged;
                LogicOut * m_pNextChanged[2];
                Simulator * m_pSimulator;
                bool m_bUseLogicChain;
};

#endif

---