modularization/src/driver/driver_gps_cookoo_f9k/cookoo_sdk.h

/*
 * Copyright : Cookoo Science, All Rights Reserved ©2022
 *
 * cookoo_sdk.h
 *
 * Author cookoo
 */
#ifndef COOKOO_SDK
#define COOKOO_SDK

/* COOKOO SDK 设备接口
*    设备包含:
*    CAN   * 5
*        CAN0-CAN1 支持波特率, 支持扩展帧 或者使用linux/can/raw
*        CAN2-CAN4 固定波特率500k, 不支持设置波特率, 不支持扩展帧
*    IO    * 8
         输入口 * 4
		 输出口 * 4
*    ADC   * 2
*
*    RS232 * 2
*        封装MCU上的232,
*        封装ARM上的232设备，可使用本接口，或使用/dev/下的设备符
*    RS485 * 1
*        封装ARM上的485设备，可使用本接口，或使用/dev/下的设备符
*
*    相机 * 8
*        封装ARM上的video(/dev/video*)
*/
namespace cookoo {

// CAN设备
class Ck_Can
{
public:
    // COOKOO CAN设备ID*5
    enum CK_CAN {
        CK_CAN0 = 0,
        CK_CAN1,
        CK_CAN2,
        CK_CAN3,
        CK_CAN4,
    };
    struct ck_can_frame {
        uint32_t can_id;  /* 32 bit CAN_ID + EFF/RTR/ERR flags */
        uint8_t  can_dlc; /* frame payload length in byte (0 .. CAN_MAX_DLEN) */
        uint8_t  data[8] __attribute__((aligned(8)));
    };

public:
    /**
     * @fn     (Ck_Can)
     * @brief  
     * @param  CAN通道号, 波特率
     * @return None
     */
	Ck_Can(CK_CAN can_ch, int rate);

	/**
     * @fn     (~Ck_Can)
     * @brief  
     * @param  None
     * @return None
     */
	~Ck_Can();

public:
    /**
    * @fn     (Ck_Can::Read)
    * @brief  数据读取
    * @param  data: can frame to read,
    * @return 读取长度
    */
	int Read(ck_can_frame& data);

	/**
    * @fn     (Ck_Can::Write)
    * @brief  数据写入
    * @param  data: can frame to read,
    * @return 写入长度
    */
	int Write(const ck_can_frame& data);

private:
    // 对象不支持 拷贝/移动/赋值
	Ck_Can(const Ck_Can&) = delete;
	Ck_Can(Ck_Can&&) = delete;
	void operator=(const Ck_Can&) = delete;
	void operator=(Ck_Can&&) = delete;
private:
    void* m_performer = nullptr;
};

// GPIO+AD
class Ck_Pin
{
public:
    // GPIO * 8, 输入口*4, 输出口*4
    enum CK_PIN {
        CK_PIN_I1,
        CK_PIN_I2,
        CK_PIN_I3,
        CK_PIN_I4,
        CK_PIN_O1,
        CK_PIN_O2,
        CK_PIN_O3,
        CK_PIN_O4
    };

    // AD 电压检测口*2
    enum CK_AD {
        CK_AD_1,
        CK_AD_2,
    };

public:
	/**
    * @fn     (Ck_Pin)
    * @brief
    * @param  None
    * @return None
    */
    Ck_Pin();

	/**
    * @fn     (~Ck_Pin)
    * @brief
    * @param  None
    * @return None
    */
    ~Ck_Pin();

	/**
    * 暂不支持
    * @fn     (Ck_Pin::Set)
    * @brief  设置管脚-只支持O1~O4设置
    * @param  idx: GPIO index, value: 1-High, 0-Low
    * @return true:OK, false:Failed
    */
    bool  Set(CK_PIN idx, bool value);

	/**
    * @fn     (Ck_Pin::Get)
    * @brief  获取GPIO状态
    * @param  idx: GPIO index
    * @return 1:High, 0:Low
    */
    bool  Get(CK_PIN idx);

	/**
    * @fn     (Ck_Pin::Get)
    * @brief  获取AD电压
    * @param  idx: AD index
    * @return 电压值 单位V
    */
	float Get(CK_AD ad_id);

