board.h

/* ########################################################################
 
   PICSimLab - Programmable IC Simulator Laboratory
 
   ########################################################################
 
   Copyright (c) : 2010-2024  Luis Claudio Gambôa Lopes <lcgamboa@yahoo.com>
 
   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, or (at your option)
   any later version.
 
   This program 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 this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
   For e-mail suggestions :  lcgamboa@yahoo.com
   ######################################################################## */
 
#ifndef BOARD_H
#define BOARD_H
 
#include <picsim/picsim.h>
#include <stdint.h>
 
#include <stdlib.h>
#include <string.h>
#include <string>
 
#define INCOMPLETE                                                      \
    printf("Incomplete: %s -> %s :%i\n", __func__, __FILE__, __LINE__); \
    exit(-1);
 
enum { ARCH_P16, ARCH_P16E, ARCH_P18, ARCH_AVR8, ARCH_STM32, ARCH_STM8, ARCH_C51, ARCH_Z80, ARCH_UNKNOWN };
 
typedef struct {
    float x1;               
    float x2;               
    float y1;               
    float y2;               
    float cx;               
    float cy;               
    char name[10];          
    unsigned short id;      
    void* status;           
    unsigned char* update;  
    union {
        unsigned char value;  
        short value_s;        
        float value_f;        
    };
} input_t;
 
typedef struct {
    float x1;              
    float x2;              
    float y1;              
    float y2;              
    float cx;              
    float cy;              
    float r;               
    char name[10];         
    unsigned short id;     
    void* status;          
    unsigned char update;  
    union {
        unsigned char value;  
        short value_s;        
        float value_f;        
    };
} output_t;
 
#define MAX_TIMERS 256
 
#define MAX_IDS 128
 
#define INVALID_ID (MAX_IDS - 1)
 
typedef struct {
    uint32_t Timer;
    uint32_t Reload;
    void* Arg;
    void (*Callback)(void* arg);
    int Enabled;
    double Tout;  // in us
} Timers_t;
 
class board {
public:
    virtual void Draw(void) = 0;
 
    virtual void Run_CPU(void) = 0;
 
    virtual std::string GetSupportedDevices(void) = 0;
 
    virtual std::string GetPictureFileName(void);
 
    virtual std::string GetMapFile(void);
 
    virtual void Reset(void) = 0;
 
    virtual void EvMouseButtonPress(unsigned int button, unsigned int x, unsigned int y, unsigned int state) = 0;
 
    virtual void EvMouseButtonRelease(unsigned int button, unsigned int x, unsigned int y, unsigned int state) = 0;
 
    virtual void EvMouseMove(unsigned int button, unsigned int x, unsigned int y, unsigned int state){};
 
    virtual void EvKeyPress(unsigned int key, unsigned int mask) = 0;
 
    virtual void EvKeyRelease(unsigned int key, unsigned int mask) = 0;
 
    virtual void EvOnShow(void);
 
    virtual void EvThreadRun(void){};
 
    virtual void RefreshStatus(void);
 
    virtual void WritePreferences(void){};
 
    virtual void ReadPreferences(char* name, char* value){};
 
    virtual unsigned short GetInputId(char* name) = 0;
 
    virtual unsigned short GetOutputId(char* name) = 0;
 
    virtual void board_Event(const char* controlname){};
 
    virtual void board_ButtonEvent(const char* controlname, unsigned int button, unsigned int x, unsigned int y,
                                   unsigned int state){};
 
    board(void);
 
    virtual ~board(void);
 
    void SetUseOscilloscope(int uo);
 
    void SetUseSpareParts(int sp);
 
    int GetUseOscilloscope(void);
 
    int GetUseSpareParts(void);
 
    virtual std::string GetName(void) = 0;
 
    void SetProcessorName(std::string proc);
 
    std::string GetProcessorName(void);
 
    int GetInputCount(void);
 
    input_t* GetInput(int n);
 
    int GetOutputCount(void);
 
    output_t* GetOutput(int n);
 
    virtual int DebugInit(int dtyppe) = 0;
 
    virtual std::string GetDebugName(void) = 0;
 
    virtual std::string GetAboutInfo(void) = 0;
 
    virtual void DebugLoop(void) = 0;
 
    virtual int CpuInitialized(void) = 0;
 
    virtual void MSetSerial(const char* port) = 0;
 
    virtual int MInit(const char* processor, const char* fname, float freq) = 0;
 
    virtual void MEnd(void) = 0;
 
    virtual int MGetArchitecture(void) = 0;
 
    virtual void EndServers(void){};
 
    virtual int MDumpMemory(const char* fname) = 0;
 
    virtual void MEraseFlash(void) = 0;
 
    virtual void MSetFreq(float freq) = 0;
 
    virtual float MGetFreq(void) = 0;
 
    virtual void MSetVCC(float vcc) = 0;
 
    virtual float MGetVCC(void) = 0;
 
    virtual float MGetInstClockFreq(void) = 0;
 
    virtual int MGetPinCount(void) = 0;
 
    virtual std::string MGetPinName(int pin) = 0;
 
    virtual void MSetPin(int pin, unsigned char value) = 0;
 
    virtual void MSetPinDOV(int pin, unsigned char ovalue) = 0;
 
    virtual void MSetAPin(int pin, float value) = 0;
 
    virtual unsigned char MGetPin(int pin) = 0;
 
