dm32uv_interface.hh

#ifndef DM32UVINTERFACE_HH
#define DM32UVINTERFACE_HH
 
#include "usbserial.hh"
#include <QObject>
#include "dm32uv.hh"
 
 
class DM32UVInterface : public USBSerial
{
  Q_OBJECT
 
protected:
  struct Q_PACKED DeviceDetectionRequest {
    const char payload[7] = {'P','S','E','A','R','C','H'};
 
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
  };
 
  struct Q_PACKED DeviceDetectionResponse {
    uint8_t result;
    char payload[7];
 
    bool receive(DM32UVInterface *dev, const ErrorStack &err=ErrorStack());
    QString identifier() const;
  };
 
 
  struct Q_PACKED PasswordRequest {
    const char payload[7] = {'P', 'A', 'S', 'S', 'S', 'T', 'A'};
 
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
  };
 
  struct Q_PACKED PasswordResponse {
    uint8_t result;
    uint16_t code;
 
    bool receive(DM32UVInterface *dev, const ErrorStack &err=ErrorStack());
  };
 
 
  struct Q_PACKED SysinfoRequest {
    const char payload[7] = {'S','Y','S','I','N','F','O'};
 
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
  };
 
  struct Q_PACKED ACKResponse {
    uint8_t result;
 
    bool receive(DM32UVInterface *dev, const ErrorStack &err=ErrorStack());
  };
 
 
  struct Q_PACKED ValueRequest {
    enum class ValueId{
      FirmwareVersion = 0x1, BuildDate = 0x3, MainConfigMemory = 0xa, CallSignDBMemory = 0xf
    };
    const char request_type = 'V';
    const uint8_t unused[3] = {0x00, 0x00, 0x00};
    uint8_t valueId;
 
    ValueRequest(ValueId valueId);
    explicit ValueRequest(uint8_t valueId);
 
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
  };
 
  struct Q_PACKED ValueResponse {
    char response_type;
    uint8_t valueId;
    uint8_t length;
    union {
      struct {
        uint32_t lower;
        uint32_t upper;
      } memory;
      // Raw payload.
      uint8_t payload[255];
    };
 
    bool receive(DM32UVInterface *dev, const ErrorStack &err=ErrorStack());
    QString string() const;
    uint32_t lowerMemoryBound() const;
    uint32_t upperMemoryBound() const;
  };
 
 
  struct Q_PACKED EnterProgramModeRequest {
    const char payload[12] = {
      '\xff', '\xff', '\xff', '\xff', '\x0c',
      'P','R','O','G','R','A','M'
    };
 
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
  };
 
 
  struct Q_PACKED Unknown02Request {
    const char payload[1] {'\x02'};
 
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
   };
 
  struct Q_PACKED Unknown02Response {
    char payload[8];
 
    bool receive(DM32UVInterface *dev, const ErrorStack &err=ErrorStack());
  };
 
 
  struct Q_PACKED PingRequest {
    const char payload[1] = {'\x06'};
 
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
  };
 
 
  struct Q_PACKED ReadRequest {
    const char request_type = 'R';
    uint8_t address[3];
    uint16_t length;
 
    ReadRequest(uint32_t address, uint16_t length);
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
  };
 
  struct Q_PACKED ReadResponse {
    const char response_type = 'W';
    uint8_t _address[3];
    uint16_t _length;
    uint8_t _payload[4096];
 
    uint32_t address() const;
    uint16_t length() const;
    QByteArray payload() const;
 
    bool receive(DM32UVInterface *dev, const ErrorStack &err=ErrorStack());
  };
 
 
  struct Q_PACKED WriteRequest {
    const char request_type = 'W';
    uint8_t _address[3];
    uint16_t _length;
    uint8_t _payload[4096];
 
    WriteRequest(uint32_t address, const QByteArray &payload);
    bool send(DM32UVInterface *dev, const ErrorStack &err=ErrorStack()) const;
  };
 
 
protected:
  enum class State {
    Closed, Open, Connected, SystemInfo, Program, Error
  };
 
public:
  explicit DM32UVInterface(const USBDeviceDescriptor &descr,
                           const ErrorStack &err=ErrorStack(), QObject *parent=nullptr);
 
  RadioInfo identifier(const ErrorStack &err=ErrorStack()) override;
 
  bool getAddressMap(DM32UV::AddressMap &map, const ErrorStack &err=ErrorStack(),
                     void (*progress)(unsigned int percent)=nullptr);
 
  bool read_start(uint32_t bank, uint32_t address, const ErrorStack &err=ErrorStack()) override;
  bool read(uint32_t bank, uint32_t address, uint8_t *data, int nbytes, const ErrorStack &err=ErrorStack()) override;
  bool read_finish(const ErrorStack &err=ErrorStack()) override;
 
  bool write_start(uint32_t bank, uint32_t address, const ErrorStack &err=ErrorStack()) override;
  bool write(uint32_t bank, uint32_t address, uint8_t *data, int nbytes, const ErrorStack &err=ErrorStack()) override;
  bool write_finish(const ErrorStack &err=ErrorStack()) override;
 
public:
  static USBDeviceInfo interfaceInfo();
  static QList<USBDeviceDescriptor> detect(bool saveOnly=true);
 
protected:
  /*** Identifies the radio. */
  bool request_identifier(const ErrorStack &err = ErrorStack());
  bool enter_program_mode(const ErrorStack &err = ErrorStack());
  template<class Request, class Response>
  bool sendReceive(const Request &req, Response &res, const ErrorStack &err=ErrorStack()) {
    if (! req.send(this, err))
      return false;
    return res.receive(this, err);
  }
  bool send(const char *data, qint64 n, int timeout, const ErrorStack &err=ErrorStack());
  bool receive(char *data, qint64 n, int timeout, const ErrorStack &err=ErrorStack());
 
protected:
  State _state;
  RadioInfo _info;
  QString _firmwareVersion;
  QPair<uint32_t, uint32_t> _codeplugMemory;
  QPair<uint32_t, uint32_t> _callsignMemory;
};
 
#endif // DM32UVINTERFACE_HH