ISCS_CABINET_CONTROL/mainboard/components/ir_check/ir_check.c

// #include "ir_check.h"
// #include "user_uart.h"
// #include "user_crc16.h"

// static uint16_t check_ir_check_count = 0;
// static ir_check_work_s ir_check_work = {
//     .workStat = IR_CHECK_DEV_TYPE,
//     .ir_check_ready;
//     .ir_check_count;
//     .sw_stat[IR_CHECK_MAX_COUNT];
//     .set_stat[IR_CHECK_MAX_COUNT];
//     .set_stat_enable[IR_CHECK_MAX_COUNT];
//     .set_stat_enable_idx;
// };

// static uint32_t ir_check_offline_timeout = 0;
// static bool ir_check_offline_stat = true;

// static void set_ir_check_offline(bool stat);

// modbus_work_s ir_check_modbus_work = {
//     .rtu_addr = IR_CHECK_UART_ADDR,
//     .tx_size = 0,
//     .rx_size = 0,
//     .tx_buffer = {0},
//     .rx_buffer = {0},
//     .rtu_rec = {0},
//     .modbusRx_stat = false,
//     .modbusTx_stat = false,
// };

// /*******************************************************************************
//   * @函数名称	downloadRx_receive
//   * @函数说明   处理接收数据
//   * @输入参数    data：数据指针
//                 size：数据长度
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static void downloadRx_receive(uint8_t *data, uint16_t size)
// {
//     memcpy(ir_check_modbus_work.rx_buffer, data, size);
//     ir_check_modbus_work.rx_size = size;
// 	memcpy((void *)&(ir_check_modbus_work.rtu_rd), ir_check_modbus_work.rx_buffer, ir_check_modbus_work.rx_size);
// 	memcpy((void *)&(ir_check_modbus_work.rtu_rd.crc), &(ir_check_modbus_work.rx_buffer[ir_check_modbus_work.rx_size - 2]), 2);
// 	memcpy((void *)&(ir_check_modbus_work.rtu_rec), ir_check_modbus_work.rx_buffer, ir_check_modbus_work.rx_size);
// 	memcpy((void *)&(ir_check_modbus_work.rtu_rec.crc), &(ir_check_modbus_work.rx_buffer[ir_check_modbus_work.rx_size - 2]), 2);
// 	ir_check_modbus_work.rtu_rec.dataSize = ir_check_modbus_work.rx_size - 6;
// 	ir_check_modbus_work.modbusRx_stat = true;
// }

// /*******************************************************************************
//   * @函数名称	downloadTx_send
//   * @函数说明   发送数据
//   * @输入参数   无
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static void downloadTx_send(uint8_t *data, int size)
// {
// #if USE_BASE64 == 1
// 	base64_encode(data, (char *)download_work.tx_buffer, size);
// 	int len = strlen((char *)download_work.tx_buffer);
// 	download_work.tx_buffer[len] = '\r';
// 	download_work.tx_buffer[len + 1] = '\n';
// 	download_work.tx_buffer[len + 2] = '\0';
	
// 	download_work.tx_size = len + 2;
// #else
// 	memcpy(download_work.tx_buffer, data, size);
// 	download_work.tx_size = size;
// #endif
//     download_work.modbusTx_stat = true;
	
// 	vUser_usart1_send(download_work.tx_buffer, download_work.tx_size);
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_sd_dev_type
//   * @函数说明   设置询问从机设备类型数据
//   * @输入参数   data：数据指针
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static uint16_t rtu_protocol_sd_dev_type(uint8_t *data)
// {
//     data[0] = download_work.rtu_addr;
//     data[1] = CMD_RD_REG;
//     data[2] = (uint8_t)(REG_DEV_TYPE_ADDR >> 8);
//     data[3] = (uint8_t)REG_DEV_TYPE_ADDR;
//     data[4] = 0x00;
//     data[5] = 0x01;

//     check_download_count++;

