YANRUS系列设备开发文档

unsigned short int CRC_Test(unsigned char* HEX, int len)
{
    unsigned short int ret = 0xFFFF;
    unsigned char i;
    while(len--){
        ret ^= *HEX++;
        for(i = 0; i < 8; i++){
            if(ret & 0x0001)
                ret = (ret >> 1) ^ 0xA001;
            else
                ret >>= 1;
        }
    }
    return ret;
}

typedef enum {
    State_Wait = 0x00,                  // The data is suspended in this state 
    State_Ready = 0x01,                 // The data is ready in this state 
    State_Run = 0x02                    // The data is processed in this state 
} Data_StateTypedef;

typedef struct Dev_Data {
    Data_StateTypedef state;            // Current status of Dev_Data 
    unsigned short int data;            // Data of Dev_Data 
    unsigned short int Address;         // Address of Dev_Data 
    unsigned char Arr[200];             // The data buffer of Dev_Data 
    void (*Data_Deal)(void);            // Dev_Data's data processing function 
} Dev_Data;

// CRC check function 
// HEX : Pointer to input data 
// len : Length of the input data 
// return : CRC Results 
unsigned short int CRC_Test(unsigned char *HEX, int len)
{
    unsigned short int ret = 0xFFFF;
    unsigned char i;
    while(len--)
    {
        ret ^= *HEX++;
        for(i = 0; i < 8; i++)
        {
            if(ret & 0x0001)
                ret = (ret >> 1) ^ 0xA001;
            else
                ret >>= 1;
        }
    }
    return ret;
}

// Check whether the two HEX data are consistent 
// str1 : Pointer to input data1 
// len1 : Length of the input data1 
// str2 : Pointer to input data2 
// len2 : Length of the input data2 
// return : Check Results 
unsigned char My_StrStr(unsigned char *str1, int len1, unsigned char *str2, int len2)
{
    int i, j;
    if(len1 <= 0 || len2 <= 0) return 0;
    if(len2 > len1) return 0;
    for(i = 0; i <= len1 - len2; i++)
    {
        for(j = 0; j < len2; j++)
            if(str1[i + j] != str2[j]) break;
        if(j == len2) return 1;
    }
    return 0;
}

// Send data to the device 
// Address : Address of the target data 
// Wdata : Target data 
// pData : Sent and returned data 
// return : None 
void SendDataToDev(unsigned short int Address, unsigned short int Wdata, unsigned char *pData)
{
    unsigned short int CRC_Da;
    unsigned int i;
    pData[0] = 0x02;
    pData[1] = 0x06;
    pData[2] = (unsigned char)((Address & 0xFF00) >> 8);
    pData[3] = (unsigned char)(Address & 0x00FF);
    pData[4] = (unsigned char)((Wdata & 0xFF00) >> 8);
    pData[5] = (unsigned char)(Wdata & 0x00FF);
    CRC_Da = CRC_Test(pData, 6);
    pData[6] = (unsigned char)(CRC_Da & 0x00FF);
    pData[7] = (unsigned char)((CRC_Da & 0xFF00) >> 8);
    // Send characters one by one on Serial Port 2 
    for(i = 0; i < 8; i++)
        Usart2_SendByte(pData[i]);
}

// Get data from the device 
// return : None 
void GetDataFromDev(void)
{
    unsigned char data[8];
    unsigned short int CRC_Da;
    unsigned int i;
    data[0] = 0x02;
    data[1] = 0x03;
    data[2] = 0x00;
    data[3] = 0x00;
    data[4] = 0x00;
    data[5] = 0x40;
    CRC_Da = CRC_Test(data, 6);
    data[6] = (unsigned char)(CRC_Da & 0x00FF);
    data[7] = (unsigned char)((CRC_Da & 0xFF00) >> 8);
    // Send characters one by one on Serial Port 2 
    for(i = 0; i < 8; i++)			
        Usart2_SendByte(data[i]);
}

// Define a global variable, here taking Contator_On as an example
Dev_Data Contator_On;

