ISCS_CABINET_COLL_16/main/components/server/upload.c

#include "upload.h"
#include "user_uart.h"
#include "user_crc16.h"
#include "base64.h"
#include "string.h"
#include "user_server.h"

modbus_work_s upload_work = {
	  .rtu_addr = DEV_UART_ADDR,
    .tx_size = 0,
    .rx_size = 0,
    .tx_buffer = {0},
    .rx_buffer = {0},
    .rtu_rec = {0},
    .modbusRx_stat = false,
    .modbusTx_stat = false,
};

static uint32_t upload_offline_timeout = 0;
static bool upload_offline_stat = true;

static void set_upload_offline(bool stat);

/*******************************************************************************
  * @函数名称	uploadRx_receive
  * @函数说明   处理接收数据
  * @输入参数    data：数据指针
                size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void uploadRx_receive(uint8_t *data, uint16_t size)
{
    memcpy(upload_work.rx_buffer, data, size);
    upload_work.rx_size = size;
#if USE_BASE64 == 1	
	uint8_t data[MODBUS_DATA_SIZE] = {0};
	if(upload_work.rx_buffer[upload_work.rx_size - 2] == '\r' 
		&& upload_work.rx_buffer[upload_work.rx_size - 1] == '\n')
	{
		upload_work.rx_buffer[upload_work.rx_size - 2] = '\0';
		int len = base64_decode((char *)upload_work.rx_buffer, data);
		
		memcpy((void *)&(upload_work.rtu_rec), data, len);
		memcpy((void *)&(upload_work.rtu_rec.crc), &(data[len - 2]), 2);
		upload_work.rtu_rec.dataSize = len - 6;
		upload_work.modbusRx_stat = true;
	}
#else
	memcpy((void *)&(upload_work.rtu_rec), upload_work.rx_buffer, upload_work.rx_size);
	memcpy((void *)&(upload_work.rtu_rec.crc), &(upload_work.rx_buffer[upload_work.rx_size - 2]), 2);
	upload_work.rtu_rec.dataSize = upload_work.rx_size - 6;
	upload_work.modbusRx_stat = true;
#endif
}

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



/*******************************************************************************
  * @函数名称	rtu_protocol_rd_dev_type
  * @函数说明   设置设备类型数据
  * @输入参数   data：数据指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint8_t * rtu_protocol_rd_dev_type(uint8_t *data)
{
    *data++ = DEV_TYPE >> 8;
    *data++ = DEV_TYPE;

    return data;
}

/*******************************************************************************
  * @函数名称	rtu_protocol_rd_version
  * @函数说明   设置版本号数据
  * @输入参数   data：数据指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint8_t * rtu_protocol_rd_version(uint8_t *data)
{
    *data++ = HARDWARE_VERSION;
    *data++ = SOFTWARE_VERSION;

    return data;
}

/*******************************************************************************
  * @函数名称	rtu_protocol_coll_stat
  * @函数说明   设置主板状态数据
  * @输入参数   data：数据指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint8_t * rtu_protocol_coll_stat(uint8_t *data)
{
    uint16_t value = 0;

    memcpy((void *)&value, (void *)&(coll_data.coll_stat), 2);
    *data++ = value >> 8;
    *data++ = value;

    return data;
}

/*******************************************************************************
  * @函数名称	rtu_protocol_coll_count
  * @函数说明   设置包含的主板数
  * @输入参数   data：数据指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint8_t * rtu_protocol_coll_count(uint8_t *data)
{
    uint16_t value = 0;

    memcpy((void *)&value, (void *)&(coll_data.count), 2);
    *data++ = value >> 8;
    *data++ = value;

    return data;
}

/*******************************************************************************
  * @函数名称	rtu_protocol_sw_low_stat
  * @函数说明   设置采集到的所有开关量
  * @输入参数   data：数据指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint8_t * rtu_protocol_sw_low_stat(uint8_t *data)
{
    uint16_t value = 0;

    for(int i = 0; i < 8; i++)
    {
        value <<= 2;
        value += coll_data.sw_stat[7 - i];
    }

    *data++ = (uint8_t)(value >> 8);
    *data++ = (uint8_t)value;

    return data;
}

/*******************************************************************************
  * @函数名称	rtu_protocol_sw_low_stat
  * @函数说明   设置采集到的所有开关量
  * @输入参数   data：数据指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint8_t * rtu_protocol_sw_high_stat(uint8_t *data)
{
    uint16_t value = 0;

    for(int i = 0; i < 8; i++)
    {
        value <<= 2;
        value += coll_data.sw_stat[7 - i + 8];
    }

    *data++ = (uint8_t)(value >> 8);
    *data++ = (uint8_t)value;

    return data;
}

/*******************************************************************************
  * @函数名称	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);
	uploadTx_send(data, size + 2);
}

/*******************************************************************************
  * @函数名称	rtu_protocol_rd_reg_parsing
  * @函数说明   解析接收到的上位机数据
  * @输入参数   rec：数据
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static bool rtu_protocol_rd_reg_parsing(rtu_rec_s *rec)
{
  uint8_t data[MODBUS_DATA_SIZE] = {0};
  uint16_t dataSize = 0;
  data[0] = upload_work.rtu_addr;
  data[1] = CMD_RD_REG;
  dataSize = rec->data[0];
  dataSize <<= 8;
  dataSize += rec->data[1];
  data[2] = dataSize * 2;

  uint16_t reg_addr = 0;

  reg_addr = rec->regAddr[0];
  reg_addr <<= 8;
  reg_addr += rec->regAddr[1];

  uint8_t *ptr = &data[3];

  switch(reg_addr)
  {
    case REG_DEV_TYPE_ADDR: ptr = rtu_protocol_rd_dev_type(ptr);
    case 0x0001: ptr += 4;
    case REG_VERSION_ADDR:ptr = rtu_protocol_rd_version(ptr);
    case 0x0004: ptr += 24;
    case REG_COLL_STAT_ADDR: ptr = rtu_protocol_coll_stat(ptr);
    case REG_COLL_COUNT_ADDR: ptr = rtu_protocol_coll_count(ptr);
    case REG_COLL_SW_HIGH_STAT_ADDR: ptr = rtu_protocol_sw_high_stat(ptr);
    case REG_COLL_SW_LOW_STAT_ADDR: ptr = rtu_protocol_sw_low_stat(ptr);
    default:break;
  }

  rtu_protocol_send(data, dataSize * 2 + 3);

  return true;
}

/*******************************************************************************
  * @函数名称	rtu_protocol_wr_reg_return
  * @函数说明   写入数据成功返回
  * @输入参数   rec：数据
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void rtu_protocol_wr_reg_return(rtu_rec_s *rec)
{
    uint8_t data[MODBUS_DATA_SIZE] = {0};

    data[0] = rec->addr;
    data[1] = rec->func;
    data[2] = rec->regAddr[0];
    data[3] = rec->regAddr[1];
    memcpy(&data[4], rec->data, rec->dataSize);
    memcpy(&data[rec->dataSize + 4], (uint8_t *)&(rec->crc), 2);

    uploadTx_send(data, rec->dataSize + 6);
}

/*******************************************************************************
  * @函数名称	rtu_protocol_wr_coll_sw_high_stat_parsing
  * @函数说明   设置存取状态指令返回解析
  * @输入参数   rec：数据
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static bool rtu_protocol_wr_coll_sw_high_stat_parsing(rtu_rec_s *rec)
{
    uint16_t temp = 0;
    temp = rec->data[0];
    temp <<= 8;
    temp += rec->data[1];

    for(int i = 0; i < 8; i++)
    {
        if((temp & (1 << (i + 8))) != 0)
        {
            if((temp & (1 << i)) != 0)
            {
                vUser_server_set_items_stat(i + 8, PUT_ITEMS_STAT);
            }
            else{
                vUser_server_set_items_stat(i + 8, TAKE_ITEMS_STAT);
            }
        }
        else{
          vUser_server_set_items_stat(i, NO_ITEMS_STAT);
        }
    }

    rtu_protocol_wr_reg_return(rec);

  	return true;	
}

/*******************************************************************************
  * @函数名称	rtu_protocol_wr_coll_sw_low_stat_parsing
  * @函数说明   设置存取状态指令返回解析
  * @输入参数   rec：数据
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static bool rtu_protocol_wr_coll_sw_low_stat_parsing(rtu_rec_s *rec)
{
	uint16_t temp = 0;
    temp = rec->data[0];
    temp <<= 8;
    temp += rec->data[1];

    for(int i = 0; i < 8; i++)
    {
        if((temp & (1 << (i + 8))) != 0)
        {
            if((temp & (1 << i)) != 0)
            {
                vUser_server_set_items_stat(i, PUT_ITEMS_STAT);
            }
            else{
                vUser_server_set_items_stat(i, TAKE_ITEMS_STAT);
            }
        }
        else{
          vUser_server_set_items_stat(i, NO_ITEMS_STAT);
        }
    }

    rtu_protocol_wr_reg_return(rec);

  	return true;	
}

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

    reg_addr = rec->regAddr[0];
    reg_addr <<= 8;
    reg_addr += rec->regAddr[1];
    switch(reg_addr)
    {
        case REG_COLL_SW_HIGH_STAT_ADDR: stat = rtu_protocol_wr_coll_sw_high_stat_parsing(rec);break;
	      case REG_COLL_SW_LOW_STAT_ADDR: stat = rtu_protocol_wr_coll_sw_low_stat_parsing(rec);break;
        default:break;
    }

    return stat;
}

/*******************************************************************************
  * @函数名称	  rtu_protocol_wr_multi_coll_sw_stat_parsing
  * @函数说明   设置存取状态指令返回解析
  * @输入参数   rec：数据
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static bool rtu_protocol_wr_multi_coll_sw_stat_parsing(rtu_wr_multi_s *wr_multi)
{
    bool stat = false;
	  uint16_t regCount = 0;
    regCount = wr_multi->regCount[0];
    regCount <<= 8;
    regCount += wr_multi->regCount[1];

    if(regCount == 2 && wr_multi->count == 4)
    {
        uint32_t temp = 0;
        
        temp += *wr_multi->data++;
        temp <<= 8;
        temp += *wr_multi->data++;
        temp <<= 8;
        temp += *wr_multi->data++;
        temp <<= 8;
        temp += *wr_multi->data++;

        for(int i = 0; i < 16; i++)
        {
            if((temp & (1 << (i + 16))) != 0)
            {
                if((temp & (1 << i)) != 0)
                {
                    vUser_server_set_items_stat(i, PUT_ITEMS_STAT);
                }
                else{
                    vUser_server_set_items_stat(i, TAKE_ITEMS_STAT);
                }
            }
            else{
              vUser_server_set_items_stat(i, NO_ITEMS_STAT);
            }
        }

        stat = true;
    }

  	return stat;	
}

/*******************************************************************************
  * @函数名称	  rtu_protocol_wr_multi_reg_parsing
  * @函数说明   解析接收到的上位机数据
  * @输入参数   rec：数据
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static bool rtu_protocol_wr_multi_reg_parsing(rtu_rec_s *rec)
{
  bool stat = false;
  uint8_t data[MODBUS_DATA_SIZE] = {0};
  rtu_wr_multi_s wr_multi;
  uint16_t reg_addr = 0;

  wr_multi.addr = upload_work.rtu_addr;
  wr_multi.func = CMD_WR_MULTI_REG;
  wr_multi.regAddr[0] = rec->regAddr[0];
  wr_multi.regAddr[1] = rec->regAddr[1];
  wr_multi.regCount[0] = rec->data[0];
  wr_multi.regCount[1] = rec->data[1];
  wr_multi.count = rec->data[2];
  wr_multi.data = &(rec->data[3]);

  reg_addr = wr_multi.regAddr[0];
  reg_addr <<= 8;
  reg_addr += wr_multi.regAddr[1];

  switch(reg_addr)
  {
      case REG_COLL_SW_HIGH_STAT_ADDR: stat = rtu_protocol_wr_multi_coll_sw_stat_parsing(&wr_multi);
      default:break;
  }

  if(stat == true)
  {
      memcpy(data, (uint8_t *)&wr_multi, 6);
      rtu_protocol_send(data, 6);
  }

  return stat;
}

/*******************************************************************************
  * @函数名称	  rtu_protocol_parsing
  * @函数说明   解析接收到的上位机数据
  * @输入参数   rec：数据
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static bool rtu_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->addr != upload_work.rtu_addr)
    {
        return false;
    }

    if(rec->func == CMD_RD_REG)
    {
        if(true == rtu_protocol_rd_reg_parsing(rec))
        {
            set_upload_offline(false);
            return true;
        }
    }
    else if(rec->func == CMD_WR_REG)
    {
        if(true == rtu_protocol_wr_reg_parsing(rec))
        {
            set_upload_offline(false);
            return true;
        }
    }
    else if(rec->func == CMD_WR_MULTI_REG)
    {
        if(true == rtu_protocol_wr_multi_reg_parsing(rec))
        {
            set_upload_offline(false);
            return true;
        }
    }

    return false;
}

static void set_upload_offline(bool stat)
{
	if(stat == true)
	{
		upload_offline_timeout = 5000;
		if(upload_offline_stat == false)
		{
			upload_offline_stat = true;
		}
	}
	else{
		if(upload_offline_stat == true)
		{
			upload_offline_stat = false;
		}
	}
}

/*******************************************************************************
  * @函数名称   vUpload_tick
  * @函数说明   任务计时器
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUpload_tick(void)
{
	if(upload_offline_timeout > 0)
	{
		upload_offline_timeout--;
	}
	else{
		set_upload_offline(true);
	}
}

/*******************************************************************************
  * @函数名称   upload_pro
  * @函数说明   任务
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUpload_pro(void)
{
	if(upload_work.modbusRx_stat == true)
	{
		upload_work.modbusRx_stat = false;
		rtu_protocol_parsing(&(upload_work.rtu_rec));
	}
}

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

    vUser_usart2_init(&param);
    vUser_usart2_set_data_upload_func(uploadRx_receive);
}