    const char* Check();

private:
    // 对象不支持 拷贝/移动/赋值
	Ck_Pin(const Ck_Pin&) = delete;
	Ck_Pin(Ck_Pin&&) = delete;
	void operator=(const Ck_Pin&) = delete;
	void operator=(Ck_Pin&&) = delete;
private:
    void* m_performer = nullptr;
};

// 串口
class Ck_Serial
{
public:
    // 串口设备: RS232 * 2, RS485 * 1
    enum CK_SERIAL {
        CK_SERIAL_RS232_1,// ARM
        CK_SERIAL_RS232_2,// MCU, 固定波特率
        CK_SERIAL_RS485_0 // ARM
    };

public:
    /**
    * @fn     (Ck_Serial)
    * @brief  
    * @param  port: Serial port
	*         rate: Serial bitrate
    *               CK_SERIAL_RS232_0, 固定波特率, 此参数无效 
    * @return None
    */
    explicit Ck_Serial(CK_SERIAL port, int rate);

	/**
    * @fn     (~Ck_Serial)
    * @brief  
    * @param  None
    * @return None
    */
    ~Ck_Serial();

public:
/**
    * @fn     (Ck_Serial::Read)
    * @brief  数据读取
    * @param  data: buffer to read,
	*         len : max length of data
    * @return 读取长度
    */
	int Read(void* data, int len);

	/**
    * @fn     (Ck_Serial::Write)
    * @brief  数据写入
    * @param  data: buffer to read,
	*         len : length of data
    * @return 写入长度
    */
	int Write(const void* data, int len);

private:
    // 对象不支持 拷贝/移动/赋值
    Ck_Serial(const Ck_Serial&) = delete;
    Ck_Serial(Ck_Serial&&) = delete;
    void operator=(const Ck_Serial&) = delete;
    void operator=(Ck_Serial&&) = delete;
private:
    void* m_performer = nullptr;
};

// 设置激光雷达电源开关
/**
* @fn     (Set_Power)
* @brief  设置激光雷达供电开关
* @param   ch:通道1-4
           sw: 开关 0-1
*/
void Set_Power(uint8_t ch, bool sw);

// 相机外触发
/**
* @fn     (Set_Poe)
* @brief  设置POE供电开关
* @param  sw: 开关 0-1
*/
void Set_Poe(bool sw);
/**
* @fn     (Cam_Trigger_On)
* @brief  相机外触发开
* @param  channel: 相机线束通道 0-1
*         rate   : 帧率
*         duty   : 占空比
*/
void Cam_Trigger_On(uint8_t channel, uint16_t rate, uint8_t duty);
/**
* @fn     (Cam_Trigger_Off)
* @brief  相机外触发关
* @param  channel: 相机线束通道 0-1
*/
void Cam_Trigger_Off(uint8_t channel);

//相机设备
class Ck_Cam
{
public:
    /**
    * @st     (Ck_Frame)
    * @brief  相机图像帧数据
    * @param  cnt: 帧序号
    *         size:数据大小
    *         data:数据
    *         type:图像格式
    *              1-YUYV
    *              2-UYVY
    */
    typedef struct _st_ck_frame_
    {
        unsigned int cnt;
        unsigned int size;
        unsigned char* data;
        unsigned char type;
    } Ck_Frame;

public:
    /**
    * @fn     (Ck_Cam::Ck_Cam)
    * @brief  相机设备类构造
    * @param  dev:设备描述符
    *         w:分辨率-宽
    *         h:分辨率-高
    *         fps:帧率
    */
    Ck_Cam(const std::string& dev, int w, int h, int fps);

    /**
    * @fn     (Ck_Cam::~Ck_Cam)
    * @brief  相机设备类析构
    */
    ~Ck_Cam();

    /**
    * @fn     (Ck_Cam::Start)
    * @brief  相机设备对象开始运行
    */
    void Start();

    /**
    * @fn     (Ck_Cam::Stop)
    * @brief  相机设备对象停止运行
    */
    void Stop();

    /**
    * @fn     (Ck_Cam::GetFrame)
    * @brief  相机设备获取图像
    * @return 图像数据       
    */
    Ck_Frame GetFrame();

private:
    std::string m_dev;
    int m_w;
    int m_h;
    int m_fps;
    void* m_performer = nullptr;

private:
    // 对象不支持 拷贝/移动/赋值
    Ck_Cam(const Ck_Cam&) = delete;
    Ck_Cam(Ck_Cam&&) = delete;
    void operator=(const Ck_Cam&) = delete;
    void operator=(Ck_Cam&&) = delete;
};

class Ck_GPS
{
public:
    static Ck_GPS* GetInstance();
    static void    DelInstance();

    /**
    * @fn     (Ck_GPS::Start)
    * @brief  开始运行
    * @param  
    * @return None
    */
	void Start();

    /**
    * @fn     (Ck_GPS::Start)
    * @brief  停止运行
    * @param  
    * @return None
    */
	void Stop();

