#include #include #include #include #include #include #include #include #include #include #include #include /* netdb is necessary for struct hostent */ #include "../inc/config.h" #include "../inc/os_task.h" #include "../inc/type.h" #include "../inc/tcp_task.h" #include "../inc/general_api.h" #include "../inc/isys_config.h" #include "../inc/delay.h" #include "../inc/i2c_drv.h" #include "../inc/lcd_task.h" #include "../inc/iuart_user.h" #include "../inc/eeprom.h" #include "../inc/log_task.h" #include "../inc/isys_com.h" #include "../inc/upgrade.h" uint8 fpga_up_sys_reboot = 0; #if USE_LOG_MODULE//@STAY_FINAL_PROC：留在最后处理 #else// uint32 log_system_event_generate(S_SYS_TIME* ptime,uint32 type,uint8 *pcontent,uint32 ctlen) { } #endif //#include "stm32f4x7_eth.h" //#include "stm32f4x7_eth_bsp.h" /* #include "stm32f4xx_hal.h" #include "sockets.h" #include "os_task.h" #include "type.h" #include "tcp_task.h" #include "cgifuncs.h" #include "os_task.h" #include "eeprom.h" #include "lcd_task.h" #include "i2c_drv.h" #include "uart_user.h" #include "tcp.h" #include "delay.h" #include "general_api.h" #include "sys_config.h" #include "config.h" #include "fpga.h" */ #if ALARM_USE_UDP extern struct sockaddr_in alarm_clientaddr; extern int alarm_sockfd; #endif #if USE_TCP_COMM extern uint8 std_r[]; extern uint8 std_w[]; #define TCP_REMOTE_MAX_REC_LEN 128 #define TCP_REMOTE_MAX_SEND_LEN 128 static uint32 tcp_remote(uint8 *pbuf,uint8* poutbuf) { uint32 send_len = 0; uint32 set_result = 0; if(memcmp(std_r,pbuf,3)==0) //头部检查 { if(get_check_sum(pbuf,4)==pbuf[4])//查询命令 { send_len = protocol_read(pbuf,poutbuf);//回复 } } if(memcmp(std_w,pbuf,3)==0) { if(get_check_sum(pbuf,8)==pbuf[8])//设置命令 { set_result = protocol_write(pbuf,poutbuf);//配置本地参数 } else { set_result = UART_PARA_SET_ERR_SUM; } send_len = uart_init_set_result_frame(pbuf,poutbuf,set_result); //串口和网口一套协议 } return send_len; } /* void tcp_remote_task(void * pvParameters) { struct sockaddr_in server_addr; struct sockaddr_in conn_addr; int sock_fd; int sock_conn; socklen_t addr_len; int err; int length; static uint8 inbuf_tcp[TCP_REMOTE_MAX_REC_LEN] = {0,}; static uint8 outbuf_tcp[TCP_REMOTE_MAX_SEND_LEN] = {0,}; (void)pvParameters; task_set_ignore_chk(TCP_REMOTE_TASK_ID); vTaskDelay(15); printf("%s init start...\n",__FUNCTION__); sock_fd = lwip_socket(AF_INET, SOCK_STREAM, 0); if (sock_fd == -1) { printf("failed to create tcp sock_fd!\n"); } memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr =htonl(INADDR_ANY); server_addr.sin_port = htons(TCP_COMM_PORT); err = lwip_bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)); if (err < 0) { printf("failed to bind sock_fd!\n"); } err = lwip_listen(sock_fd, 5); if (err < 0) { printf("failed to listen sock_fd!\n"); } addr_len = sizeof(struct sockaddr_in); printf("%s init over.\n",__FUNCTION__); while(1) { //均为阻塞性 sock_conn = lwip_accept(sock_fd, (struct sockaddr *)&conn_addr, &addr_len); while(sock_conn!=-1) { memset(inbuf_tcp, 0, sizeof(inbuf_tcp)); length = lwip_recv(sock_conn, (unsigned int *)inbuf_tcp, TCP_REMOTE_MAX_REC_LEN, 0); if(length) { length = tcp_remote(inbuf_tcp,outbuf_tcp); if(length) { lwip_send(sock_conn,outbuf_tcp ,length, 0); } } else { lwip_close(sock_conn); sock_conn = -1; break; } } } } void udp_remote_task(void* pvParameters) { struct sockaddr_in server_addr; int sock_fd; int err; int length; struct sockaddr from; socklen_t fromlen; static uint8 udp_inbuf[TCP_REMOTE_MAX_REC_LEN] = {0,}; static uint8 udp_outbuf[TCP_REMOTE_MAX_SEND_LEN] = {0,}; task_set_ignore_chk(UDP_REMOTE_TASK_ID); printf("%s init start...\n",__FUNCTION__); sock_fd = lwip_socket(AF_INET, SOCK_DGRAM, 0); if(sock_fd == -1) { printf("failed to create tcp sock_fd!\n"); } memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr =htonl(INADDR_ANY); server_addr.sin_port = htons(TCP_COMM_PORT); err = lwip_bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)); if(err < 0) { printf("failed to bind sock_fd!\n"); } printf("%s init over.\n",__FUNCTION__); while(1) { //阻塞型 length = lwip_recvfrom(sock_fd,udp_inbuf,TCP_REMOTE_MAX_REC_LEN, 0,&from,&fromlen); if(length) //具体处理待定 { length = tcp_remote(udp_inbuf,udp_outbuf); if(length) { lwip_sendto(sock_fd, udp_outbuf,length, 0,&from,fromlen); } } } } */ #endif #if FPGA_UPGRADE //---------------------------------------------- static uint8 rxdata[MAX_DATA_LEN]={0}; //TCP通讯 接收 static uint8 txdata[TX_DATA_LEN] = //TCP通讯 发送 { 0x7E, // head 0xFF,0xFF, // address 0x00, // cmd 0x02,0x00, // data len 0x00,0x00, // data 0x00, // sum 0x0D // tail }; static uint8 recvData[MAX_DATA_LEN]={0}; //TCP通讯 解析 static uint8 writeBuf[MAX_PER_FRAME_LEN]={0}; S_UP_STATE upState={0}; static const char div_str[]={":"}; //----------------------------------------------- void send_upgrade_msg(uint8 lcdDisplayType) { set_trigger_lcd_menu(lcdDisplayType); /*MSG *pmsg = alloc_msg(); if(pmsg) { pmsg->type = msgType; pmsg->need_free = MSG_NEED_FREE; send_msg(LCD_TASK_ID,pmsg); }*/ #if 0//WEB_MSG_CFG MSG msg; msg.type = MSG_FPGA_UPGRADE; msg.need_free = MSG_NO_NEED_FREE; msg.wPara = lcdDisplayType; msg_send_to_lcd(&msg); #endif } uint8 char_to_hex(uint8 ch) { uint8 value = 0; if(ch >= '0' && ch <= '9') { value = ch -0x30; } else if(ch >='A' && ch <='F') { value = (ch-'A') + 10; } else if(ch >='a' && ch <='f') { value = (ch-'a') + 10; } return value; } int conv_ascii2hex(uint8 *charBuf,uint8 *hexBuf,uint16 charLen) { uint16 retLen=0; uint16 i,j; if(!charBuf) return -1; if(!hexBuf) return -1; if(charLen%2!=0) return -1; if(charLen<2) return -1; for(i=0,retLen=0;iUPDATA_RAW_FRAME_MAX_LEN){ return -2; } if(recvLenlenH); lenl = char_to_hex(pUpFrame->lenL); length = (lenh<<4)|(lenl); typeh = char_to_hex(pUpFrame->typeH); typel = char_to_hex(pUpFrame->typeL); type = (typeh<<4)|(typel); if(length==0x10) { if(type==0x00)//数据 { memset(tempBuf,0,sizeof(tempBuf)); memcpy(tempBuf,pUpFrame->data,32); retLen = conv_ascii2hex(tempBuf,parseBuf,32); } } else if(length==0x00)//结束 { if(type==0x01)//文件末尾 { retLen = -1; } } return retLen; } uint8 check_fpga_write_busy(void) { uint16 timeout=0; uint8 rstate=0; uint8 ret=0; //管脚为1时，进行检测 while(GET_FPGA_SPI_MISO()==1) { rstate = fpga_byte_read(0x01,FPGA_UPGRADE_CTRL_ADDR); while((rstate&FPGA_UP_STATUS_BUSY_MASK==0)){ rstate = fpga_byte_read(0x01,FPGA_UPGRADE_CTRL_ADDR); delay_us(10); timeout++; if(timeout>=1000){// 10ms return 0xff; } }; } return ret; } int check_fpga_write_busy_V2(void) { uint16 timeout=0; uint8 rstate=0; uint8 ret=0; uint8 i = 0; uint8 count = 0; //管脚为1时，进行检测 while(GET_FPGA_SPI_MISO()==1) { delay_us(1); count++; if(count > 100) { rstate = fpga_byte_read(0x01,FPGA_UPGRADE_CTRL_ADDR); if(rstate & FPGA_UP_STATUS_BUSY_MASK) { return -1; } } } return 0; } void reset_fpga_system(void) { fpga_byte_write(0x01,FPGA_UPGRADE_CTRL_ADDR,FPGA_UP_CTRL_RESET_EN_MASK|FPGA_UP_CTRL_HDRESET_EN_MASK); } void reset_imx_system(void) { system("sync"); system("reboot"); } uint8 check_fpga_upgrade_done(void) { uint8 rstate = 0; uint8 ret_data = READY; //h-up-state rstate = fpga_byte_read(0x01,FPGA_UPGRADE_CTRL_ADDR); if(rstate&FPGA_UP_STATUS_DONE_MASK){ log_printf(LOG_DEBUG,I_NOUSED," rstate=0x%x\n",rstate); //升级完成 //fpga_byte_write(0x01,FPGA_UPGRADE_CTRL_ADDR,FPGA_UP_CTRL_RESET_EN_MASK|FPGA_UP_CTRL_HDRESET_EN_MASK); reset_fpga_system(); fpga_up_sys_reboot = 1; //reset_imx_system(); // #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_OVER);//MSG_FPGA_UPGRADE_OVER #endif upState.curSate=UPSTATE_FEADBACK_END; ret_data = ABORT_SUCCESS; if(rstate&FPGA_UPGRADE_STATUS_ERROR_MASK){ //升级出错 fpga_byte_write(0x01,FPGA_UPGRADE_CTRL_ADDR,FPGA_UP_CTRL_RESET_EN_MASK); #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_ERR);//MSG_FPGA_UPGRADE_ERR #endif upState.errCnt++; ret_data = ABORT_ERROR; } } return ret_data; } void recv_pkg_parse(uint8 *recvBuf,uint8 *pOutFrame)// get total linenum { if(!recvBuf)return; if(!pOutFrame)return; pOutFrame = strtok(recvBuf,":");// ':' } int find_char (char **strings,char value) { int num=0; char *string; while((string= *strings++)!=NULL) { while(*string!='\0') { if(*string++==value) { num++; } } } return num; } uint16 get_recv_pkg_line_num(uint8 *recvBuf,uint16 dataLen) { char *pStr=NULL; uint16 lineNum=0; if(!recvBuf)return 0; if(!dataLen)return 0; pStr=recvBuf; while(1) { pStr = strchr(pStr,':'); if(pStr!='\0') { lineNum++; } else{ break; } } return lineNum; } void test_only_write_file(void) { #define MAX_FILE_LEN (25*1024*1024) #define MAX_LINE (1000) FILE *fp; char load_file[20] = "./cttb.mcs"; uint8 line[MAX_LINE]; int len = 0; static int count = 0; uint8 * pWriteData = NULL; fp = fopen(load_file, "r"); if(fp == NULL) { log_printf(LOG_ERR,I_NOUSED,"can not load file!"); return ; } log_printf(LOG_DEBUG,I_NOUSED,"START get %s line \n",load_file); while(fgets(line, MAX_LINE, fp) != NULL) { len = strlen(line); len = len - 1; count++; if(count >= 1024){ log_printf(LOG_DEBUG,I_NOUSED,"len=%d count 1024\n", len); count = 0; } if(len>=4)//写到fpga { pWriteData = (uint8*)(line); while(len){// 4字节写入 ispi_fpga_send_buf_4Byte(pWriteData); pWriteData = pWriteData+4; len= len-4; //printf("-len=%d\n", len); } //printf("ready UPSTATE_WRITE\n"); } } log_printf(LOG_DEBUG,I_NOUSED,"%s write over\n", load_file); fclose(fp); } extern void set_fpga_up_result(uint8 res); int g_now_only_upgrade_fpga = 0; static uint32 fpga_upgrade_process(void) { S_FPGA_UP_FRAME_NEW *pframe; int datalen = 0; uint8 sum = 0; uint8 rstate = 0; uint8 ret_data= 0; uint8 *pSemi1 =NULL; uint8 *pSemi2 =NULL; uint8 *pLineData =NULL; uint8 *pWriteData =NULL; int lineDataLen =0; int retDataLen =0; uint8 pkgFirstFlg =0; static uint8 tstFlg=0; static uint16 ck_cnt; static uint8 first_byte = 0; int i = 0; pframe = (S_FPGA_UP_FRAME_NEW*)&rxdata[0]; datalen = pframe->datalen; txdata[0] = rxdata[0]; txdata[1] = rxdata[1]; if((rxdata[0] != 0xAA) || (rxdata[datalen + 5] != 0xBB)) { log_printf(LOG_DEBUG,I_NOUSED,"no aa bb\n"); return 0; } if(!sys_ready) { return 0; } sum = get_check_sum(rxdata,datalen+4); if(sum != rxdata[datalen + 4]) { txdata[1] = 0xAA; txdata[2] = 0; txdata[3] = 1; txdata[4] = NOT_READY; txdata[5] = get_check_sum(txdata,4); txdata[6] = 0xBB; return 7; } //校验和通过,报文正常 pframe = (S_FPGA_UP_FRAME_NEW*)&rxdata[0]; switch(pframe->cmd) { case UPGRADE_START: // 1：RU_inReset_EnableB 寄存器写1，RU_inCheckIdOnly 和 RU_inVerifyOnly 均置0； fpga_byte_write(0x01,FPGA_UPGRADE_CTRL_ADDR,FPGA_UP_CTRL_RESET_EN_MASK); log_printf(LOG_DEBUG,I_NOUSED,"1 FPGA_UPGRADE_CTRL_ADDR,FPGA_UP_CTRL_RESET_EN_MASK\n"); fpga_byte_write(0x01,FPGA_UPGRADE_CTRL_ADDR,FPGA_UP_CTRL_RESET_EN_MASK); log_printf(LOG_DEBUG,I_NOUSED,"1 FPGA_UPGRADE_CTRL_ADDR,FPGA_UP_CTRL_RESET_EN_MASK\n"); // 2： RU_inReset_EnableB 再写0，开启远程升级； fpga_byte_write(0x01,FPGA_UPGRADE_CTRL_ADDR,0); fpga_byte_write(0x01,FPGA_UPGRADE_CTRL_ADDR,0); ret_data = START_OK; log_printf(LOG_DEBUG,I_NOUSED," 1 FPGA_UPGRADE_CTRL_ADDR,0\n"); upState.curSate=UPSTATE_START; upState.errCnt=0; upState.lineCnt=0; set_fpga_up_result(0); ck_cnt=0; break; case POLL_ERASER: if(GET_FPGA_SPI_MISO()==1){ ret_data = ERASER_ING; upState.curSate=UPSTATE_EARSEING; log_printf(LOG_DEBUG,I_NOUSED,"eing--upState.curSate=%s\n", "UPSTATE_EARSEING"); } else{ rstate = fpga_byte_read(0x01,FPGA_UPGRADE_CTRL_ADDR); if(rstate&FPGA_UP_STATUS_EARSE_OK_MASK){ ret_data = ERASER_END; upState.curSate=UPSTATE_EARSE_END; g_now_only_upgrade_fpga = 1; log_printf(LOG_DEBUG,I_NOUSED,"g_now_only_upgrade_fpga 1\n"); } else{ ret_data = ERASER_ING; upState.curSate=UPSTATE_EARSEING; } log_printf(LOG_DEBUG,I_NOUSED,"ing|end --- %s, rstate=0x%x\n", upState.curSate==UPSTATE_EARSE_END?"UPSTATE_EARSE_END":"UPSTATE_EARSEING",rstate); } if(tstFlg==1){ tstFlg=0; ret_data = ERASER_END; upState.curSate=UPSTATE_EARSE_END; log_printf(LOG_DEBUG,I_NOUSED,"end------upState.curSate=%s\n", "UPSTATE_EARSE_END"); } break; case W_DATA_BLOCK: //接收缓存数据 memset(recvData,0,sizeof(recvData)); memcpy(recvData,rxdata+4,datalen); pkgFirstFlg = 1; pSemi1 = recvData; pSemi2 = recvData; //解析缓存数据 while(1) { //解析出一行数据 if(pkgFirstFlg){ pkgFirstFlg=0; pSemi1 = strchr(pSemi1,':'); if(pSemi1==NULL) { ret_data = ABORT_ERROR;//错误，一般不进这里 break; } } pSemi2 = strchr(pSemi1+1,':'); if(pSemi2==NULL){ lineDataLen = strlen(pSemi1); pLineData = pSemi1; } else{ pLineData = pSemi1; lineDataLen = ((uint32)pSemi2 - (uint32)pSemi1); pSemi1 = pSemi2; } //解析行数据并写入 if(lineDataLen!=0) { memset(writeBuf,0,sizeof(writeBuf)); retDataLen = recv_upgrade_data_parse(pLineData,writeBuf,lineDataLen);//行数据 upState.lineCnt++; // 写到fpga [16 case .mcs file format .] if(retDataLen >= 16) { //rstate=check_fpga_write_busy_V2(); rstate=check_fpga_write_busy(); if(rstate == 0xff){ log_printf(LOG_DEBUG,I_NOUSED,"check_fpga_write_busy ,rstate =%x\n", rstate); #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_BUSY_TIMEOUT); #endif return 0xff; } pWriteData = (uint8*)(writeBuf); // if(first_byte==0) { // for(i = 0; i < retDataLen; i++) // printf("0x%x ", pWriteData[i]); // printf("\n"); // first_byte++; // } while(retDataLen){// 4字节写入 ispi_fpga_send_buf_4Byte(pWriteData); pWriteData = pWriteData+4; retDataLen= retDataLen-4; } upState.curSate = UPSTATE_WRITE; ret_data = READY; //printf("ready UPSTATE_WRITE\n"); } else if(retDataLen==-1){//全部写结束 upState.curSate=UPSTATE_FILE_END; ck_cnt=0; delay_ms(200); ret_data = check_fpga_upgrade_done(); log_printf(LOG_DEBUG,I_NOUSED,"cnt=0 UPSTATE_FILE_END\n"); g_now_only_upgrade_fpga = 0; } else if(retDataLen==-2){//长度错误 upState.curSate=UPSTATE_WRITE; ret_data = ABORT_ERROR; #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_ERR);//MSG_FPGA_UPGRADE_ERR #endif log_printf(LOG_DEBUG,I_NOUSED,"ABORT_ERROR UPSTATE_WRITE\n"); g_now_only_upgrade_fpga = 0; } else{//中间控制字段 ret_data = READY; } } else{ ret_data = ABORT_ERROR; g_now_only_upgrade_fpga = 0; } if(pSemi1==NULL||pSemi2==NULL) { break; } } break; case W_DATA_BLOCK_LAST: if(upState.curSate==UPSTATE_FILE_END) { ret_data = check_fpga_upgrade_done(); if(ret_data==ABORT_SUCCESS){ ret_data = ABORT_SUCCESS; #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_OVER);//MSG_FPGA_UPGRADE_OVER #endif g_now_only_upgrade_fpga = 0; log_printf(LOG_DEBUG,I_NOUSED,"ABORT_SUCCESS DISPLAY_FPGA_UPGRADE_OVER g_now_only_upgrade_fpga 0\n"); } else if(ret_data==ABORT_ERROR){ ret_data = ABORT_ERROR; #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_ERR);//MSG_FPGA_UPGRADE_ERR #endif g_now_only_upgrade_fpga = 0; log_printf(LOG_DEBUG,I_NOUSED,"ABORT_ERROR DISPLAY_FPGA_UPGRADE_ERR g_now_only_upgrade_fpga 0\n"); } else{ ck_cnt++; if(ck_cnt>=100){ ret_data = ABORT_ERROR; #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_ERR);//MSG_FPGA_UPGRADE_ERR #endif g_now_only_upgrade_fpga = 0; log_printf(LOG_DEBUG,I_NOUSED,"ABORT_ERROR DISPLAY_FPGA_UPGRADE_ERR g_now_only_upgrade_fpga 0\n"); } } delay_ms(200); } else{ ret_data = check_fpga_upgrade_done(); if(ret_data==ABORT_SUCCESS){ ret_data = ABORT_SUCCESS; #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_OVER);//MSG_FPGA_UPGRADE_OVER #endif g_now_only_upgrade_fpga = 0; log_printf(LOG_DEBUG,I_NOUSED,"ABORT_SUCCESS DISPLAY_FPGA_UPGRADE_OVER g_now_only_upgrade_fpga 0\n"); } else if(ret_data==ABORT_ERROR){ ret_data = ABORT_ERROR; #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_ERR);//MSG_FPGA_UPGRADE_ERR #endif g_now_only_upgrade_fpga = 0; log_printf(LOG_DEBUG,I_NOUSED,"ABORT_SUCCESS DISPLAY_FPGA_UPGRADE_ERR g_now_only_upgrade_fpga 0\n"); } else{ ck_cnt++; if(ck_cnt>=100){ ret_data = ABORT_ERROR; #if FPGA_UP_MSG send_upgrade_msg(DISPLAY_FPGA_UPGRADE_ERR);//MSG_FPGA_UPGRADE_ERR #endif g_now_only_upgrade_fpga = 0; log_printf(LOG_DEBUG,I_NOUSED,"ABORT_ERROR DISPLAY_FPGA_UPGRADE_ERR g_now_only_upgrade_fpga 0\n"); } } delay_ms(200); } break; default:break; } txdata[0] = 0xAA; txdata[1] = ret_data; txdata[2] = 1; txdata[3] = 0; txdata[4] = ret_data; txdata[5] = get_check_sum(txdata,5); txdata[6] = 0xBB; return 7; } /* void fpga_upgrade_task(void * pvParameters) { struct sockaddr_in server_addr; struct sockaddr_in conn_addr; int sock_fd; int sock_conn; socklen_t addr_len; int err; int length; task_set_ignore_chk(FPGA_UPGRADE_TASK_ID); (void)pvParameters; vTaskDelay(10); printf("%s init start...\n",__FUNCTION__); sock_fd = lwip_socket(AF_INET, SOCK_STREAM, 0); if (sock_fd == -1) { printf("failed to create fpga sock_fd!\n"); } memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr =htonl(INADDR_ANY); server_addr.sin_port = htons(UPGRADE_LISTEN_PORT); err = lwip_bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)); if (err < 0) { printf("failed to bind sock_fd!\n"); } err = lwip_listen(sock_fd,1); //只允许一个客户端连接 if (err < 0) { printf("failed to listen sock_fd!\n"); } addr_len = sizeof(struct sockaddr_in); printf("%s init over.\n",__FUNCTION__); while(1) { //accept和recv均为阻塞性 sock_conn = lwip_accept(sock_fd, (struct sockaddr *)&conn_addr, &addr_len); while(sock_conn!=-1) { memset(rxdata, 0, sizeof(rxdata)); length = lwip_recv(sock_conn, (unsigned int *)rxdata, MAX_DATA_LEN, 0); if(length) { length = fpga_upgrade_process(); if(length==0xff){//出错后主动断开连接 lwip_close(sock_conn); sock_conn = -1; break; } lwip_send(sock_conn, txdata,length, 0); } else { lwip_close(sock_conn); sock_conn = -1; break; } } } }*/ #endif//FPGA_UPGRADE #if 0//FPGA_UPGRADE #define FPGA1_UPGRADE_ADDRESS (0XFFFF) #define FPGA2_UPGRADE_ADDRESS (0X1FFF) #define MAX_DATA_LEN 544 #define TX_DATA_LEN 10 static uint8 rxdata[MAX_DATA_LEN]={0}; //TCP通讯 接收 static uint8 txdata[TX_DATA_LEN] = //TCP通讯 发送 { 0x7E, // head 0xFF,0xFF, // address 0x00, // cmd 0x02,0x00, // data len 0x00,0x00, // data 0x00, // sum 0x0D // tail }; static uint32 fpga_upgrade_process(void) { uint32 len = 0; uint8 sum = 0; S_FPGA_UP_FRAME *pframe; uint32 filelen; uint32 offset; uint8 data = 0; len = (rxdata[5]<<8) | rxdata[4]; txdata[1] = rxdata[1]; txdata[2] = rxdata[2]; //address txdata[6] = rxdata[6]; txdata[7] = rxdata[7]; if((rxdata[0] != 0x7E) || (rxdata[len + 7] != 0x0D)) { return 0; } if(!sys_ready) { return 0; } sum = get_check_sum(rxdata,len+6); if(sum!=rxdata[len + 6]) { txdata[3] = 0x03; txdata[8] = get_check_sum(txdata,8); return 10; } //校验和通过,报文正常 pframe = (S_FPGA_UP_FRAME*)&rxdata[0]; switch(pframe->addres) { case FPGA1_UPGRADE_ADDRESS: default: fpga_reset_save_segment(); switch(pframe->cmd) { case 0x0: txdata[3] = 0x01; //写成字节或的形式,直接转指针,开优化选项后,会引起异常 //filelen = *((uint32*)(rxdata+8)); filelen = (rxdata[11]<<24)|(rxdata[10]<<16)|(rxdata[9]<<8)|(rxdata[8]<<0); //offset = *((uint32*)(rxdata+12)); offset = (rxdata[15]<<24)|(rxdata[14]<<16)|(rxdata[13]<<8)|(rxdata[12]<<0); if(filelen<=offset+len-10) { MSG *pmsg = alloc_msg(); if(pmsg) { pmsg->type = MSG_FPGA_UPGRADE_OVER; pmsg->need_free = MSG_NEED_FREE; send_msg(LCD_TASK_ID,pmsg); } } spi_fpga_send_buf((uint8*)(rxdata+16) , len-10); break; case 0x10: //进入升级模式 data = fpga_byte_read(0x01,FPGA_UPGRADE_I2C_REG_ADDRES); if((data == 0x21) || (data == 0x22)) { fpga_reset_save_segment(); //切换到升级模式后,实际相当于换了个APP,段地址需要强制重发 fpga_byte_write(0x01,FPGA_UPGRADE_I2C_REG_ADDRES,pframe->cmd); } break; case 0x11: case 0x12: //GOTO app1 //GOTO app2 data = fpga_byte_read(0x01,FPGA_UPGRADE_I2C_REG_ADDRES); fpga_byte_write(0x01,FPGA_UPGRADE_I2C_REG_ADDRES,pframe->cmd); break; case 0x13: data = fpga_byte_read(0x01,FPGA_UPGRADE_I2C_REG_ADDRES); fpga_byte_write(0x01,FPGA_UPGRADE_I2C_REG_ADDRES,pframe->cmd); break; case 0x14: data = fpga_byte_read(0x01,FPGA_UPGRADE_I2C_REG_ADDRES); fpga_byte_write(0x01,FPGA_UPGRADE_I2C_REG_ADDRES,pframe->cmd); break; case 0x15: case 0x16: case 0x17: data = fpga_byte_read(0x01,FPGA_UPGRADE_I2C_REG_ADDRES); fpga_byte_write(0x01,FPGA_UPGRADE_I2C_REG_ADDRES,pframe->cmd); break; case 0x18: data = fpga_byte_read(0x01,FPGA_UPGRADE_I2C_REG_ADDRES); break; } fpga_reset_save_segment(); break; } if(pframe->cmd>=0x10) { txdata[3] = pframe->cmd; txdata[4] = 0x01; txdata[5] = 0x00; txdata[6] = data; txdata[7] = get_check_sum(txdata,7); txdata[8] = 0x0d; txdata[9] = 0x00; } else { txdata[3] = 1; txdata[4] = 0x02; txdata[5] = 0x00; txdata[6] = 0; txdata[7] = 0; txdata[8] = get_check_sum(txdata,8); txdata[9] = 0x0d; } return 10; } /* void fpga_upgrade_task(void * pvParameters) { struct sockaddr_in server_addr; struct sockaddr_in conn_addr; int sock_fd; int sock_conn; socklen_t addr_len; int err; int length; (void)pvParameters; task_set_ignore_chk(FPGA_UPGRADE_TASK_ID); vTaskDelay(10); printf("%s init start...\n",__FUNCTION__); sock_fd = lwip_socket(AF_INET, SOCK_STREAM, 0); if (sock_fd == -1) { printf("failed to create fpga sock_fd!\n"); } memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr =htonl(INADDR_ANY); server_addr.sin_port = htons(UPGRADE_LISTEN_PORT); err = lwip_bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)); if (err < 0) { printf("failed to bind sock_fd!\n"); } err = lwip_listen(sock_fd,1); //只允许一个客户端连接 if (err < 0) { printf("failed to listen sock_fd!\n"); } addr_len = sizeof(struct sockaddr_in); printf("%s init over.\n",__FUNCTION__); while(1) { //accept和recv均为阻塞性 sock_conn = lwip_accept(sock_fd, (struct sockaddr *)&conn_addr, &addr_len); while(sock_conn!=-1) { memset(rxdata, 0, sizeof(rxdata)); length = lwip_recv(sock_conn, (unsigned int *)rxdata, MAX_DATA_LEN, 0); if(length) { length = fpga_upgrade_process(); lwip_send(sock_conn, txdata,length, 0); } else { lwip_close(sock_conn); sock_conn = -1; break; } } } }*/ #endif #if USE_SPECT_DATA_TASK extern void spi0_read(uint32 len,void *pdata,uint32 restart); static uint32 tcp_spect_init_send_frame(uint32 param,struct tcp_data_frame * pframe); static uint8 spect_data_buf[TCP_FRAME_DATA_LEN+32]; //FPGA读取的数据 1次读取1K字节,共256个复数 static uint8 tcp_rec_buf[TCP_SPECT_REC_BUF_LEN]; //接收报文缓冲区 static uint8 tcp_send_buf[TCP_SPECT_SEND_BUF_LEN]; //发送报文缓冲区 static uint32 licence_valid = FALSE; //系统授权法是否有效合法,默认为FALSE static uint64 sn = 0; static uint32 input_licence = 0; #if SPECT_DEBUG_MODE extern uint32 check_delay_over(uint32 *ptick,uint32 cycle); extern void Delayus(uint32 m); extern int sprintf(char *,const char *,...); #endif /***************************************************************************** 函 数 名 : spect_update_imd_snr 功能描述 : 更新FPGA的SNR和IMD信息 输入参数 : void 输出参数 : 无 返 回 值 : static 调用函数 : 被调函数 : 修改历史 : 1.日 期 : 2013年2月27日 作 者 : 郭金涛 修改内容 : 新生成函数 *****************************************************************************/ static void spect_update_imd_snr(struct snr_imd *psnr) { if(!psnr) return; psnr->rsnr = fpga_byte_read(0x1,0x44); psnr->tsnr = fpga_byte_read(0x1,0x46); psnr->limd = fpga_byte_read(0x1,0x45); psnr->uimd = fpga_byte_read(0x1,0x47); } /***************************************************************************** 函 数 名 : spect_update_data 功能描述 : 更新发送的频谱数据信息 输入参数 : void 输出参数 : 无 返 回 值 : void 调用函数 : 被调函数 : 修改历史 : 1.日 期 : 2013年1月30日 作 者 : 郭金涛 修改内容 : 新生成函数 一共需更新16KB的数据,当前FPGA只支持单字节读取(不支持连续模式),经测试,16kB数据全部读完至少10s以上 由于本任务优先级较高,其它任务将被挂起,因此此时液晶按键,串口等都不再响应; *****************************************************************************/ static void spect_update_data(uint32 index) { uint32 restart_flag = 0; struct snr_imd* psnr; struct frame_struct* pdata; if(index==1) //第一帧,需要发送数据重发标志 32k为一个整体,读32k后,重新读取 restart_flag = 1; else restart_flag = 0; #if 1 spect_spi_read(TCP_FRAME_DATA_LEN,spect_data_buf,restart_flag); #endif pdata = (struct frame_struct*)spect_data_buf; psnr = &pdata->snr_imd_data; spect_update_imd_snr(psnr); //每帧都发snr和imd信息 } /***************************************************************************** 函 数 名 : spect_frame_check_valid 功能描述 : 检查协议格式是否正确,至于处理则有外围函数处理 格式检查比较简单,未采用遍历模式 输入参数 : uint8 *pframe 输出参数 : 无 返 回 值 : SPECT_FRAME_ERR 调用函数 : 被调函数 : 修改历史 : 1.日 期 : 2013年2月4日 作 者 : 郭金涛 修改内容 : 新生成函数 *****************************************************************************/ static uint32 spect_frame_check_valid(uint8 *pframe) { struct tcp_data_frame *pspect_frame = NULL; uint8 calc_sum = 0; pspect_frame = (struct tcp_data_frame *)pframe; if(pspect_frame->id!=std_r[0]) { spect_printf("%s:id err!(%02x)\n",__FUNCTION__,pspect_frame->id); return FRAME_ERR_ID; } if(pspect_frame->header!=FRAME_HEADER) { spect_printf("%s:header err!(%02x)\n",__FUNCTION__,pspect_frame->header); return FRAME_ERR_HEADER; } if(pspect_frame->lenlen); return FRAME_ERR_LEN; } calc_sum = get_check_sum(pframe,pspect_frame->len-2); if(pframe[pspect_frame->len-2]!=calc_sum) { spect_printf("%s:sum err!(frame:%02x,calc:%02x)\n",__FUNCTION__,pframe[pspect_frame->len-2],calc_sum); return FRAME_ERR_SUM; } if(pframe[pspect_frame->len-1]!=FRAME_TAIL) { spect_printf("%s:tail err!(%02x)\n",__FUNCTION__,pframe[pspect_frame->len-1]); return FRAME_ERR_TAIL; } return FRAME_ERR_NONE; } static uint32 spect_frame_read1(struct tcp_data_frame * precframe) { uint8 index1,index2; uint16 ans_index = 0; #if SPECT_TASK_UART_DEBUG static uint32 tick_bak = 0; #endif //若为应答命令,仅存在于多帧模式下(读命令),主机方才会发送ack命令 if(precframe->cmd&(SPECT_CMD_ACK)) { index1 = (uint8)((precframe->index&0xff00)>>8); index2 = (uint8)(precframe->index&0x00ff); spect_printf("%s:ack frame.index1:%02x,index2:%02x.\n",__FUNCTION__,index1,index2); if(index2!=0) { if(index1==index2) //数据发送完毕 最后一帧 { //当前32帧发送完成大约需要1.5s左右 spect_printf("use tick:%d\n",get_sys_tick()-tick_bak); return 0; } index1++; } else //非多帧,直接返回 return 0; } else { index1 = 1; index2 = (TCP_DATA_BUF_LEN/TCP_FRAME_DATA_LEN); //16 #if SPECT_TASK_UART_DEBUG tick_bak = get_sys_tick(); spect_printf("%s:read frame.index1:%02x,index2:%02x.\n",__FUNCTION__,index1,index2); #endif } //接收到读取命令,更新本地数据 时间较长,更新全部还是更新1k spect_printf("%s:Rec Send Data Frame\n",__FUNCTION__); spect_update_data(index1); ans_index = (index1<<8) | index2; //生成应答的index域 return tcp_spect_init_send_frame(ans_index,precframe); } static uint32 spect_frame_read2(struct tcp_data_frame * pframe) { if(pframe->cmd&SPECT_CMD_ACK) { return 0; //非多帧,不存在应答命令 } spect_printf("%s:Rec Send IMD SNR Frame\n",__FUNCTION__); spect_update_imd_snr((struct snr_imd*)spect_data_buf); return tcp_spect_init_send_frame(0,pframe); //单帧命令,index区域直接置0 } static uint32 spect_frame_ret_err_licence(struct tcp_data_frame * pframe) { spect_printf("%s:Rec Send IMD SNR Frame\n",__FUNCTION__); pframe->cmd = FRAME_CMD_RETURN_ERR_LICENCE; //不太好吧?! return tcp_spect_init_send_frame(0,pframe); //单帧命令,index区域直接置0 } #define USE_DBG_SPEC 0 //暂时无内容,函数为空 static uint32 spect_frame_write1(struct tcp_data_frame * pspect) { return 0; } static uint32 spect_proc(void) { struct tcp_data_frame *pspect_frame = NULL; uint32 send_len = 0; if(spect_frame_check_valid((uint8*)tcp_rec_buf)!=FRAME_ERR_NONE) return send_len; pspect_frame = (struct tcp_data_frame *)tcp_rec_buf; #if USE_DBG_SPEC #else if(licence_valid==FALSE) { spect_frame_ret_err_licence(pspect_frame); return send_len; } #endif switch(pspect_frame->cmd&(~SPECT_CMD_ACK)) { case FRAME_CMD_READ_1: send_len = spect_frame_read1(pspect_frame); break; case FRAME_CMD_READ_2: //snr和imd信息,在read1命令中每帧均返回,时间太长 send_len = spect_frame_read2(pspect_frame); break; case FRAME_CMD_WRITE_1: send_len = spect_frame_write1(pspect_frame); break; default: break; } return send_len; } static uint32 tcp_spect_init_send_frame(uint32 param,struct tcp_data_frame * precframe) { struct tcp_data_frame *pout_frame =(struct tcp_data_frame *)tcp_send_buf; //memset(pout_frame,0xff,128); //测试,正式代码不用memset //memcpy((void*)pout_frame,(void*)precframe,FRAME_WITHOUT_DATA_LEN-2); //拷贝数据区前的内容 此处执行会出现异常,原因待查(是4字节对齐的啊!) pout_frame->id = precframe->id; pout_frame->header= precframe->header; pout_frame->cmd = precframe->cmd; pout_frame->index = (uint16)param; pout_frame->cmd = precframe->cmd&(~SPECT_CMD_ACK); switch(precframe->cmd&(~SPECT_CMD_ACK)) { //注意:向pdata拷贝数据区时,必须对其取址 case FRAME_CMD_READ_1: //复数数据 pout_frame->len = TCP_FRAME_DATA_LEN+FRAME_WITHOUT_DATA_LEN+TCP_FRAM_SNR_IMD_LEN; //每帧都额外传送snr和imd信息 memcpy((void*)&pout_frame->pdata,spect_data_buf,TCP_FRAME_DATA_LEN+TCP_FRAM_SNR_IMD_LEN); break; case FRAME_CMD_READ_2: //snr和imd 信息 pout_frame->len = sizeof(struct snr_imd)+FRAME_WITHOUT_DATA_LEN; memcpy((void*)&pout_frame->pdata,spect_data_buf,sizeof(struct snr_imd)); break; case FRAME_CMD_RETURN_ERR_LICENCE: pout_frame->len = sizeof(sn)+sizeof(input_licence)+FRAME_WITHOUT_DATA_LEN; memcpy((void*)&pout_frame->pdata,&sn,sizeof(sn)); memcpy((void*)(sizeof(sn)+(uint32)&pout_frame->pdata),&input_licence,sizeof(input_licence)); break; default: pout_frame->len = 0+FRAME_WITHOUT_DATA_LEN; break; } //对pdata后的成员需用len 的偏移量来访问 tcp_send_buf[pout_frame->len-2] = get_check_sum(tcp_send_buf,pout_frame->len-2); tcp_send_buf[pout_frame->len-1] = FRAME_TAIL; spect_printf("%s\n",__FUNCTION__); return pout_frame->len; } //校验输入的授权码是否合法 在上电与更改SN或者GUI_KEY时调用(必须) //授权码采用PRBS算法(多项式为X15+X14+1) extern uint32 prbs_key_get(uint64 sn_in); //校验输入的授权码是否合法 在上电与更改SN或者GUI_KEY时调用(必须) //授权码采用PRBS算法(多项式为X15+X14+1) void tcp_spect_calc_sn_licence(uint32 key,uint64 *psn) { if(!psn) return; sn = *psn; input_licence = key; if(sn==0) { licence_valid = FALSE; return; } if(prbs_key_get(sn)==key) { licence_valid = TRUE; } else { licence_valid = FALSE; } } /* void spect_data_task(void * pvParameters) { struct sockaddr_in server_addr; struct sockaddr_in conn_addr; int sock_fd; int sock_conn; socklen_t addr_len; int err; int length; (void)pvParameters; vTaskDelay(15); task_set_ignore_chk(SPECT_TASK_ID); printf("%s init start...\n",__FUNCTION__); sock_fd = lwip_socket(AF_INET, SOCK_STREAM, 0); if (sock_fd == -1) { printf("failed to create sock_fd!\n"); } memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr =htonl(INADDR_ANY); server_addr.sin_port = htons(TCP_SPECT_COMM_PORT); err = lwip_bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)); if (err < 0) { printf("failed to bind sock_fd!\n"); } err = lwip_listen(sock_fd,5); if (err < 0) { printf("failed to listen sock_fd!\n"); } addr_len = sizeof(struct sockaddr_in); printf("%s init over.\n",__FUNCTION__); while(1) { //accept和recv均为阻塞性 sock_conn = lwip_accept(sock_fd, (struct sockaddr *)&conn_addr, &addr_len); while(sock_conn!=-1) { memset(tcp_rec_buf, 0, sizeof(tcp_rec_buf)); length = lwip_recv(sock_conn, (unsigned int *)tcp_rec_buf, TCP_SPECT_REC_BUF_LEN, 0); if(length) { length = spect_proc(); if(length) { lwip_send(sock_conn, tcp_send_buf,length, 0); } } else { lwip_close(sock_conn); sock_conn = -1; break; } } } } */ #endif #if 0 uint8 ts_buf[188*7]; void ts2ip_task(void *pvParameters) { struct sockaddr_in client_addr; int sock_fd; int send_len; uint32 count = 0; uint8 value = 0; uint32 tick_bak = 0; uint32 rate = 0; (void)pvParameters; vTaskDelay(10); printf("%s init start...\n",__FUNCTION__); sock_fd = lwip_socket(AF_INET, SOCK_DGRAM, 0); if (sock_fd == -1) { printf("failed to create sock_fd!\n"); } memset(&client_addr, 0, sizeof(client_addr)); client_addr.sin_family = AF_INET; client_addr.sin_addr.s_addr =inet_addr("192.168.1.55"); client_addr.sin_port = htons(4321); tick_bak = get_sys_tick(); rate = 0; while(1) { value++; memset(ts_buf,value,sizeof(ts_buf)); send_len = lwip_sendto(sock_fd, ts_buf, sizeof(ts_buf), 0,(struct sockaddr *)&client_addr, sizeof(client_addr)); if(send_len==sizeof(ts_buf)) { count++; rate++; } if(check_delay_over(&tick_bak,OS_TICKS_PER_SEC*2)) { printf("TS2IP task send rate:%dMB/s,tatal packet:%d\n",rate*sizeof(ts_buf)/1024/1024,count); rate = 0; } } } #endif #if USE_TS_CHECK || USE_GPS_CHECK //根据系统配置发送告警信息 void send_alarm(E_ALARM alarm,void *pinfo) { #if 1 uint8 temp_out_buf[36]={0}; uint32 len = 0; uint32 check_sum; if(atsc_para.wb_para.alarm==0) return; temp_out_buf[len++]=0x76; len++; //略过长度区域 temp_out_buf[len++]=c256_byteread(EEPROM_ID_ADDR); temp_out_buf[len++]=0xf0+(uint8)alarm; //命令代码 switch(alarm) { case ALARM_GPS: { GPGSA_T *gps_gsa = NULL; S_SYS_TIME time; S_ALARM_GPS_LOCK *pgps =(S_ALARM_GPS_LOCK *)pinfo; get_sys_time(&time); #if USE_GPS gps_gsa = gps_get_sa(); #endif temp_out_buf[len++]=pgps->lock_status; temp_out_buf[len++]=0xFF;//gps_gsa->fix_status; temp_out_buf[len++]=gps_gsa->sv; temp_out_buf[len++]=pgps->status; temp_out_buf[len++]= time.year%100; temp_out_buf[len++]= time.month&0xff; temp_out_buf[len++]= time.date&0xff; temp_out_buf[len++]= time.hour&0xff; temp_out_buf[len++]= time.min&0xff; temp_out_buf[len++]= time.sec&0xff; temp_out_buf[1] = len+2; //还有校验和和尾没算 } break; case ALARM_TS: { E_TS_ERR_TYPE *pts = (E_TS_ERR_TYPE*)pinfo; temp_out_buf[len++]=*pts; //固定传一个字节 temp_out_buf[len++]=0; temp_out_buf[1] = len+2; //还有校验和和尾没算 } break; default: return; } check_sum = get_check_sum(temp_out_buf,len); temp_out_buf[len++]= check_sum; temp_out_buf[len++] = 0X96; //暂时串口直接发送，UDP以消息模式 switch(atsc_para.wb_para.alarm) // 0无,1串口,2网口,3全部 { case 1: // uart rs485_send_string(temp_out_buf,len); break; case 2: // eth sendto(alarm_sockfd, temp_out_buf, len, 0, (struct sockaddr *)&alarm_clientaddr, sizeof(alarm_clientaddr)); break; case 3: // both rs485_send_string(temp_out_buf,len); sendto(alarm_sockfd, temp_out_buf, len, 0, (struct sockaddr *)&alarm_clientaddr, sizeof(alarm_clientaddr)); break; default: break; } #endif } void check_ts_err_status(void) { S_ASI_INPUT current_asi_status; static S_ASI_INPUT save_asi_status = {ASI_NONE_ERR,ASI_ERR}; E_TS_ERR_TYPE ts_err_info = TS_ERR_NO_CHANGE; if(update_flag) return; if(atsc_para.wb_para.alarm==0) return; current_asi_status.input = (ASI_GRP_STATE)atsc_para.log_para.asi_input; current_asi_status.status = (ASI_INPUT_STATE)(atsc_para.log_para.input_ok_flag?0:1); if(current_asi_status.input!=save_asi_status.input) { if(current_asi_status.status!=save_asi_status.status) { if(current_asi_status.status==ASI_OK) ts_err_info = TS_ERR_CHANGE_OK; else ts_err_info = TS_ERR_CHANGE_ERR; save_asi_status = current_asi_status; send_alarm(ALARM_TS,&ts_err_info); } } } void check_ts_err_log(void) { S_ASI_INPUT current_asi_status[4]; static S_ASI_INPUT save_asi_status[4] = { ASI_NONE_ERR,ASI_ERR, ASI_NONE_ERR,ASI_ERR, ASI_NONE_ERR,ASI_ERR, ASI_NONE_ERR,ASI_ERR}; E_TS_ERR_TYPE ts_err_info = TS_ERR_NO_CHANGE; uint8 input_type = 0; uint8 index = 0; if(update_flag) return; index = (ASI_GRP_STATE)atsc_para.log_para.asi_input; current_asi_status[index].status = (ASI_INPUT_STATE)(atsc_para.log_para.input_ok_flag?0:1); if(current_asi_status[index].status != save_asi_status[index].status) { input_type = index; if(current_asi_status[index].status == ASI_OK) log_system_event_generate(NULL,LOG_TYPE_TS_OK,&input_type,1); // send msg to log_task else log_system_event_generate(NULL,LOG_TYPE_TS_ERR,&input_type,1); // send msg to log_task save_asi_status[index].status = current_asi_status[index].status; } } void check_fpga_gps_lock_status(void) { static BOOL save_lock_flag = FALSE; BOOL current_lock_flag; uint8 tmp = 0; S_ALARM_GPS_LOCK gps_lock_status; if(update_flag) return; if(atsc_para.log_para.use_gps==0) //INT 才判断 return; if(atsc_para.wb_para.alarm==0) return; tmp = fpga_byte_read(0x1,0x8a); if(tmp&0x10) current_lock_flag = TRUE; //locked; else current_lock_flag = FALSE; if(current_lock_flag==save_lock_flag) return; save_lock_flag = current_lock_flag; gps_lock_status.lock_status = (uint8)save_lock_flag; gps_lock_status.status = tmp&0x0f; if(current_lock_flag==TRUE) log_system_event_generate(NULL,LOG_TYPE_GPS_LOCK,NULL,0); // send msg to log_task else log_system_event_generate(NULL,LOG_TYPE_GPS_UNLOCK,NULL,0); // send msg to log_task send_alarm(ALARM_GPS,&gps_lock_status); } void check_temperature_status(void) { S_LOG_PARA * pLogPara = NULL; static uint8 old_overtemp_flg = 0; uint8 current_overtemp_flg; if(update_flag) return; pLogPara = &atsc_para.log_para; current_overtemp_flg = pLogPara->temperature[0]&0x01; if(current_overtemp_flg == old_overtemp_flg) return; old_overtemp_flg = current_overtemp_flg; if(current_overtemp_flg) // HIGH log_system_event_generate(NULL,LOG_TYPE_OVER_TEMPERATURE,NULL,0); else log_system_event_generate(NULL,LOG_TYPE_NORMAL_TEMPERATURE,NULL,0); } void check_overflow_status(void) { S_LOG_PARA * pLogPara = NULL; static uint8 old_overflow_flg = 0; static uint8 old_underflow_flg = 0; uint8 current_overflow_flg; uint8 current_underflow_flg; if(update_flag) return; pLogPara = &atsc_para.log_para; current_overflow_flg = pLogPara->ts_rate&0x01; current_underflow_flg = atsc_para.log_para.ts_under; //Overflow if(current_overflow_flg == old_overflow_flg) return; else { old_overflow_flg = current_overflow_flg; if(current_overflow_flg) // HIGH log_system_event_generate(NULL,LOG_TYPE_OVER_FLOW,NULL,0); } //Underflow if(current_underflow_flg == old_underflow_flg) return; else if(current_underflow_flg) { old_underflow_flg = current_underflow_flg; log_system_event_generate(NULL,LOG_TYPE_UNDER_FLOW,NULL,0); } } void check_send_alarm_state(void) { #if USE_TS_CHECK #if 1//_USE_RVL_ check_ts_err_status(); check_ts_err_log(); #endif #endif #if USE_GPS_CHECK #if 1//_USE_RVL_ check_fpga_gps_lock_status(); #endif #endif #if USE_TEMPERATURE_CHECK #if 1//_USE_RVL_ check_temperature_status(); #endif #endif #if USE_OVERFLOW_CHECK #if 1//_USE_RVL_ check_overflow_status(); #endif #endif } #if 0 /***************************************************************************** * Function : check_alarm_sendto_log * Description : * Input : void * Output : None * Return : * Others : * Record * 1.Date : 20191106 * Author : WangShu * Modification: Created function bit [0] :overtemp [1] :GPS UNLOCK/LOCK [2] :overflow/underflow [3-4]:INPUT [5] :INPUT STATUS *****************************************************************************/ void check_alarm_sendto_log(void) { S_LOG_PARA *pLogData; pLogData = &atsc_para.log_para; } #endif #endif #define SPECT_PRBS_CALC_TIME (120) //实际只取计算的后32位,计算太少,看起来比较有规律行 //利用prbs算法,由输入的sn,计算出一个特殊的32位数值 uint32 prbs_key_get(uint64 sn_in) { uint32 i = 0; uint32 bit15 = 0; uint32 bit14 = 0; uint32 bit0 = 0; uint32 prbs = 0; for(i=0;i>15)&1; bit14 = (sn_in>>14)&1; bit0 = bit15^bit14; bit0 &=1; sn_in=(sn_in<<1)|bit0; } return prbs; } #define __usr_net_thr__ 1 #if __usr_net_thr__//THR #if USE_SPECT_DATA_TASK /*void spect_data_task(void * pvParameters) { struct sockaddr_in server_addr; struct sockaddr_in conn_addr; int sock_fd; int sock_conn; socklen_t addr_len; int err; int length; (void)pvParameters; vTaskDelay(15); task_set_ignore_chk(SPECT_TASK_ID); printf("%s init start...\n",__FUNCTION__); sock_fd = lwip_socket(AF_INET, SOCK_STREAM, 0); if (sock_fd == -1) { printf("failed to create sock_fd!\n"); } memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr =htonl(INADDR_ANY); server_addr.sin_port = htons(TCP_SPECT_COMM_PORT); err = lwip_bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)); if (err < 0) { printf("failed to bind sock_fd!\n"); } err = lwip_listen(sock_fd,5); if (err < 0) { printf("failed to listen sock_fd!\n"); } addr_len = sizeof(struct sockaddr_in); printf("%s init over.\n",__FUNCTION__); while(1) { //accept和recv均为阻塞性 sock_conn = lwip_accept(sock_fd, (struct sockaddr *)&conn_addr, &addr_len); while(sock_conn!=-1) { memset(tcp_rec_buf, 0, sizeof(tcp_rec_buf)); length = lwip_recv(sock_conn, (unsigned int *)tcp_rec_buf, TCP_SPECT_REC_BUF_LEN, 0); if(length) { length = spect_proc(); if(length) { lwip_send(sock_conn, tcp_send_buf,length, 0); } } else { lwip_close(sock_conn); sock_conn = -1; break; } } } } */ int speck_data_thr(void * pvParameters) { int tcp_sock_fd = 0; int sock_conn = 0; int recv_buf_len = TCP_SPECT_REC_BUF_LEN+4; int ret = 0; struct sockaddr_in serverAddr; struct sockaddr_in conn_addr; socklen_t addr_len; int length = 0; /* creat tcp socket */ tcp_sock_fd = socket(PF_INET, SOCK_STREAM, 0); if(tcp_sock_fd == -1){ log_printf(LOG_ERR,I_NOUSED," tcp_sock_fd socket fail.\n"); return -1; } ret = setsockopt(tcp_sock_fd, SOL_SOCKET, SO_REUSEADDR, &recv_buf_len, sizeof(recv_buf_len)); if(ret < 0) { log_printf(LOG_ERR,I_NOUSED,"setsockopt err.\n"); } memset(&serverAddr, 0, sizeof(serverAddr)); serverAddr.sin_family = PF_INET; serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); serverAddr.sin_port = htons(TCP_SPECT_COMM_PORT); if(bind(tcp_sock_fd,(struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) { log_printf(LOG_ERR,I_NOUSED," bind 0.0.0.0:%d failed\n",TCP_SPECT_COMM_PORT); close(tcp_sock_fd); return -1; } else { log_printf(LOG_DEBUG,I_NOUSED,"bind 0.0.0.0:%d ok\n",TCP_SPECT_COMM_PORT); } if(listen(tcp_sock_fd, 5)==-1){ log_printf(LOG_ERR,I_NOUSED,"socket server listen fail.\n"); close(tcp_sock_fd); return -1; } addr_len = sizeof(struct sockaddr_in); while(1) { // block sock_conn = accept(tcp_sock_fd, (struct sockaddr *)&conn_addr, &addr_len); while(sock_conn != -1) { //printf(" port :%d accepted \n", port); memset(tcp_rec_buf, 0, sizeof(tcp_rec_buf)); length = recv(sock_conn, tcp_rec_buf, TCP_SPECT_REC_BUF_LEN, 0); if(length) { //printf(" rx_buff %02X %02X %02X \n", rx_buff[0], rx_buff[1], rx_buff[2]); length = spect_proc(); if(length) { send(sock_conn, tcp_send_buf, length, 0); } } else { close(sock_conn); sock_conn = -1; break; } } } } #endif//USE_SPECT_DATA_TASK void check_fpga_up_finished_reboot_sys(void) { static uint8 sec_cnt=0; if(fpga_up_sys_reboot){ sec_cnt++; if(sec_cnt>=3){ fpga_up_sys_reboot=0; log_printf(LOG_DEBUG,I_NOUSED,"fpga up succeed,imx ready to reboot now.\n"); reset_imx_system(); } } } // 上位机升级FPGA int fpga_up_thr(void * pvParameters) { struct sockaddr_in sin; struct sockaddr_in pin; int on=1; int sock_fp = -1; int sock_conn = -1; int size_of_addr; int length; int i = 0; struct timeval timeout = {1,1000};// s,us log_printf(LOG_DEBUG,I_NOUSED,"[.thr.] fpga_up_thr Start.\n"); /* creat socket */ sock_fp = socket(AF_INET,SOCK_STREAM,0); if(sock_fp==-1) { log_printf(LOG_ERR,I_NOUSED,"socket fpgaUp fail.\n"); return -1; } int ret = setsockopt(sock_fp,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)); if(ret<0) { log_printf(LOG_ERR,I_NOUSED,"Sta.setsockopt fpgaUp server err.\n"); } bzero(&sin,sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; sin.sin_port = htons(UPGRADE_LISTEN_PORT); if(bind(sock_fp,(struct sockaddr *)&sin,sizeof(sin))==-1) { log_printf(LOG_ERR,I_NOUSED,"socket fpgaUp server bind fail.\n"); close(sock_fp); return -1; } if(listen(sock_fp,1)==-1) // only one can be connect { log_printf(LOG_ERR,I_NOUSED,"socket fpgaUp server listen fail.\n"); close(sock_fp); return -1; } while(1) { /* block untill client connected */ size_of_addr = sizeof(pin); sock_conn = accept(sock_fp,(struct sockaddr *)&pin, &size_of_addr); if(sock_conn == -1) { log_printf(LOG_DEBUG,I_NOUSED,"fpgaUp tcp accept!\n"); continue; } log_printf(LOG_DEBUG,I_NOUSED,"2.fpgaUp tcp accept!\n"); while(sock_conn!=-1) { memset(rxdata, 0, sizeof(rxdata)); length = recv(sock_conn, (unsigned int *)rxdata, MAX_DATA_LEN, 0);// 阻塞 if(length) { length = fpga_upgrade_process(); if(length==0xff){//出错后主动断开连接 close(sock_conn); sock_conn = -1; break; } send(sock_conn, txdata, length, 0); } else { close(sock_conn); sock_conn = -1; break; } } } } void * tcp_remote_thr(void *args) { int tcp_sock_fd = 0; int sock_conn = 0; int recv_buf_len = TCP_REMOTE_MAX_REC_LEN+4; int ret = 0; struct sockaddr_in serverAddr; struct sockaddr_in conn_addr; int port; socklen_t addr_len; static uint8 rx_buff[TCP_REMOTE_MAX_REC_LEN+4] = {0}; static uint8 tx_buff[TCP_REMOTE_MAX_SEND_LEN+4] = {0}; int recvlen = 0; log_printf(LOG_DEBUG,I_NOUSED,"[.thr.] tcp_remote_thr Start.\n"); /* creat tcp socket */ tcp_sock_fd = socket(PF_INET, SOCK_STREAM, 0); if(tcp_sock_fd == -1){ log_printf(LOG_ERR,I_NOUSED," tco_sock_fd socket fail.\n"); return ((void*)NULL); } ret = setsockopt(tcp_sock_fd, SOL_SOCKET, SO_REUSEADDR, &recv_buf_len, sizeof(recv_buf_len)); if(ret < 0) { log_printf(LOG_ERR,I_NOUSED,"setsockopt err.\n"); } /*if(standard==STANDARD_CTTB) port = TCP_COM_CTTB_PROTOCOL_PORT; else port = TCP_COM_CMMB_PROTOCOL_PORT;*/ port = TCP_COMM_PORT; memset(&serverAddr, 0, sizeof(serverAddr)); serverAddr.sin_family = PF_INET; serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); serverAddr.sin_port = htons(port); if(bind(tcp_sock_fd,(struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) { log_printf(LOG_ERR,I_NOUSED,"bind 0.0.0.0:%d failed\n",port); close(tcp_sock_fd); return ((void*)NULL); } else { log_printf(LOG_DEBUG,I_NOUSED," bind 0.0.0.0:%d ok\n",port); } if(listen(tcp_sock_fd, 5)==-1){ log_printf(LOG_DEBUG,I_NOUSED,"socket server listen fail.\n"); close(tcp_sock_fd); return ((void*)NULL); } addr_len = sizeof(struct sockaddr_in); while(1) { if(get_upgrade_flg()){ usleep(1000000); continue; } // block sock_conn = accept(tcp_sock_fd, (struct sockaddr *)&conn_addr, &addr_len); while(sock_conn != -1) { //printf(" port :%d accepted \n", port); memset(rx_buff, 0, sizeof(rx_buff)); recvlen = recv(sock_conn, rx_buff, TCP_REMOTE_MAX_REC_LEN, 0); if(recvlen) { //printf(" rx_buff %02X %02X %02X \n", rx_buff[0], rx_buff[1], rx_buff[2]); recvlen = tcp_remote(rx_buff, tx_buff); if(recvlen) { send(sock_conn, tx_buff, recvlen, 0); } } else { close(sock_conn); sock_conn = -1; break; } } } } void * udp_remote_thr(void * args) { int udo_sock_fd = 0; int ret = 0; struct sockaddr_in serverAddr; struct sockaddr from; socklen_t fromlen; int port; static uint8 rx_buff[TCP_REMOTE_MAX_REC_LEN+4] = {0}; static uint8 tx_buff[TCP_REMOTE_MAX_SEND_LEN+4] = {0}; int recvlen = 0; log_printf(LOG_DEBUG,I_NOUSED,"[.thr.] udp_remote_thr Start.\n"); /* creat udp socket */ udo_sock_fd = socket(AF_INET, SOCK_DGRAM, 0); if(udo_sock_fd == -1){ log_printf(LOG_ERR,I_NOUSED," tco_sock_fd socket fail.\n"); return ((void*)NULL); } // ret = setsockopt(tcp_sock_fd, SOL_SOCKET, SO_REUSEADDR, &recv_buf_len, sizeof(recv_buf_len)); // if(ret < 0) { // printf("setsockopt err.\n"); // } /*if(standard==STANDARD_CTTB) port = TCP_COM_CTTB_PROTOCOL_PORT; else port = TCP_COM_CMMB_PROTOCOL_PORT;*/ port = TCP_COMM_PORT; memset(&serverAddr, 0, sizeof(serverAddr)); serverAddr.sin_family = PF_INET; serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); serverAddr.sin_port = htons(port); if(bind(udo_sock_fd,(struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) { log_printf(LOG_ERR,I_NOUSED," bind 0.0.0.0:%d failed\n",port); close(udo_sock_fd); return ((void*)NULL); } else { log_printf(LOG_DEBUG,I_NOUSED,"bind 0.0.0.0:%d ok\n",port); } while(1) { if(get_upgrade_flg()){ usleep(1000000); continue; } memset(rx_buff, 0, sizeof(rx_buff)); // block recvlen = recvfrom(udo_sock_fd, rx_buff, TCP_REMOTE_MAX_REC_LEN, 0, &from, &fromlen); if(recvlen) { //printf(" rx_buff %02X %02X %02X \n", rx_buff[0], rx_buff[1], rx_buff[2]); recvlen = tcp_remote(rx_buff, tx_buff); if(recvlen) { sendto(udo_sock_fd, tx_buff, recvlen, 0, &from, fromlen); } } } } #endif