//     return 6;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_sd_coll_stat
//   * @函数说明   设置询问从机就绪状态数据
//   * @输入参数   data：数据指针
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static uint16_t rtu_protocol_sd_coll_stat(uint8_t *data)
// {
//     data[0] = download_work.rtu_addr;
//     data[1] = CMD_RD_REG;
//     data[2] = (uint8_t)(REG_COLL_STAT_ADDR >> 8);
//     data[3] = (uint8_t)REG_COLL_STAT_ADDR;
//     data[4] = 0x00;
//     data[5] = 0x01;

//     return 6;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_sd_coll_count
//   * @函数说明   设置询问从机包含的主板总数数据
//   * @输入参数   data：数据指针
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static uint16_t rtu_protocol_sd_coll_count(uint8_t *data)
// {
//     data[0] = download_work.rtu_addr;
//     data[1] = CMD_RD_REG;
//     data[2] = (uint8_t)(REG_COLL_COUNT_ADDR >> 8);
//     data[3] = (uint8_t)REG_COLL_COUNT_ADDR;
//     data[4] = 0x00;
//     data[5] = 0x01;

//     return 6;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_sd_sw_stat
//   * @函数说明   设置询问从机包含的开关量数据
//   * @输入参数   data：数据指针
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static uint16_t rtu_protocol_sd_sw_stat(uint8_t *data)
// {
//     data[0] = download_work.rtu_addr;
//     data[1] = CMD_RD_REG;
//     data[2] = (uint8_t)(REG_COLL_SW_HIGH_STAT_ADDR >> 8);
//     data[3] = (uint8_t)REG_COLL_SW_HIGH_STAT_ADDR;
//     data[4] = 0x00;
//     data[5] = 0x02;

//     return 6;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_send
//   * @函数说明   发送数据
//   * @输入参数    data：数据指针
// 				size：数据长度
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static void rtu_protocol_send(uint8_t *data, int size)
// {
// 	uint16_t crc = 0xFFFF;

// 	crc = GetCRC16(data, size, crc);
// 	memcpy(&data[size], &crc, 2);
// 	downloadTx_send(data, size + 2);
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_sd_task
//   * @函数说明   发送数据任务
//   * @输入参数   无
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static void rtu_protocol_sd_task(void)
// {
//     uint8_t data[MODBUS_DATA_SIZE] = {0};
// 	uint16_t datasize = 0;

//     switch(download_work_stat)
// 	{
// 		case DOWNLOAD_DEV_TYPE:datasize = rtu_protocol_sd_dev_type(data);break;
// 		case DOWNLOAD_COLL_REDAY_STAT:datasize = rtu_protocol_sd_coll_stat(data);break;
// 		case DOWNLOAD_COLL_COUNT:datasize = rtu_protocol_sd_coll_count(data);break;
// 		case DOWNLOAD_SW_STAT:datasize = rtu_protocol_sd_sw_stat(data);break;
// 		default:{
// 			download_work_stat = DOWNLOAD_DEV_TYPE;
// 			datasize = rtu_protocol_sd_dev_type(data);
// 		}break;
// 	}

//   rtu_protocol_send(data, datasize);
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_rd_dev_type_parsing
//   * @函数说明   解析读取设备类型
//   * @输入参数   rd：数据
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_protocol_rd_dev_type_parsing(rtu_rd_s *rd)
// {
// 	uint16_t temp = 0;
	
// 	temp = rd->data[0];
// 	temp <<= 8;
// 	temp += rd->data[1];
// 	if(temp == (uint16_t)COLL_UART_ADDR)
// 	{
// 		download_work_stat = DOWNLOAD_COLL_REDAY_STAT;
// 		check_download_count = 0;
// 		return true;
// 	}

// 	return false;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_rd_coll_stat_parsing
//   * @函数说明   解析读取设备就绪状态
//   * @输入参数   rd：数据
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_protocol_rd_coll_stat_parsing(rtu_rd_s *rd)
// {
// 	uint16_t temp = 0;
	
