sim_wire.h

Go to the documentation of this file.

/*
 * sim_wire.h
 *
 *  Copyright 2024 Clement Savergne <csavergne@yahoo.com>
 
    This file is part of yasim-avr.
 
    yasim-avr 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 3 of the License, or
    (at your option) any later version.
 
    yasim-avr is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with yasim-avr.  If not, see <http://www.gnu.org/licenses/>.
 */
 
//=======================================================================================
 
#ifndef __YASIMAVR_WIRE_H__
#define __YASIMAVR_WIRE_H__
 
#include "sim_types.h"
#include "sim_signal.h"
 
YASIMAVR_BEGIN_NAMESPACE
 
 
//=======================================================================================
 
class AVR_CORE_PUBLIC_API Wire {
 
public:
 
    enum StateEnum {
        //The enum values are partially a bitset (using StateFlag values) :
        //bit 0 indicates that it is a stable digital state if set
        //bit 1 is the boolean value (only if bit 0 is set too)
        //bit 2 indicates a 'driver' state if set or 'weak' if clear
        //'Weak' states
        State_Floating  = 0x00,
        State_PullUp    = 0x03,
        State_PullDown  = 0x01,
        //'Driver' states
        State_Analog    = 0x04,
        State_High      = 0x07,
        State_Low       = 0x05,
        //Special states
        State_Shorted   = 0x80,
        State_Error     = 0x90
    };
 
 
    class AVR_CORE_PUBLIC_API state_t {
 
    public:
 
        inline state_t() : m_value(State_Floating), m_level(0.5) {}
        constexpr state_t(StateEnum s, double v = 0.0) : m_value(s), m_level(normalised_level(s, v)) {}
        state_t(const state_t& other) = default;
 
        inline bool is_digital() const { return m_value & 0x01; }
        inline bool is_driven() const { return m_value & 0x04; }
 
        inline bool digital_value() const { return (m_value & 0x01) ? (m_value & 0x02) : (m_level > 0.5); }
 
        std::string to_string() const;
 
        inline bool operator==(StateEnum s) const { return m_value == s; }
        inline bool operator!=(StateEnum s) const { return m_value != s; }
        inline bool operator==(const state_t& s) const
        {
            return (s.m_value == m_value) && ((m_value != State_Analog) || (s.m_level == m_level));
        }
        inline bool operator!=(const state_t& s) const { return !(s == *this); }
 
        inline StateEnum value() const { return m_value; }
        inline double level() const { return m_level; }
 
        state_t& operator=(const state_t& other) = default;
 
    private:
 
        StateEnum m_value;
        double m_level;
 
        constexpr static double normalised_level(StateEnum s, double v)
        {
            //If the state is analog, trim the voltage to the correct range
            if (s == State_Analog) {
                if (v < 0.0) return 0.0;
                if (v > 1.0) return 1.0;
                else return v;
            }
            //If the state is digital, ensure the voltage level is consistent with the
            //digital level
            else if (s & 0x01) {
                return (s & 0x02) ? 1.0 : 0.0;
            }
            //Other cases : force to the default value
            else {
                return 0.5;
            }
        }
 
    };
 
    static StateEnum char2state(char c);
 
 
    enum SignalId {
        Signal_StateChange = 0,
 
        Signal_DigitalChange,
 
        Signal_VoltageChange,
    };
 
 
    Wire();
    Wire(Wire& other);
    Wire(const Wire& other);
    virtual ~Wire();
 
    DataSignal& signal();
 
    const state_t& state() const;
    bool digital_state() const;
    double voltage() const;
 
    void set_state(const state_t& state);
    void set_state(StateEnum state, double v = 0.0);
    void set_state(char state, double v = 0.0);
 
    void attach(Wire& other);
    void detach();
    bool attached(const Wire& other) const;
    bool attached() const;
    std::vector<Wire*> siblings() const;
 
    Wire& operator=(Wire& other);
    Wire& operator=(const Wire& other);
 
    static state_t resolve_two_states(const state_t& a, const state_t& b);
 
protected:
 
    void auto_resolve_state();
 
    virtual void notify_digital_state(bool state);
    virtual state_t state_for_resolution() const;
 
private:
 
    state_t m_state;
    state_t m_resolved_state;
    Wire* m_primary;
    std::vector<Wire*> m_secondaries;
    DataSignal m_signal;
 
    void resolve_state();
    void set_resolved_state(const state_t& s);
    void notify_resolved_state();
 
};
 
inline const Wire::state_t& Wire::state() const
{
    return m_resolved_state;
};
 
inline double Wire::voltage() const
{
    return m_resolved_state.level();
}
 
inline void Wire::set_state(StateEnum state, double level)
{
    set_state(state_t(state, level));
}
 
inline void Wire::set_state(char state, double level)
{
    set_state(state_t(char2state(state), level));
}
 
inline DataSignal& Wire::signal()
{
    return m_signal;
}
 
 
YASIMAVR_END_NAMESPACE
 
#endif //__YASIMAVR_WIRE_H__