    virtual const picpin* MGetPinsValues(void) = 0;
 
    virtual void MStep(void) = 0;
 
    virtual void MStepResume(void) = 0;
 
    virtual void MReset(int flags) = 0;
 
    virtual unsigned short* DBGGetProcID_p(void) {
        INCOMPLETE;
        return NULL;
    };
 
    virtual unsigned int DBGGetPC(void) {
        INCOMPLETE;
        return 0;
    };
 
    virtual void DBGSetPC(unsigned int pc) { INCOMPLETE; };
 
    virtual unsigned char* DBGGetRAM_p(void) {
        INCOMPLETE;
        return NULL;
    };
 
    virtual unsigned char* DBGGetROM_p(void) {
        INCOMPLETE;
        return NULL;
    };
 
    virtual unsigned char* DBGGetCONFIG_p(void) {
        INCOMPLETE;
        return NULL;
    };
 
    virtual unsigned char* DBGGetID_p(void) {
        INCOMPLETE;
        return NULL;
    };
 
    virtual unsigned char* DBGGetEEPROM_p(void) {
        INCOMPLETE;
        return NULL;
    };
 
    virtual unsigned int DBGGetRAMSize(void) {
        INCOMPLETE;
        return 0;
    };
 
    virtual unsigned int DBGGetROMSize(void) {
        INCOMPLETE;
        return 0;
    };
 
    virtual unsigned int DBGGetCONFIGSize(void) {
        INCOMPLETE;
        return 0;
    };
 
    virtual unsigned int DBGGetIDSize(void) {
        INCOMPLETE;
        return 0;
    };
 
    virtual unsigned int DBGGetEEPROM_Size(void) {
        INCOMPLETE;
        return 0;
    };
 
    virtual unsigned int DBGGetRAMLAWR(void) {
        INCOMPLETE;
        return 0;
    };
 
    virtual unsigned int DBGGetRAMLARD(void) {
        INCOMPLETE;
        return 0;
    };
 
    unsigned char CalcAngle(int i, int x, int y);
 
    virtual void SetScale(double scale);
 
    double GetScale(void);
 
    virtual int GetDefaultClock(void) { return 2; };
 
    std::string GetDefaultProcessor(void) { return DProc; };
 
    void SetDefaultProcessor(std::string dproc) { DProc = dproc; };
 
    uint32_t GetInstCounter(void) { return InstCounter; };
 
    uint32_t GetInstCounter_us(const uint32_t start);
 
    uint32_t GetInstCounter_ms(const uint32_t start);
 
    int TimerRegister_us(const double micros, void (*Callback)(void* arg), void* arg);
 
    int TimerRegister_ms(const double miles, void (*Callback)(void* arg), void* arg);
 
    int TimerUnregister(const int timer);
 
    int TimerChange_us(const int timer, const double micros);
 
    int TimerChange_ms(const int timer, const double miles);
 
    int TimerSetState(const int timer, const int enabled);
 
    uint64_t TimerGet_ns(const int timer);
 
    void TimerUpdateFrequency(float freq);
 
    virtual void IoLockAccess(void){};
 
    virtual void IoUnlockAccess(void){};
 
    virtual int GetUARTRX(const int uart_num) { return 0; };
 
    virtual int GetUARTTX(const int uart_num) { return 0; };
 
    virtual std::string GetClkLabel(void) { return "Clk (Mhz)"; };
 
protected:
    virtual void RegisterRemoteControl(void){};
 
    void InstCounterInc(void);
 
    std::string Proc;               
    std::string DProc;              
    input_t input[MAX_IDS];         
    input_t* input_ids[MAX_IDS];    
    output_t output[MAX_IDS];       
    output_t* output_ids[MAX_IDS];  
    int inputc;                     
    int outputc;                    
    int use_oscope;                 
    int use_spare;                  
    unsigned char p_RST;            
    float Scale;
 
    void ReadMaps(void);
 
    void StartThread(void);
 
    void StopThread(void);
 
private:
    uint32_t InstCounter;
    int TimersCount;
    Timers_t Timers[MAX_TIMERS];
    Timers_t* TimersList[MAX_TIMERS];
 
    void ReadInputMap(std::string fname);
 
    void ReadOutputMap(std::string fname);
};
 
extern int ioupdated;
 
#endif /* BOARD_H */
 
#ifndef BOARDS_DEFS_H
#define BOARDS_DEFS_H
 
#define board_init(name, function)                                  \
    static board* function##_create(void) {                         \
        board* b = new function();                                  \
        b->SetDefaultProcessor(b->GetProcessorName());              \
        return b;                                                   \
    };                                                              \
    static void __attribute__((constructor)) function##_init(void); \
    static void function##_init(void) {                             \
        board_register(name, function##_create);                    \
    }
 
typedef board* (*board_create_func)(void);
 
void board_register(const char* name, board_create_func bcreate);
 
// boards object creation
board* create_board(int* lab, int* lab_);
 
#define BOARDS_MAX 25
 
extern int BOARDS_LAST;
 
typedef struct {
    char name[30];   // name
    char name_[30];  // name without spaces
    board_create_func bcreate;
} board_desc;
 
extern board_desc boards_list[BOARDS_MAX];
 
// Arduino Uno is the dafault board
#define DEFAULT_BOARD 2
 
#endif /* BOARDS_DEFS_H */