// 	temp = rd->data[0];
// 	temp <<= 8;
// 	temp += rd->data[1];
// 	if(temp == COLL_READY_STAT)
// 	{
// 		download_work_stat = DOWNLOAD_COLL_COUNT;
// 		coll_ready_stat = true;
		
// 		return true;
// 	}

// 	return false;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_rd_coll_count_parsing
//   * @函数说明   解析读取下挂主板数量
//   * @输入参数   rd：数据
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_protocol_rd_coll_count_parsing(rtu_rd_s *rd)
// {
// 	uint16_t temp = 0;
	
// 	temp = rd->data[0];
// 	temp <<= 8;
// 	temp += rd->data[1];
// 	if(temp < COLL_MAX_COUNT)
// 	{
// 		coll_sw_count = temp;
// 		download_work_stat = DOWNLOAD_SW_STAT;
// 		vUser_server_set_coll_stat(coll_sw_count);
// 		return true;
// 	}

// 	return false;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_rd_sw_stat_parsing
//   * @函数说明   解析读取下挂主板开关量状态
//   * @输入参数   rd：数据
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_protocol_rd_sw_stat_parsing(rtu_rd_s *rd)
// {
// 	uint32_t temp = 0;

//     if(rd->dataSize != 4)
//     {
//         return false;
//     }
	
// 	temp = rd->data[0];
// 	temp <<= 8;
// 	temp += rd->data[1];
//     temp <<= 8;
// 	temp += rd->data[2];
//     temp <<= 8;
// 	temp += rd->data[3];

// 	vUser_server_set_download_sw_stat(temp);

// 	return true;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_rd_reg_parsing
//   * @函数说明   解析读指令返回的数据
//   * @输入参数   rd：数据
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_protocol_rd_reg_parsing(rtu_rd_s *rd)
// {
// 	bool stat = false;
//   	switch(download_work_stat)
// 	{
// 		case DOWNLOAD_DEV_TYPE:stat = rtu_protocol_rd_dev_type_parsing(rd);break;
// 		case DOWNLOAD_COLL_REDAY_STAT:stat = rtu_protocol_rd_coll_stat_parsing(rd);break;
// 		case DOWNLOAD_COLL_COUNT:stat = rtu_protocol_rd_coll_count_parsing(rd);break;
// 		case DOWNLOAD_SW_STAT:stat = rtu_protocol_rd_sw_stat_parsing(rd);break;
// 		default:break;
// 	}

//   return stat;
// }

// /*******************************************************************************
//   * @函数名称	rtu_rd_protocol_parsing
//   * @函数说明   读指令返回解析
//   * @输入参数   rd：数据
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_rd_protocol_parsing(rtu_rd_s *rd)
// {
// 	uint16_t crc = 0xFFFF;
	
// 	crc = GetCRC16((uint8_t *)rd, rd->dataSize + 3, crc);
// 	if(crc != rd->crc)
// 	{
// 		return false;
// 	}

// 	if(rd->func == CMD_RD_REG)
// 	{
// 		if(true == rtu_protocol_rd_reg_parsing(rd))
// 		{
// 			return true;
// 		}
// 	}

// 	return false;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_wr_reg_parsing
//   * @函数说明   写指令数据解析
//   * @输入参数   rec：数据
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_protocol_wr_reg_parsing(rtu_rec_s *rec)
// {
//   uint16_t reg_addr = 0;

//   reg_addr = rec->regAddr[0];
//   reg_addr <<= 8;
//   reg_addr += rec->regAddr[1];
//   switch(reg_addr)
//   {
//     default:break;
//   }

//   return false;
// }

// /*******************************************************************************
//   * @函数名称	rtu_rec_protocol_parsing
//   * @函数说明   写指令返回解析
//   * @输入参数   rec：数据
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_rec_protocol_parsing(rtu_rec_s *rec)
// {
// 	uint16_t crc = 0xFFFF;

	
// 	crc = GetCRC16((uint8_t *)rec, rec->dataSize + 4, crc);
// 	if(crc != rec->crc)
// 	{
// 		return false;
// 	}