void ops_Contator_On(void)			// Contator_On's data processing function
{
    // If the data is suspended, return immediately
    if(Contator_On.state == State_Wait)
    {
        return;
    }
    // If the data is in the ready state, send the data
    if(Contator_On.state == State_Ready)
    {
        // Send the data Contator_On.data to the address Contator_On.Address
        // Retrieve the data into Contator_On.Arr
        SendDataToDev(Contator_On.Address,Contator_On.data,Contator_On.Arr);
        // Data transmission completed, preparation for data processing
        Contator_On.state = State_Run;
        return;
    }
    // If the data is in a running state, process it
    if(Contator_On.state == State_Run)
    {
        // The feedback received is incorrect, resend the data
        // Dev_UsartData_buf is the content of the current serial port buffer
        // Dev_len_buf is the length of the existing data
        if(My_StrStr(Dev_UsartData_buf,Dev_len_buf,Contator_On.Arr,8) == 0x00)
            SendDataToDev(Contator_On.Address,Contator_On.data,Contator_On.Arr);
        else 
        {
            // You can perform related operations here
            // TODO : Some operations you need
            // This example shows printing 'Contator_On Finish' on Serial Usart1
            Usart1_Printf("Contator_On Finish\n");
            // Suspend the status
            Contator_On.state = State_Wait;
        }
        return;
    }
}

void DevData_Init(void)
{
    // The Address of Contator_On is 0x002A (Chapter 1 Part 2)
    Contator_On.Address = 0x002A;					
    // The data of Contator_On will be initialized to 0x00
    Contator_On.data = 0x0000;						
    // The data is suspended
    Contator_On.state = State_Wait;					
    // Initialize data processing pointer
    Contator_On.Data_Deal = ops_Contator_On;
}

// You also need a signal to notify the ops function to enter State_Ready
// Here, taking key detection as an example
// This is the timer interrupt function
unsigned char last_State1 = 0x00;					// Local variable for key detection
unsigned char State1 = 0x00;						// Local variable for key detection
void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET)
    {
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
        last_State1 = State1;
        State1 = (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_12) == Bit_RESET) ? 0x01 : 0x00;
        // Rising edge detected
        if((State1 == 0x01)&&(last_State1 == 0x00))
        {
            // The data is assigned the value 0x0001 and enters the ready state
            Contator_On.state = State_Ready;
            Contator_On.data = 0x0001;
        }
    }
}

// You need to loop the corresponding ops function in the main function
int main(void)
{
    DevData_Init();
    Usart1_Init();
    Usart2_Init();
    Tim2_Init();
    while(1)
    {
        Contator_On.Data_Deal();
        // You also need to take relevant measures to prevent data overflow.
        // Here is a caching mechanism provided as an example
        memset(Dev_UsartData_buf,0x00,500);
        Dev_len_buf = Dev_len;
        memcpy(Dev_UsartData_buf,Dev_UsartData,500);
        memset(Dev_UsartData,0x00,500);
        Dev_len = 0;
    }
}

// For convenience, the original data structure is used here. 
Dev_Data Get_Data_Deal;

void ops_Get_Data_Deal(void)		// Get_Data_Deal's data processing function
{
    // If the data is suspended, return immediately
    if(Get_Data_Deal.state == State_Wait)
    {
        return;
    }
    // If the data is in the ready state, send the data
    if(Get_Data_Deal.state == State_Ready)
    {
        // Send a request to get data
        GetDataFromDev();
        // Data transmission completed, preparation for data processing
        Get_Data_Deal.state = State_Run;
        return;
    }
    // If the data is in a running state, process it
    if(Get_Data_Deal.state == State_Run)
    {
        // Calculate the actual checksum based on the previous data
        unsigned short int CRC_Text = CRC_Test(Get_Data_Deal.Arr,131);
        // Obtain the CRC checksum from the data packet
        unsigned short int CRC_EE = (unsigned short int)Get_Data_Deal.Arr[131] 
            						+ (unsigned short int)Get_Data_Deal.Arr[132]*256;
        // Verification failed, resend the request to obtain data
        if(CRC_Text != CRC_EE)
        {
            GetDataFromDev();
            return;
        }
        // Verification passed, you can handle your data here
        // TODO : Some operations you need
        // This example shows printing 'Get_Data Finish' on Usart1
        Usart1_Printf("Get_Data Finish\n");
        // Destroy the check bits to prevent the data from being reused
        Get_Data_Deal.Arr[132] = 0x00;
        Get_Data_Deal.Arr[133] = 0x00;
        // Suspend the status
        Get_Data_Deal.state = State_Wait;
        return;
    }
}

