0201_APP/APP/uart_pt.c

#include "uart_pt.h"
#include "includes.h"
//#include "gw_ctrl.h"

PtTest g_ptTest;

char Send_Buf_Char[320];
void gw_net_send_02(char *data,  uint16_t len, uint16_t *llen)
{
    int i;
    //char send_buf[320];
    char value = 0;
    int send_len=0;
    const uint16_t len1 = len;

    memset(Send_Buf_Char,0,sizeof(Send_Buf_Char));
    for(i = 0;i < len1;i++) {
        value = data[i];
        send_len += snprintf((char *)Send_Buf_Char + send_len, sizeof(Send_Buf_Char), "%02x", value);
    }
    *llen = send_len;
}

char sendbuff[320] = {0};
uint8_t eeprom_buf[64] = {0};
uint32_t eeprom_addr=0;
#define EEPROM_PAGE 256
#define EEPROM_BUF_LEN 64

void pt_return_handle(char *data)
{
	memset(sendbuff,0,sizeof(sendbuff));
	strcpy(sendbuff,data);
	uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
}

void uart_cmd_task(char *data, uint8_t len)
{
    OS_ERR  err;
    char     * p_data     = NULL;

    uint32_t device_sn;            //设备sn
	uint32_t device_type;          //设备类型
	uint32_t manufactures;         //产品制造商
	uint32_t batch_number;         //批次号
	uint32_t production_data;      //出厂日期
	uint32_t pcb_ver;              //PCB版本

    uint16_t i = 0;
    uint16_t eeprom_first = 0;
    uint16_t lent = 0;

    char     tempbuff[130] = {0};
    char     type[5]       = {0};
    char     ssn[11]       = {0};
    char     pcb[3]        = {0};
    char     bn[5]         = {0};
    char     mfrs[5]       = {0};
    char     pd[9]         = {0};
    char     port[6]       = {0};
    char     usr[40]       = {0};
    char     pwd[40]       = {0};
    //eeprom
    char     eepaddr[5]    = {0};
    char     eeplen[5]     = {0};
    uint32_t eep_addr      = 0;
    uint32_t eep_len       = 0;
    uint16_t eep_len_temp  = 0;

    //测试离线升级
	char     master_snb[15] = {0};
	char     slave_snb[15]  = {0};
	char     des_snb[15]    = {0};
	unsigned int master_sn  = 0;
	unsigned int slave_sn   = 0;
	unsigned int des_sn     = 0;

    if(strstr(data,"AT+PTMOD=ON\r\n"))//产测开始指令
    {
        g_ptTest.bTestStart = PT_ON;
		
		pt_return_handle("+PTMOD:ON,00000001\r\n");

        device_fixed_info.Work_State = DEV_WORK_STATE_PT;
		
		timeout_setValue(&g_ptTest.tt_pt_time,PT_TIME,1);//打开产测定时

        //关闭所有指示灯
        close_all_led();
    }
    else if(strstr(data,"AT+PTMOD\r\n"))
    { // 查询当前是否在产测模式下 产测版本
        if(g_ptTest.bTestStart==PT_ON)
        {
			pt_return_handle("+PTMOD:ON,00000001\r\n");
        } 
        else
        {
			pt_return_handle("+PTMOD:OFF,00000001\r\n");
        }
	}
    if(g_ptTest.bTestStart == PT_ON)//打开产测后
    {
        if(strstr(data,"AT+PTMOD=OFF\r\n"))//关闭产测指令
        {
            g_ptTest.bTestStart = PT_OFF;
			pt_return_handle("+PTMOD:OFF,00000001\r\n");

			device_info_get();//读取eeprom中的设备信息
            if(device_info.alrd == DEVICE_ALRD)//已初始化
            {
                device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL;
				printf("normal\n");
            }
            else
            {
                device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT;
				printf("uninit\n");
            }
			
			timeout_stop(&g_ptTest.tt_pt_time);//关闭产测定时
        }
        else if(strstr(data,"AT+INITDEVINFO=WBJW,"))// 初始化信息 设备类型 sn 批次号  生产厂商 生产日期
        {
            p_data = strstr(data,"AT+INITDEVINFO=WBJW,");
            if(strstr(p_data,"\r\n"))
            {
                sscanf(p_data,"AT+INITDEVINFO=WBJW,%[^\r\n]\r\n",tempbuff);
                sscanf((char *)tempbuff,"%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,]",type,ssn,pcb,bn,mfrs,pd,tempbuff,port,usr,pwd);
                sscanf(type,"%04X",&device_type); // 设备类型
                sscanf(ssn,"%010u",&device_sn);  //sn
                sscanf(pcb,"%02X",&pcb_ver);     //PCB版本
                sscanf(bn,"%04X",&batch_number); //批次号 
                sscanf(mfrs,"%04X",&manufactures); //生产厂商
                sscanf(pd,"%08X",&production_data); // 生产日期

                if(device_type_cmp(SOFTWARE_VERSION_APP,(u16)device_type) == 0)
                {
					pt_return_handle("+INITDEVINFO:ERR,DEVICE_TYPE_MISMATCH\r\n");
                    memset(data,0,len);
					return;
                }
                device_info.alrd            = DEVICE_ALRD;
                device_info.device_type     = device_type;
                device_info.device_sn       = device_sn;
                device_info.batch_number    = batch_number;
                device_info.manufactures    = manufactures;
                device_info.production_data = production_data;
                device_info.pcb_ver         = pcb_ver;

                device_info_update();//写eeprom
                eeprom_first = EEPROM_FIRST_INIT_FLAG;
				AT24CXX_Write(EECFG_FIRST_INIT0, (uint8_t *)&eeprom_first, 2);

				pt_return_handle("+INITDEVINFO:OK\r\n");
            }
        }
        else if(strstr(data,"AT+DEVINFO\r\n"))// 读取信息
        {
            device_info_get();//读取eeprom中的设备信息
            memset(sendbuff,0,sizeof(sendbuff));
            strcpy(sendbuff,"+DEVINFO:"); // 文件头

            memset(tempbuff,0,sizeof(tempbuff));
            sprintf(tempbuff,"%04x,%010u,%02x,%04x,",device_info.device_type,\
                            device_info.device_sn,\
                            device_info.pcb_ver,device_fixed_info.MCU_Type_ID);
            strcat(sendbuff,tempbuff);

            gw_net_send_02((char*)device_fixed_info.MCU_UUID,12,&lent);
            memset(tempbuff,0,sizeof(tempbuff));
            memcpy(tempbuff,Send_Buf_Char,lent);
            strcat(sendbuff,tempbuff);
            strcat(sendbuff,",");

            memset(tempbuff,0,sizeof(tempbuff));

            sprintf(tempbuff,"%s,%08x,%08x,%04x,%04x,%08x,,,,","", device_fixed_info.Soft_ver_boot,\
                            device_fixed_info.Soft_ver_app,device_info.batch_number,\
                            device_info.manufactures,device_info.production_data);
            strcat(sendbuff,tempbuff);

            lent = strlen(sendbuff);

            sendbuff[lent] = 0x0D;
            sendbuff[lent+1] = 0x0A;

            uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
        }
        else if(strstr(data,"AT+EEPROMERASE="))//擦除整片eeprom
        {
            p_data = strstr(data,"AT+EEPROMERASE=");
            if(strstr(p_data,"\r\n"))
            {
                sscanf(p_data,"AT+EEPROMERASE=%[^\r\n]\r\n",tempbuff);
                sscanf(tempbuff,"%[^,]",type);
                sscanf(type,"%04X",&device_type); // 设备类型
                if(device_type_cmp(SOFTWARE_VERSION_APP,(u16)device_type) == 0)
                {
					pt_return_handle("+EEPROMERASE:ERR,DEVICE_TYPE_MISMATCH\r\n");
                    memset(data,0,len);
					return;
                }
                
                eeprom_addr = 0;
                memset(eeprom_buf,0,EEPROM_BUF_LEN);

                for(i = 0; i < EEPROM_PAGE; i++)
                {
                    AT24CXX_Write(eeprom_addr, eeprom_buf, EEPROM_BUF_LEN);
                    eeprom_addr += EEPROM_BUF_LEN;
                }

                memset(sendbuff,0,sizeof(sendbuff));
                strcpy(sendbuff,"+EEPROMERASE:OK\r\n");
                uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
                
                //清除接收数据FIFO
                uart_blocking_read((char *)tempbuff, UART_DEBUG, 1);
            }
        }
        else if(strstr(data,"AT+RST\r\n"))//复位
        {
			pt_return_handle("+RST:OK\r\n");

            OSTimeDlyHMSM(0, 0, 0, 100, OS_OPT_TIME_DLY, &err);
            NVIC_SystemReset();
        }
        else if(strstr(data,"AT+EEPROMWR="))//测外部eeprom写
        {
            p_data=strstr(data,"AT+EEPROMWR=");
            if(strstr(p_data,"\r\n"))
            {
                memset(sendbuff,0,sizeof(sendbuff));
                sscanf(p_data,"AT+EEPROMWR=%[^\r\n]\r\n",tempbuff);
                sscanf(tempbuff,"%[^,]%[^,],%[^,],%[^,]",type,eepaddr,eeplen,sendbuff);

				sscanf(type,"%04X",&device_type); // 设备类型
                sscanf(eepaddr,"%04X",&eep_addr); //地址
                sscanf(eeplen,"%04X",&eep_len);  //长度
				if(device_type_cmp(SOFTWARE_VERSION_APP,(u16)device_type) == 0)
                {
					pt_return_handle("+EEPROMWR:ERR,DEVICE_TYPE_MISMATCH\r\n");
                    memset(data,0,len);
					return;
                }
                eep_len_temp = asciitohex(sendbuff,eeprom_buf,strlen(sendbuff)-2);			
                
                if(eep_len == eep_len_temp) //OK
                {
                    AT24CXX_Write(eep_addr,(uint8_t *)eeprom_buf,eep_len);

					pt_return_handle("+EEPROMWR:OK\r\n");
                }
                else//ERR
                {
					pt_return_handle("+EEPROMWR:ERR\r\n");
                }
            }
        }
        else if(strstr(data,"AT+EEPROMRD="))//测外部eeprom读
        {
            p_data=strstr(data,"AT+EEPROMRD=");
			if(strstr(p_data,"\r\n"))
            {
                sscanf(p_data,"AT+EEPROMRD=%[^\r\n]\r\n",tempbuff);
                sscanf(tempbuff,"%[^,],%[^,]",eepaddr,eeplen);

                sscanf(eepaddr,"%04X",&eep_addr); //地址
                sscanf(eeplen,"%04X",&eep_len);  //长度
                
                AT24CXX_Read(eep_addr,eeprom_buf,eep_len);
                
                memset(Send_Buf_Char,0,sizeof(Send_Buf_Char));
                gw_net_send_02((char*)eeprom_buf,eep_len,&lent);
                
                memset(sendbuff,0,sizeof(sendbuff));
                strcpy(sendbuff,"+EEPROMRD:"); // 文件头
                
                memset(tempbuff,0,sizeof(tempbuff));
                sprintf(tempbuff,"%04x,%04x,",eep_addr,eep_len);
                strcat(sendbuff,tempbuff);
                
                strcat(sendbuff,Send_Buf_Char);
                
                lent = strlen(sendbuff);

                sendbuff[lent] = 0x0D;
                sendbuff[lent+1] = 0x0A;

                uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
            }
        }
        else if(strstr(data,"AT+INITLORAPARAINDEX=WBJW,")) //写LoRa参数当前组索引号
        {
            p_data=strstr(data,"AT+INITLORAPARAINDEX=WBJW,");
            if(strstr(p_data,"\r\n"))
            {
                sscanf(p_data,"AT+INITLORAPARAINDEX=WBJW,%[^\r\n]\r\n",tempbuff);
                sscanf(tempbuff,"%[^,]",type);
                sscanf(type,"%u",&device_type); //lora索引
                if(device_type < LORA_GROUP_NUM)//正确
                {
                    eepaddr[0] = device_type;
                    eepaddr[1] = ~eepaddr[0];
                    AT24CXX_Write(LORA_ADDR,(uint8_t *)eepaddr,2);

					pt_return_handle("+INITLORAPARAINDEX:OK\r\n");
                }
                else
                {
					pt_return_handle("+INITLORAPARAINDEX:ERR\r\n");
                }
            }
        }
        else if(strstr(data,"AT+LORAPARAINDEX\r\n")) //读LoRa参数当前组索引号
        {
            memset(sendbuff,0,sizeof(sendbuff));
            strcpy(sendbuff,"+LORAPARAINDEX:"); // 文件头
            
            AT24CXX_Read(LORA_ADDR,(uint8_t *)eepaddr,2);
            
            memset(tempbuff,0,sizeof(tempbuff));
            sprintf(tempbuff,"%u",eepaddr[0]);
            strcat(sendbuff,tempbuff);
            
            lent = strlen(sendbuff);
            sendbuff[lent] = 0x0D;
            sendbuff[lent+1] = 0x0A;
            uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
        }
        else if(strstr(data,"AT+ENCRYPT\r\n")) //读连接器加密状态
        {
            memset(sendbuff,0,sizeof(sendbuff));
            strcpy(sendbuff,"+ENCRYPT:"); // 文件头
            
            memset(tempbuff,0,sizeof(tempbuff));
            sprintf(tempbuff,"%u",device_fixed_info.Encrypt);
            strcat(sendbuff,tempbuff);
            
            lent = strlen(sendbuff);
            sendbuff[lent] = 0x0D;
            sendbuff[lent+1] = 0x0A;
            uart_msg_send(UART1_ID, sendbuff, strlen(sendbuff));
        }
        else if(strstr(data,"AT+OFFLINE=")) //测试。下发离线升级指令
        {
            p_data=strstr(data,"AT+OFFLINE=");
            if(strstr(p_data,"\r\n"))
            {
				sscanf(p_data,"AT+OFFLINE=%[^\r\n]\r\n",tempbuff);
				sscanf(tempbuff,"%[^,],%[^,],%[^,]",master_snb,slave_snb,des_snb);

//                sscanf((char*)p_data,"AT+OFFLINE=%[^,],%[^,],%[^,]\r\n",master_snb,slave_snb,des_snb);

                sscanf(master_snb,"%u",&master_sn);
                sscanf(slave_snb,"%u",&slave_sn);
                sscanf(des_snb,"%u",&des_sn);

                if(slave_sn != des_sn)//失败
                {
					pt_return_handle("+OFFLINE:ERR\r\n");
                }
                else //成功
                {
					pt_return_handle("+OFFLINE:OK\r\n");

                    //退出产测
                    g_ptTest.bTestStart = PT_OFF;
					printf("master:%u,slave:%u,des:%u\n",master_sn,slave_sn,des_sn);
					pt_return_handle("+PTMOD:OFF,00000001\r\n");
                    
                    if(device_info.alrd == DEVICE_ALRD)//已初始化
                    {
                        device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL;
                    }
                    else
                    {
                        device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT;
                    }
					timeout_stop(&g_ptTest.tt_pt_time);//关闭产测定时
					
//                    //Lora发送命令
//                    lora_offline_update(master_sn,slave_sn,des_sn);
                }  
            }
        }
    }
    memset(data,0,len);
}

