sim_pin.h

Go to the documentation of this file.

/*
 * sim_pin.h
 *
 *  Copyright 2021-2026 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_PIN_H__
#define __YASIMAVR_PIN_H__
 
#include "sim_wire.h"
 
YASIMAVR_BEGIN_NAMESPACE
 
 
//=======================================================================================
 
typedef sim_id_t pin_id_t;
 
 
class PinManager;
 
 
class AVR_CORE_PUBLIC_API Pin : public Wire {
 
public:
 
    struct controls_t {
 
        unsigned char dir = 0;
        unsigned char drive = 0;
        bool inverted = false;
        bool pull_up = false;
 
    };
 
    explicit Pin(pin_id_t id);
 
    pin_id_t id() const;
 
    void set_external_state(const state_t& state);
    void set_external_state(StateEnum state, double level = 0.0);
    void set_external_state(char state, double level = 0.0);
 
    void set_gpio_controls(const controls_t& controls);
    controls_t gpio_controls() const;
 
    Pin(const Pin&) = delete;
    Pin& operator=(const Pin&) = delete;
 
private:
 
    friend class PinManager;
    friend class PinDriver;
 
    pin_id_t m_id;
    controls_t m_gpio_controls;
    state_t m_gpio_state;
    PinManager* m_manager;
 
    virtual void notify_digital_state(bool state) override;
    virtual state_t state_for_resolution() const override;
 
    void update_pin_state();
 
};
 
 
inline pin_id_t Pin::id() const
{
    return m_id;
}
 
inline void Pin::set_external_state(const state_t& state)
{
    set_state(state);
}
 
inline void Pin::set_external_state(StateEnum state, double level)
{
    set_state(state, level);
}
 
inline void Pin::set_external_state(char state, double level)
{
    set_state(state, level);
}
 
inline Pin::controls_t Pin::gpio_controls() const
{
    return m_gpio_controls;
}
 
 
//=======================================================================================
 
class AVR_CORE_PUBLIC_API PinDriver {
 
public:
 
    typedef unsigned int pin_index_t;
 
    PinDriver(ctl_id_t id, pin_index_t pin_count);
    virtual ~PinDriver();
 
    void set_enabled(bool enabled);
    void set_enabled(pin_index_t index, bool enabled);
    bool enabled(pin_index_t index) const;
 
    void update_pin_state(pin_index_t pin_index);
    void update_pin_states();
 
    Wire::state_t pin_state(pin_index_t pin_index) const;
    Pin::controls_t gpio_controls(pin_index_t pin_index) const;
 
    PinDriver(const PinDriver&) = delete;
    PinDriver& operator=(const PinDriver&) = delete;
 
    virtual Pin::controls_t override_gpio(pin_index_t pin_index, const Pin::controls_t& controls) = 0;
 
    virtual void digital_state_changed(pin_index_t pin_index, bool state);
 
private:
 
    friend class PinManager;
 
    ctl_id_t m_id;
    PinManager* m_manager;
    pin_index_t m_pin_count;
    Pin** m_pins;
 
};
 
 
//=======================================================================================
 
class AVR_CORE_PUBLIC_API PinManager {
 
public:
 
    typedef sim_id_t mux_id_t;
    static constexpr mux_id_t default_mux_id = "DEFAULT";
 
    explicit PinManager(const std::vector<pin_id_t>& pin_ids);
    ~PinManager();
 
    bool register_driver(PinDriver& drv);
    bool add_mux_config(ctl_id_t drv, const std::vector<pin_id_t>& pins, mux_id_t mux_id = default_mux_id);
 
    void set_current_mux(ctl_id_t drv, mux_id_t index);
    void set_current_mux(ctl_id_t drv, PinDriver::pin_index_t, mux_id_t index);
    mux_id_t current_mux(ctl_id_t drv, PinDriver::pin_index_t pin_index) const;
    std::vector<pin_id_t> current_mux_pins(ctl_id_t drv) const;
 
    Pin* pin(pin_id_t pin_id) const;
 
    PinManager(const PinManager&) = delete;
    PinManager& operator=(const PinManager&) = delete;
 
private:
 
    friend class Pin;
    friend class PinDriver;
 
    struct pin_entry_t;
    struct drv_entry_t;
 
    std::unordered_map<pin_id_t, pin_entry_t*> m_pins;
    std::unordered_map<ctl_id_t, drv_entry_t*> m_drivers;
 
    void add_driver_to_pin(pin_entry_t& pin_entry, PinDriver& drv, PinDriver::pin_index_t index);
    void remove_driver_from_pin(pin_entry_t& pin_entry, PinDriver& drv, PinDriver::pin_index_t index);
 
    Wire::state_t override_gpio(pin_id_t pin_id, const Pin::controls_t& gpio_controls);
    void notify_digital_state(pin_id_t pin_id, bool state);
    void set_current_pin_mux(drv_entry_t& drv, PinDriver::pin_index_t index, mux_id_t mux_id);
    void set_driver_enabled(PinDriver& drv, PinDriver::pin_index_t index, bool enabled);
    bool driver_enabled(const PinDriver& drv, PinDriver::pin_index_t index) const;
    void unregister_driver(PinDriver& drv);
 
};
 
 
YASIMAVR_END_NAMESPACE
 
#endif //__YASIMAVR_PIN_H__