void DevData_Init(void)
{
    // Since there is no address and no data to write, no assignment is made here directly.
    Get_Data_Deal.state = State_Wait;				// The data is suspended
    Get_Data_Deal.Data_Deal = ops_Get_Data_Deal;	    // Initialize data processing pointer
}

// For convenience, the function enabled by this button is set to a single query.
// This is the timer interrupt function
unsigned char last_State1 = 0x00;					// Local variable for key detection
unsigned char State1 = 0x00;						// Local variable for key detection
void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET)
    {
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
        last_State1 = State1;
        State1 = (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_12) == Bit_RESET) ? 0x01 : 0x00;
        // Rising edge detected
        if((State1 == 0x01)&&(last_State1 == 0x00))
        {
            // Set the ops for obtaining data to ready state
            Get_Data_Deal.state = State_Ready;
        }
    }
}

// You need to loop the corresponding ops function in the main function
int main(void)
{
    DevData_Init();
    Usart1_Init();
    Usart2_Init();
    Tim2_Init();
    while(1)
    {
        Get_Data_Deal.Data_Deal();
        // You also need to take relevant measures to prevent data overflow.
        // Here is a caching mechanism provided as an example
        memset(Dev_UsartData_buf,0x00,500);
        Dev_len_buf = Dev_len;
        memcpy(Dev_UsartData_buf,Dev_UsartData,500);
        memset(Dev_UsartData,0x00,500);
        Dev_len = 0;
    }
}

// Here is the data processing method of our other device
// You can refer to this kind of handling technique
// This union takes advantage of memory continuity and defines 133 pieces of data for the query protocol.
// You'd better update this union according to the agreement of the version you are using.
// The keyword '__pack' indicates that data is tightly packed
typedef union Type_Rx_Data{
    __packed struct{
        unsigned char hand0;
        unsigned char hand1;
        unsigned char hand2;
        unsigned short int p00_FIL_SC_H;
        unsigned short int p01_FIL_OI_H;
        unsigned short int p02_PREP_EN_STAT;
        unsigned short int p03_DRV_EN_STAT;
        unsigned short int p04_KV_OV;
        unsigned short int p05_mA_OI;
        unsigned short int p06_RI_OI;
        unsigned short int p07_ARC;
        unsigned short int p08_STARTER_ERR;
        unsigned short int p09_STARTER_HEAT;
        unsigned short int p0A_CONTATOR_STAT;
        unsigned short int p0B_BEAMFAULT;
        unsigned short int p0C_EXP_DUTY_STAT;
        unsigned short int p0D_DC_BUS;
        unsigned short int p0E_KV_FB;
        unsigned short int p0F_mA_FB;
        unsigned short int p10_FIL_FB;
        unsigned short int p11_TIME_FB_low;
        unsigned short int p12_TIME_FB_high;
        unsigned short int p13_TEMP_INV;
        unsigned short int p14_TEMP_TANK;
        unsigned short int p15_WORK_MODE_FB;
        unsigned short int p16_DEV_ID0_High;
        unsigned short int p17_DEV_ID0_Low;
        unsigned short int p18_LASER_CM;
        unsigned short int p19_ExpTimesSumH;
        unsigned short int p1A_ExpTimesSumL;
        unsigned short int p1B_ExpTimeSum;
        unsigned short int p1C_Power_FB;
        unsigned short int p1D_Keep_For_System;
        unsigned short int p1E_Keep_For_System;
        unsigned short int p1F_Keep_For_System;
        unsigned short int p20_Keep_For_System;
        unsigned short int p21_INV_DRV_EN;
        unsigned short int p22_FIL_DRV_EN;
        unsigned short int p23_HV_RST;
        unsigned short int p24_KV_REF;
        unsigned short int p25_mA_REF;
        unsigned short int p26_FIL_REF;
        unsigned short int p27_TIME_REF_low;
        unsigned short int p28_TIME_REF_high;
        unsigned short int p29_UART_PARA_SEL;
        unsigned short int p2A_CONTACTOR_ON;
        unsigned short int p2B_FPGA_FIL_SEL;
        unsigned short int p2C_FIL_CTRL_EN;
        unsigned short int p2D_P_FIL;
        unsigned short int p2E_I_FIL;
        unsigned short int p2F_D_FIL;
        unsigned short int p30_KV_CTRL_EN;
        unsigned short int p31_P_KV;
        unsigned short int p32_I_KV;
        unsigned short int p33_D_KV;
        unsigned short int p34_mA_CTRL_EN;
        unsigned short int p35_P_mA;
        unsigned short int p36_I_mA;
        unsigned short int p37_D_mA;
        unsigned short int p38_Keep_For_System;
        unsigned short int p39_Keep_For_System;
        unsigned short int p3A_LIGHT_ON;
        unsigned short int p3B_Laser_ON;
        unsigned short int p3C_Max_Power;
        unsigned short int p3D_Delay_ExpTimes;
        unsigned short int p3E_Keep_For_System;
        unsigned short int p3F_Keep_For_System;
        unsigned char CRCL;
        unsigned char CRCH;
    }val;
    unsigned char data[133];
}Rx_Data_t;