    /**
    * @fn     (Ck_GPS::Calibrate)
    * @brief  F9K配置标定参数
    *         x1, y1, z1 惯导到后轮中心,参数单位为 cm
    *         x2, y2, z2 惯导到定位天线,参数单位为 cm
    *         e 量取杆臂值的配置误差, 可填0
    * @param  
    * @return None
    */
	void Set_Calibrate(
        float x1, float y1, float z1, 
        float x2, float y2, float z2, 
        float e);

    /**
    * @fn     (Ck_GPS::Save_Calibrate)
    * @brief  保存标定结果
    * @return true:保存成功,false:保存失败
    */
    bool Save_Calibrate();

    /**
    * @fn     (Ck_GPS::Set_Ntrip)
    * @brief  配置nrtip服务器
    *         不使用RTK可不调用此接口
    * @param  
    * @return None
    */
	void Set_Ntrip(std::string const& ip, int port,
      std::string const& user, std::string const& passwd,
      std::string const& mountpoint);

    /**
    * @fn     (Ck_GPS::Set_IMU_DATA_OUT)
    * @brief  设置IMU数据输出
    * @param  freq 0-100, 0:不输出,其他:输出频率
    * @return None
    */
	void Set_IMU_DATA_OUT(uint8_t freq);

    /**
    * @fn     (Ck_GPS::Read_GPS)
    * @brief  定位数据读取 支持NMEA格式:GGA,RMC输出
    * @param  None
    * @return 定位数据
    */
	std::string Read_GPS();

    /**
    * @fn     (Ck_GPS::Get_IMU_STATE)
    * @brief  获取IMU状态
    * @return  
    *         bit7-4 Automatic IMU-mount alignment on/off 
    *           0:automatic alignment is not running, 
    *           1:automatic alignment is running
    *         bit3-0 Status of IMU-mount alignment
    *           0:user-defined/fixed angles are used, 
    *           1:IMU-mount roll/pitch angles alignment is ongoing, 
    *           2:IMU-mount roll/pitch/yaw angles alignment is ongoing, 
    *           3:coarse IMU-mount alignment are used, 
    *           4:fine IMU-mount alignment are used
    */
	uint8_t Get_IMU_STATE();

    /**
    * @fn     (Ck_GPS::Read_IMU_DATA)
    * @brief  IMU数据读取
    * @param  acc_x m/s2
    * @param  acc_y m/s2
    * @param  acc_z m/s2
    * @param  gyr_x m/s2
    * @param  gyr_y m/s2
    * @param  gyr_z m/s2
    * @return none
    */
	void Read_IMU_DATA(float& acc_x, float& acc_y, float& acc_z, 
        float& gyr_x, float& gyr_y, float& gyr_z);

    /**
    * @fn     (Ck_GPS::Set_SPD_IN_MOD)
    * @brief  车速输入模式
    * @param  mod输入模式 
    *           0-不输入, 
    *           1-软件接口输入
    *           2-硬件接口输入
    * @return none
    */
	void Set_SPD_IN_MOD(uint8_t mod);

    /**
    * @fn     (Ck_GPS::Send_SPD)
    * @brief  发送车速
    * @param  spd-车速  精度*1000 单位m/s
    *           使用Set_SPD_IN_MOD(1)设置软件接口输入,
    *           再使用此接口传入车速, 输入频率>=10HZ
    * @return none
    */
	void Send_SPD(int spd);

    /**
    * @fn     (Ck_GPS::Set_NMEA_FREQ)
    * @brief  设置NMEA输出频率
    * @param  freq: 输出频率 0, 1, 10, 20, 30 Hz
    * @return none
    */
	void Set_NMEA_FREQ(uint8_t freq);

    /**
    * @fn     (Ck_GPS::Set_NMEA_MSG)
    * @brief  设置NMEA报文输出开关
    * @param  name: "GGA", "RMC"...
    *         output: 0-关, 1-开
    * @return none
    */
	void Set_NMEA_MSG(const std::string& name, bool output);

    /**
     * @fn     (~Ck_GPS)
     * @brief  
     * @param  None
     * @return None
     */
	~Ck_GPS();

private:
    Ck_GPS();
    // 对象不支持 拷贝/移动/赋值
	Ck_GPS(const Ck_GPS&) = delete;
	Ck_GPS(Ck_GPS&&) = delete;
	void operator=(const Ck_GPS&) = delete;
	void operator=(Ck_GPS&&) = delete;
private:
    static Ck_GPS* m_instance;
};

}

#endif /* COOKOO_SDK */