opengd77_interface.hh

#ifndef OPENGD77INTERFACE_HH
#define OPENGD77INTERFACE_HH
 
#include "usbserial.hh"
#include "errorstack.hh"

class OpenGD77Interface : public USBSerial
{
  Q_OBJECT
 
public:
  static const uint32_t EEPROM = 0;
  static const uint32_t FLASH  = 1;

  enum class Variant {
    GD77, UV380
  };
 
public:
  explicit OpenGD77Interface(const USBDeviceDescriptor &descr,
                             const ErrorStack &err=ErrorStack(), QObject *parent=nullptr);
  virtual ~OpenGD77Interface();

  void close();

  RadioInfo identifier(const ErrorStack &err=ErrorStack());

  bool extendedCallsignDB() const;
 
  bool read_start(uint32_t bank, uint32_t addr, const ErrorStack &err=ErrorStack());
  bool read(uint32_t bank, uint32_t addr, uint8_t *data, int nbytes, const ErrorStack &err=ErrorStack());
  bool read_finish(const ErrorStack &err=ErrorStack());
 
  bool write_start(uint32_t bank, uint32_t addr, const ErrorStack &err=ErrorStack());
  bool write(uint32_t bank, uint32_t addr, uint8_t *data, int nbytes, const ErrorStack &err=ErrorStack());
  bool write_finish(const ErrorStack &err=ErrorStack());
 
  bool setDateTime(const QDateTime &datetime, const ErrorStack &err);
 
  bool saveSettingsNotVFOs(const ErrorStack &err=ErrorStack());
  bool saveSettingsAndVFOs(const ErrorStack &err=ErrorStack());
  bool reboot(const ErrorStack &err=ErrorStack());
 
public:
  static USBDeviceInfo interfaceInfo();
  static QList<USBDeviceDescriptor> detect(bool saveOnly=true);
 
protected:
  struct __attribute__((packed)) ReadRequest {
    enum Command {
      READ_FLASH = 1,
      READ_EEPROM = 2,
      READ_MCU_ROM = 5,
      READ_DISPLAY_BUFFER = 6,
      READ_WAV_BUFFER = 7,
      READ_AMBE_BUFFER = 8,
      READ_FIRMWARE_INFO = 9
    };

    char type;
    uint8_t command;
    uint32_t address;
    uint16_t length;

    bool initReadFlash(uint32_t address, uint16_t length);
    bool initReadEEPROM(uint32_t address, uint16_t length);
    bool initReadFirmwareInfo();
  };

  struct __attribute__((packed)) FirmwareInfo {
    enum class RadioType {
      GD77=0, GD77S=1, DM1801=2, RD5R=3, DM1801A=4, MD9600=5,
      MDUV380=6, MD380=7, DM1701=8, MD2017=9, DM1701RGB=10
    };
 
    uint32_t structVersion;   
    uint32_t radioType;       
    char fw_revision[16];     
    char build_date[16];      
    uint32_t flashChipSerial; 
    uint16_t features;        

    bool featureInvertedDisplay() const;
    bool featureExtendedCallsignDB() const;
    bool featureVoicePromptLoaded() const;
  };

  struct __attribute__((packed)) ReadResponse {
    char type;
    uint16_t length;
    union {
      uint8_t data[32];    
      FirmwareInfo info;   
    };
  };

  struct __attribute__((packed)) WriteRequest {
    enum Command {
      SET_FLASH_SECTOR = 1,
      WRITE_SECTOR_BUFFER = 2,
      WRITE_FLASH_SECTOR = 3,
      WRITE_EEPROM = 4,
      WRITE_WAV_BUFFER = 7
    };

    char type;
    uint8_t command;
 
    union {
      uint8_t sector[3];
      struct __attribute__((packed)) {
        uint32_t address;
        uint16_t length;
        uint8_t data[32];
      } payload;
    };

    bool initWriteEEPROM(Variant variant, uint32_t addr, const uint8_t *data, uint16_t size);
    bool initSetFlashSector(Variant variant, uint32_t addr);
    bool initWriteFlash(Variant variant, uint32_t addr, const uint8_t *data, uint16_t size);
    bool initFinishWriteFlash(Variant variant);
  };

  struct __attribute__((packed)) WriteResponse {
    char type;
    uint8_t command;
  };

  struct __attribute__((packed)) CommandRequest {
    enum Command {
      SHOW_CPS_SCREEN  = 0,
      CLEAR_SCREEN     = 1,
      DISPLAY          = 2,
      RENDER_CPS       = 3,
      CLOSE_CPS_SCREEN = 5,
      COMMAND          = 6
    };

    enum Option {
      SAVE_SETTINGS_NOT_VFOS = 0,
      REBOOT = 1,
      SAVE_SETTINGS_AND_VFOS = 2,
      FLASH_GREEN_LED = 3,
      FLASH_RED_LED = 4,
      INIT_CODEC = 5,
      INIT_SOUND = 6,
      SET_DATETIME = 7,
      DELAY_10ms = 10
    };

    char type;
    uint8_t command;
    union {
      uint8_t x;
      uint8_t option;
    };
    // Either some text options or a timestamp.
    union {
      struct __attribute__((packed)) {
        uint8_t y;
        uint8_t font;
        uint8_t alignment;
        uint8_t inverted;
      };
      uint32_t timestamp;
    };

    char message[16];

    void initShowCPSScreen();
    void initClearScreen();
    void initDisplay(uint8_t x, uint8_t y, const char *message, unsigned int iSize,
                     uint8_t font, uint8_t alignment, uint8_t inverted);
    void initRenderCPS();
    void initCloseScreen();
    void initCommand(Option option);
    void initSetDateTime(const QDateTime &dt);
  };
 
protected:
  bool readEEPROM(uint32_t addr, uint8_t *data, uint16_t len, const ErrorStack &err=ErrorStack());
  bool writeEEPROM(uint32_t addr, const uint8_t *data, uint16_t len, const ErrorStack &err=ErrorStack());

  bool readFlash(uint32_t addr, uint8_t *data, uint16_t len, const ErrorStack &err=ErrorStack());
  bool setFlashSector(uint32_t addr, const ErrorStack &err=ErrorStack());
  bool writeFlash(uint32_t addr, const uint8_t *data, uint16_t len, const ErrorStack &err=ErrorStack());
  bool finishWriteFlash(const ErrorStack &err=ErrorStack());

  bool readFirmwareInfo(FirmwareInfo &radioInfo, const ErrorStack &err=ErrorStack());

  bool sendShowCPSScreen(const ErrorStack &err=ErrorStack());
  bool sendClearScreen(const ErrorStack &err=ErrorStack());
  bool sendDisplay(uint8_t x, uint8_t y, const char *message, uint8_t iSize, uint8_t alignment, uint8_t inverted, const ErrorStack &err=ErrorStack());
  bool sendRenderCPS(const ErrorStack &err=ErrorStack());
  bool sendCloseScreen(const ErrorStack &err=ErrorStack());
  bool sendSetDateTime(const QDateTime &dt, const ErrorStack &err=ErrorStack());
  bool sendCommand(CommandRequest::Option option, const ErrorStack &err=ErrorStack());
 
protected:
  Variant _protocolVariant;
  bool _extendedCallsignDB;
  int32_t _sector;
};
 
#endif // OPENGD77INTERFACE_HH