//uint8_t rcv_buf_pt[256]; 
//uint16_t rcv_size_pt = 0,rcv_size_temp_pt = 0;
//产测执行函数
void pt_handle(void)
{
    rcv_size = uart_blocking_read((char *)rcv_buf, UART_DEBUG, 1);
    if(rcv_size) 
    {
        rcv_size_temp = rcv_size;
        rcv_size = uart_blocking_read((char *)rcv_buf+rcv_size_temp, UART_DEBUG, 50);
        rcv_size += rcv_size_temp;
        uart_cmd_task((char *)rcv_buf,rcv_size);
		
		if(g_ptTest.bTestStart == PT_ON)
		{
			timeout_setValue(&g_ptTest.tt_pt_time,PT_TIME,1);//打开产测定时
		}
    }
	
	//产测超时判断
	//连续一段时间未收到产测指令，关闭产测
	if(timeout_isOut(&g_ptTest.tt_pt_time))
	{
		g_ptTest.bTestStart = PT_OFF;
		
		device_info_get();//读取eeprom中的设备信息
		if(device_info.alrd == DEVICE_ALRD)//已初始化
		{
			device_fixed_info.Work_State = DEV_WORK_STATE_NORMAL;
		}
		else
		{
			device_fixed_info.Work_State = DEV_WORK_STATE_UNINIT;
		}
		printf("pt off\n");
	}
}