// You can use a FSM to obtain all 133 pieces of data
// This is the interrupt function for UART1
// Directly received data for Set data 
unsigned char Dev_UsartData[500] = {0x00};		
// Receive Data Buffer for Set data
unsigned char Dev_UsartData_buf[500] = {0x00};	
// Directly received data for Get data
Rx_Data_t Rx_Data;
// Receive Data Buffer for Get data
Rx_Data_t Rx_Data1;
// Data Receiving Status
unsigned char Rx_State = 0x00;					
// Number of valid data already received
unsigned char Rx_Wei = 3;						
void USART1_IRQHandler(void)
{
    if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);
    // Obtain the data received this time
    Dev_UsartData[Dev_len] = USART_ReceiveData(USART1);
    // Select according to the current reception status for Get data
    switch(Rx_State)
    {
        // No valid data received
        case 0x00:
        {
            // Received the first valid data, exit the loop
            if(Dev_UsartData[Dev_len] == 0x02)
            Rx_State = 0x01;
            break;
        }
        // A valid data has already been received
        case 0x01:
        {
            // Received the second valid data, exit the loop
            if(Dev_UsartData[Dev_len] == 0x03)
                Rx_State = 0x02;
            // Otherwise, the data is invalid
            else
                Rx_State = 0x00;
            break;
        }
        // Packet header data is valid, ready to receive
        case 0x02:
        {
            // Number of data received
            if(Dev_UsartData[Dev_len] == 0x80)
            {
                // Assign values to the data packet header of the data structure 
                // and prepare to receive the valid data section
                Rx_State = 0x03;
                Rx_Data.data[0] = 0x02;
                Rx_Data.data[1] = 0x03;
                Rx_Data.data[2] = 0x80;
                Rx_Wei = 3;
            }
            // Otherwise, the data is invalid
            else
                Rx_State = 0x00;
            break;
        }
        // Receive valid data
        case 0x03:
        {
            // Write valid data one after another
            Rx_Data.data[Rx_Wei] = Dev_UsartData[Dev_len];
            Rx_Wei++;
            // Data reception complete, updated to cache
            if(Rx_Wei >= 134)
            {
                Rx_Wei = 3;
                Rx_State = 0x00;
                memcpy(Get_Data_Deal.Arr,Rx_Data.data,133);
                memcpy(Rx_Data1.data,Rx_Data.data,133);
            }
            break;
        }
    }
    // Ensure that the setting data reception is not affected
    if(Dev_len < 450)
    Dev_len ++;
}

// Macro for fetching data
// Choose according to your device situation
// Little-endian
#define Get_RX(data_x) 			(((Rx_Data1.val.data_x&0xFF00)>>8)|((Rx_Data1.val.data_x&0x00FF)<<8))
// Big-endian
#define Get_RX(data_x)			Rx_Data1.val.data_x
// You can read the data of FIL_SC_H in the following way
unsigned short int FIL_SC_H = Get_RX(p00_FIL_SC_H);