2283 lines
62 KiB
C
2283 lines
62 KiB
C
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <math.h>
|
||
#include <sys/types.h>
|
||
#include <sys/socket.h>
|
||
#include <netinet/in.h>
|
||
#include <unistd.h>
|
||
#include <netinet/in.h>
|
||
#include <arpa/inet.h>
|
||
#include <netdb.h> /* 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;i<charLen;)
|
||
{
|
||
hexBuf[retLen++]=(char_to_hex(charBuf[i])<<4)|(char_to_hex(charBuf[i+1]));
|
||
i=i+2;
|
||
}
|
||
hexBuf[retLen]='\0';
|
||
|
||
return retLen;
|
||
}
|
||
|
||
|
||
int recv_upgrade_data_parse(uint8 *recvBuf,uint8 *parseBuf,uint16 recvLen)
|
||
{
|
||
uint8 test;
|
||
uint8 type;
|
||
uint8 length;
|
||
int retLen=0;
|
||
|
||
uint8 lenh,lenl;
|
||
uint8 typeh,typel;
|
||
|
||
S_FGPA_UPDATA_FRAME *pUpFrame=NULL;
|
||
uint8 tempBuf[100];
|
||
|
||
if(recvLen>UPDATA_RAW_FRAME_MAX_LEN){
|
||
return -2;
|
||
}
|
||
if(recvLen<UPDATA_RAW_FRAME_MIN_LEN){
|
||
return -2;
|
||
}
|
||
|
||
pUpFrame = (S_FGPA_UPDATA_FRAME*)recvBuf;
|
||
|
||
lenh = char_to_hex(pUpFrame->lenH);
|
||
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->len<FRAME_WITHOUT_DATA_LEN)
|
||
{
|
||
spect_printf("%s:len err!(%02x)\n",__FUNCTION__,pspect_frame->len);
|
||
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<SPECT_PRBS_CALC_TIME;i++)
|
||
{
|
||
prbs|=(sn_in&1);
|
||
prbs<<=1;
|
||
bit15 = (sn_in>>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
|