// 	if(rec->func == CMD_WR_REG)
// 	{
// 		if(true == rtu_protocol_wr_reg_parsing(rec))
// 		{
// 			return true;
// 		}
// 	}

// 	return false;
// }

// /*******************************************************************************
//   * @函数名称	rtu_protocol_parsing
//   * @函数说明   返回数据解析
//   * @输入参数  	无
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// static bool rtu_protocol_parsing(void)
// {
// 	if(download_work.rtu_rec.addr != download_work.rtu_addr)
// 	{
// 		return false;
// 	}
	
// 	if(download_work.rtu_rec.func == CMD_RD_REG)
// 	{
// 		if(true == rtu_rd_protocol_parsing(&(download_work.rtu_rd)))
// 		{
// 			set_download_offline(false);
// 		}
// 	}
// 	else if(download_work.rtu_rec.func == CMD_WR_REG)
// 	{
// 		if(true == rtu_rec_protocol_parsing(&(download_work.rtu_rec)))
// 		{
// 			set_download_offline(false);
// 		}
// 	}
// 	else{
// 		download_work_stat = DOWNLOAD_DEV_TYPE;
// 	}
// }

// /************************************************
//   * 函数名：set_ir_check_offline
//   * 描述  ：设置从机通讯状态灯
//   * 输入  ：stat：通讯状态
//   * 输出  ：无
//   * 注意  ：无
//  ************************************************/
// static void set_ir_check_offline(bool stat)
// {
// 	if(stat == true)
// 	{
// 		ir_check_offline_timeout = 5000;
// 		if(ir_check_offline_stat == false)
// 		{
// 			ir_check_offline_stat = true;
// 		}
// 	}
// 	else{
// 		if(ir_check_offline_stat == true)
// 		{
// 			ir_check_offline_stat = false;
// 		}
// 	}
// }

// /************************************************
//  * 函数名：vIr_check_tick
//  * 描述  ：任务计时器
//  * 输入  ：无
//  * 输出  ：无
//  * 注意  ：无
//  ************************************************/
// void vIr_check_tick(void)
// {
// 	if(ir_check_delay_count > 0)
// 	{
// 		ir_check_delay_count--;
// 	}
	
// 	if(ir_check_offline_timeout > 0)
// 	{
// 		ir_check_offline_timeout--;
// 	}
// 	else{
// 		set_ir_check_offline(true);
// 	}
// }

// /************************************************
//  * 函数名：vDownload_pro
//  * 描述  ：执行任务
//  * 输入  ：无
//  * 输出  ：无
//  * 注意  ：无
//  ************************************************/
// void vDownload_pro(void)
// {
// 	if(download_delay_count == 0)
// 	{
// 		download_delay_count = 500;
// 		if(check_download_count >= MAX_REPLAY_COUNT)
// 		{
// 			vUser_server_set_coll_stat(0);
// 		}
// 		rtu_protocol_sd_task();
// 	}
// 	if(download_work.modbusRx_stat == true)
// 	{
// 		download_work.modbusRx_stat = false;
// 		rtu_protocol_parsing();
// 	}
// }

// /*******************************************************************************
//   * @函数名称   vUpload_init
//   * @函数说明   初始化
//   * @输入参数  	无
//   * @输出参数   无
//   * @返回参数   无
// *******************************************************************************/
// void vDownload_init(void)
// {
//     user_uart_param_s param = {
//         .baudrate = 115200,
//         .wordlength = USART_WordLength_8b,
//         .stopbit = USART_StopBits_1,
//         .parity = USART_Parity_No,
//     };

//     vUser_usart1_init(&param);
//     vUser_usart1_set_data_upload_func(downloadRx_receive);
// }