0103_APP/App/taskOpt.c

#include "taskOpt.h"
#include "xspDataOpt.h"
#include "masterslave.h"
#include "up_4g.h"
timeout_t g_upstatusTime; // 上报状态的时间
timeout_t g_upfirmTime;  // 上报固件信息的时间

taskRunData g_taskRunDa;
/*----------------------------------------------------------------
 *  上电读取20次 comm端，找出comm端一个电平的最小时间
 * ---------------------------------------------------------------*/
void power_up_read_comm_min_time(void)
{
    volatile int i;
    uint32_t minTick,maxTick;

    //    return;
    minTick=0xFFFFFFFF;
    maxTick=0x00;
    testcount.count = 0;
    //gpio_bit_reset(g_extimsg.csGroup,g_extimsg.csPin);
    testcount.btestStart = 1;
    start_delay_ms(2000);
    while(1){
        if(testcount.count>20) {
            //gpio_bit_set(g_extimsg.csGroup,g_extimsg.csPin);
            testcount.btestStart = 0;
            break;
        }
        if(1 == g_iDelayfinish){
            minTick = 0x00;
            testcount.count = 1;
            break;
        }
    }
    stop_delay_ms();
    testcount.wCount = 0;
    for(i=0;i<testcount.count-1;i++){
        if(testcount.exittest[i].status != testcount.exittest[i+1].status){
            testcount.width[testcount.wCount++] = testcount.exittest[i+1].tick - testcount.exittest[i].tick;
        }
    }
    for(i=1;i<testcount.wCount;i++){
        if(minTick>testcount.width[i]) minTick = testcount.width[i];
        if(maxTick<testcount.width[i]) maxTick = testcount.width[i];
    }
    g_timeInfo.delay = minTick/3;
    g_timeInfo.delay = 200;
    printf("maintick=%d,maxtick=%d,delay=%d\r\n",minTick,maxTick,g_timeInfo.delay);
    //gpio_bit_reset(g_extimsg.csGroup,g_extimsg.csPin);

}
void init_run_data(void)
{
    //uint8_t i;
    if(g_iDentity == IDENTITY_SLAVE) return;
    timeout_setValue(&g_uart485.time,2000); // 发送延时
    timeout_setValue(&g_upstatusTime,READ_STATUS_TIME); // 读取状态的时间
    timeout_setValue(&g_upfirmTime,READ_FIRME_TIME); // 读取固件的时间
    timeout_setValue(&g_logMsg.singTime,TIME_SING_N); // 读取信号采样率 10 分钟读取一次
    timeout_setValue(&g_taskRunDa.delayRead,300);
    g_taskRunDa.breadstatus = 1;
    g_taskRunDa.breadfirmmsg = 1;
}
/*------------------------------------------------------------------------------
 *  有4G模块的设备，且连接网络的状态下，上电要询问自己的身份
 * -----------------------------------------------------------------------------*/
void ask_oneself_for_identity(void)
{
    uint8_t sendbuff[128],len,ret;
    if((0x01 == g_devMsg.baskIdentity)&&(B4G_HAVE == g_devMsg.bHave4G) && (1 == g_4gMsg.bconnect)){
        memset(sendbuff,0,sizeof(sendbuff));
        up_system_cmd_0x2041(sendbuff,&len);
        ret = add_data_to_4G_txfifo(sendbuff,len,0x01,0x2041);
        if(1 == ret) g_devMsg.baskIdentity = 0x00;
        printf("4g mode ask own identity\r\n");
    }

    return;
}

/*-----------------------------------------------------------------------
 * 主读取自己的加油数据,存入到4G的发送fifo中
 * -----------------------------------------------------------------------*/
//void master_deal_flash_data_to_4Grxfifo(void)
//{
//    uint8_t ret;
//    XspDataInfo xspda;

//    ret = read_flash(xspda.data,1);
//    if(ret==1){
//        printf("发送数据到服务器:recordId=%d,amount=%d,oil=%d,tamout=%lld,toil=%lld\r\n",\
//               xspda.reDa.recordId,xspda.reDa.amount,xspda.reDa.oil,\
//               xspda.reDa.tamount,xspda.reDa.toil);
//    }
//}

/*------------------------------------------------------------------------
 *  读取从的数据
 * -----------------------------------------------------------------------*/
void master_read_slave_data(void)
{

}
timeout_t status2002time;
/*-------------------------------------------------------------------------
 *  读取从的状态
 * -------------------------------------------------------------------------*/
uint8_t master_read_slave_status(void)
{
    static uint8_t index = 0,bsendMaster = 0;
    nodeMsg_t *nodeMsg = NULL;

    if(0 == bsendMaster){
        if(timeout_isOut(&status2002time)){
            master_add_status_to_4g_txfifo(0x02,0x2002,g_devMsg.devType,g_devMsg.devSn, SELF_STATUS);
            timeout_setValue(&status2002time,UP_STATUS_2002);
            timeout_start(&status2002time);
        }
        bsendMaster = 1;
    }

    if(1 == g_runNode.nodMsg[index].bSelf) {
        index++;
    }
    if(((index != 0) && ((index%g_runNode.slaveNum)==0))||(g_runNode.slaveNum==0)){ // 一圈的状态读取完成
        g_taskRunDa.breadstatus = 0;
        timeout_start(&g_upstatusTime);
        printf("读取状态信息 0x1002 完成\r\n");
        index = 0;
        bsendMaster = 0;
        return 1;
    }

    if((0 == g_runNode.nodMsg[index].status) ){//||(3 == g_uart485.time.endMode)
        g_devMsg.devTypeS = g_runNode.nodMsg[index].devType;
        g_devMsg.devSnS   = g_runNode.nodMsg[index].devSn;
        if(g_runNode.nodMsg[index].bSelf !=1)master_add_status_to_4g_txfifo(0x02,0x2002,g_devMsg.devTypeS,g_devMsg.devSnS, SLAVE_OFFLINE);
        index++;
    }
    else {
        printf("读取状态信息 0x1002\r\n");
        nodeMsg = &g_runNode.nodMsg[index];
        g_devMsg.devTypeS = nodeMsg->devType;
        g_devMsg.devSnS   = nodeMsg->devSn;
        master_read_status(0x1002,&g_devMsg);
        timeout_start(&g_uart485.time);
        index++;
    }
    return 0;


}
timeout_t mastertime;
/*--------------------------------------------------------------------------
 *  读取从的固件信息
 * -------------------------------------------------------------------------*/
void master_read_slave_firmmsg(void)
{
    static uint8_t index = 0,bsendMaster=0;
    nodeMsg_t *nodeMsg = NULL;

    if(0 == bsendMaster){
        if(timeout_isOut(&mastertime)){
            master_add_status_to_4g_txfifo(0x02,0x2001,g_devMsg.devType,g_devMsg.devSn,SELF_STATUS);
            timeout_setValue(&mastertime,UP_STATUS_2001);
            timeout_start(&mastertime);
        }
        bsendMaster = 1;
    }
    if(1 == g_runNode.nodMsg[index].bSelf) {
        index++;
    }
    if((index != 0 && index%g_runNode.slaveNum==0)||(g_runNode.slaveNum==0)){ // 一圈的状态读取完成
        g_taskRunDa.breadfirmmsg = 0;
        timeout_start(&g_upfirmTime);
        printf("读取状态信息 0x1001 完成\r\n");
        index = 0;
        bsendMaster = 0;
        return ;
    }
    printf("读取状态信息 0x1001\r\n");
    nodeMsg = &g_runNode.nodMsg[index];
    g_devMsg.devTypeS = nodeMsg->devType;
    g_devMsg.devSnS   = nodeMsg->devSn;
    master_read_status(0x1001,&g_devMsg);
    timeout_start(&g_uart485.time);
    index++;

    return ;
}

/*------------------------------------------------------------------------
 *  读取信号采样率
 *-------------------------------------------------------------------------*/
void read_sing_ratio(void)
{
    static uint8_t index = 0;
    nodeMsg_t *nodeMsg = NULL;

    if(1 == g_runNode.nodMsg[index].bSelf) {
        index++;
    }

    if(g_logMsg.singOpen == 0x00) {

        if((index != 0 && index%g_runNode.slaveNum==0)||(g_runNode.slaveNum==0)){ // 一圈的状态读取完成
            timeout_start(&g_logMsg.singTime);
            printf("自动读取 读取信号采样率 1063 完成\n");
            index = 0;
            return ;
        }
        printf("自动 读取信号采样率 1063  index = %d\n",index);
        nodeMsg = &g_runNode.nodMsg[index];
        g_devMsg.devTypeS = nodeMsg->devType;
        g_devMsg.devSnS   = nodeMsg->devSn;
        master_read_log_0x1063(&g_devMsg);
        timeout_start(&g_uart485.time);
        index++;

    }
    else if(g_logMsg.singOpen == 1 ){
        if(!timeout_isOut(&g_logMsg.tsingTime)) {
            if(timeout_isOut(&g_logMsg.singTime)){
                printf("指令读取 1063 指令\n");
                g_devMsg.devTypeS =g_logMsg.devType;
                g_devMsg.devSnS   = g_logMsg.devSn;
                master_read_log_0x1063(&g_devMsg);
                timeout_start(&g_uart485.time);
                timeout_start(&g_logMsg.singTime);
            }
        }
        else {
            g_logMsg.singOpen = 0;
            timeout_setValue(&g_logMsg.singTime,TIME_SING_N);
            timeout_start(&g_logMsg.singTime);
        }
    }


}
/*-----------------------------------------------------------------------------------
 *  主处理4G的接收数据
 *  先解析 计算校验,再根据type1的类型处理数据
 * ----------------------------------------------------------------------------------*/
void master_deal_4g_rx_data(void)
{
    uint8_t buff[256], bufflen;
    uint16_t crc,fcrc;
    netMsgFormat * msg = (netMsgFormat*)buff;

    read_mqtt_work_msg(); // 读取4G下发的数据，放入到4G rx fifo中

    if(fifo_is_empty(&g_4Grxfifo)== TRUE) return; // 4G fifo为空

    bufflen = fifo_read(&g_4Grxfifo,buff);

    if(msg->palen > 256) return;
    if(msg->start != 0xFEFE) return;
    crc = _crc16_get(buff,msg->palen+NET_HEAD_LEN-2);
    fcrc = msg->info[msg->palen-1];
    fcrc = (fcrc<<8) | msg->info[msg->palen-2];
    if(crc != fcrc) {printf("dn_4g crc error\r\n"); return;}
    printf("收到 4G 类型：0x%x, 指令: 0x%x\r\n",msg->msgType1,msg->msgType2);
    switch (msg->msgType1) {
    case 0x01: // 系统类
        dn_4g_system_cmd(msg->msgType2,buff,bufflen);
        break;
    case 0x02: // 状态类

        break;
    case 0x03: // 数据类
        dn_4g_data_cmd(msg->msgType2,buff,bufflen);
        break;
    case 0x04: // 升级类
        dn_4g_update_cmd(msg->msgType2,buff,bufflen);
        break;
    case 0x10: // 异常类
        dn_4g_log_cmd(msg->msgType2,buff,bufflen);
        break;
    default:
        break;
    }
}
/*-----------------------------------------------------------------------------------
 *  主处理4G的发送fifo
 * ----------------------------------------------------------------------------------*/
void master_deal_4g_tx_data(void)
{
    uint8_t buff[256],len;

    if(B4G_NOHAVE == g_devMsg.bHave4G) return;
    if(g_uart1Info.bSdFinish == 0) return; // 上次发送未完成

    if(fifo_is_empty(&g_4Gtxfifo) == TRUE) return ;// 发送fifo为空
    printf("发送4G数据到服务器\r\n");
    len = fifo_read(&g_4Gtxfifo,buff);
    data_dump("4g-data-to-server",buff,len);
    send_data_to_mqtt(0x00,buff,len);
}
/*------------------------------------------------------------------------
 *  主处理485的 发送fifo
 *  用于服务器下发指令读取从的数据
 *  没有数据发送时返回为1  有数据发送时，返回为0
 * -----------------------------------------------------------------------*/
uint8_t master_deal_485_tx_fifo(void)
{
    FIFO_T *fifo = &g_txfifo;
    if(fifo_is_empty(fifo) == TRUE) return 1; // fifo为空时，退出
    printf("发送485 tx fifo 中的数据\r\n");
    usart_tx_dma_send(UART3,fifo->memory[fifo->front].da,fifo->memory[fifo->front].len);
    fifo->memory[fifo->front].len = 0;
    fifo->front++;
    fifo->front %= MAXSIZE;
    if (fifo->front == fifo->rear) // 设置队列为空
        fifo->flag = FALSE;

    return 0;
}
/*-------------------------------------------------------------------------
 *  设备有4G模块，不管主设备或从设备都要上报自己的状态信息
 * ------------------------------------------------------------------------*/
void dev_4g_up_status_to_server(void)
{
    if(IDENTITY_MASTER == g_iDentity) return;
    if((B4G_HAVE == g_devMsg.bHave4G)&& timeout_isOut(&g_upstatusTime)){
            master_add_status_to_4g_txfifo(0x02,0x2002,g_devMsg.devType,g_devMsg.devSn, SELF_STATUS);
            //bsendMsg &= (~0x01);
            //if(IDENTITY_SLAVE == g_iDentity)
                timeout_start(&g_upstatusTime);
    }
    if((B4G_HAVE == g_devMsg.bHave4G) && timeout_isOut(&g_upfirmTime)){ // 有4G模块，不管是主从，都需要上报自己的状态
        master_add_status_to_4g_txfifo(0x02,0x2001,g_devMsg.devType,g_devMsg.devSn,SELF_STATUS);
        //bsendMsg &= (~0x02);
        //if(IDENTITY_SLAVE == g_iDentity)
            timeout_start(&g_upfirmTime);
    }

}
/*------------------------------------------------------------
 *  判断配置文件是否过期
 * -----------------------------------------------------------*/
void config_file_is_timeout(void)
{
    if(1 == g_taskRunDa.bcfgfiletime) {
        if(timeout_isOut(&g_taskRunDa.cfigFileTime)){
            epprom_read_pin_config();
            g_taskRunDa.bcfgfiletime = 0;
        }
    }
}

/*-----------------------------------------------------------
 * 8段码测试模式
 * ----------------------------------------------------------*/
void open_8seg_test_mode(void)
{
    uint8_t ret  = 0,index;
    if(!timeout_isOut(&g_uart485.time)) return;

    ret = master_deal_485_tx_fifo();
    if(ret == 0) { // 485发送fifo有发送数据
        timeout_start(&g_uart485.time);
        return;
    }

    if(!timeout_isOut(&g_up7segData.upTime)){
        if(g_up7segData.bAppointDev == 2){
            g_devMsg.devTypeS = *((uint16_t*)&g_up7segData.devMsg[6]);
            g_devMsg.devSnS = *((uint32_t*)&g_up7segData.devMsg[8]);
            master_read_data_0x1030(&g_devMsg);
        }
        else { // 主从都有
            index = g_runNode.nIndex;
            if(1 == g_runNode.nodMsg[index].bSelf){
                g_runNode.nIndex = (++g_runNode.nIndex)%g_runNode.slaveNum;
                return;
            }
        }
        timeout_start(&g_uart485.time);
    }
    else {
        g_up7segData.bOpen = 0;
        g_up7segData.bAppointDev = 0;
    }
}

/*-----------------------------------------------------------------------
 *  如果为主，则循环读取从的数据
 * -----------------------------------------------------------------------*/
void master_work_loop(void)
{
    uint8_t index;
    uint8_t ret = 0;
    if(!timeout_isOut(&g_uart485.time)) return;
    if(!timeout_isOut(&g_taskRunDa.delayRead)) return;
    ret = master_deal_485_tx_fifo();
    if(ret == 0) { // 485发送fifo有发送数据
        timeout_start(&g_uart485.time);
        return;
    }
    if(IDENTITY_MASTER != g_iDentity) return;
    if(g_taskRunDa.breadstatus == 1 || timeout_isOut(&g_upstatusTime)){ // 读取状态
        master_read_slave_status();
    }
    else if(g_taskRunDa.breadfirmmsg == 1 || timeout_isOut(&g_upfirmTime)){ // 读取固件
        master_read_slave_firmmsg();
    }
    else if(timeout_isOut(&g_logMsg.singTime)){
        read_sing_ratio();
    }
    else { // 读取交易数据

        if(1 == g_up7segData.bOpen) return;
        if(g_4gMsg.bconnect == 0) return; // 4G 没有连接上网络则不读取交易数据

        if(g_runNode.slaveNum == 0 ) return;

        index = g_runNode.nIndex;
        if(1 == g_runNode.nodMsg[index].bSelf){
            g_runNode.nIndex = (++g_runNode.nIndex)%g_runNode.slaveNum;
            return;
        }
        g_devMsg.devTypeS = g_runNode.nodMsg[index].devType;
        g_devMsg.devSnS   = g_runNode.nodMsg[index].devSn;
        g_runNode.nodMsg[index].readCount++;
        if(g_runNode.nodMsg[index].readCount>5){
            g_runNode.nodMsg[index].status = 0;
            g_runNode.nodMsg[index].readCount = 0;
        }
        printf("读取 0x03-1061,index = %d\r\n",index);
        /*if(1 == g_taskRunDa.keyReadcurData) master_read_data_0x1061(&g_devMsg,0xFFFFFFFF);
        else */
        master_read_data_0x1061(&g_devMsg,0);
        timeout_start(&g_uart485.time);
        g_runNode.nIndex = (++g_runNode.nIndex)%g_runNode.slaveNum;
        if(g_runNode.nIndex == 0) {
            g_taskRunDa.keyReadcurData = 0;
        }
    }
}


/*------------------------------------------------------------------------
 *  主 从  解析485的接收fifo
 * -----------------------------------------------------------------------*/
void analysis_485_rx_fifo(void)
{
    uint8_t readBuf[256],readlen;
    uint16_t crc,fcrc,randDa;
    MasterSlave *msg = (MasterSlave*)readBuf;

    if(fifo_is_empty(&g_rxfifo) == TRUE) return;
    readlen = fifo_read(&g_rxfifo,readBuf);

    if(0x01 == g_updateDa.bResetUpdate){
        randDa = rand()%100 + 200;
        printf("随机时间 = %d\r\n",randDa);
        set_start_ota_timer(&g_otaTimer.randomTmr,randDa);
    }
    if(g_updateDa.Work_State == OTA_UPDATE_REPEAT && g_updateDa.retransmit_s == 0)//重传阶段
    {
        ota_repeat_rand_timer(1);//重传随机延时
    }

    if(msg->start != 0xfefe) {
        uart_pt_task(readBuf,0); // 判断是否进入产测执行
        return;
    }
    crc = _crc16_get(readBuf,msg->palen+COMM_HEAD_LEN-2);
    fcrc = msg->comInfo.info[msg->palen-1];
    fcrc = (fcrc<<8) | msg->comInfo.info[msg->palen-2];
    if(fcrc != crc ) return;
    if((0x2000 == (msg->msgType2&0x2000))) { // 要考虑离线升级和升级的指令？？？？
        if(WORK_UPDATE == g_devMsg.workMode){ // 升级模式
            if(IDENTITY_SLAVE == g_iDentity) return; //
        }
        else {
            if(B4G_NOHAVE== g_devMsg.bHave4G) {
                return;
            }
            else {
                if((g_devMsg.devSn != *(uint32_t*)&msg->comInfo.info[2]) \
                   && (g_devMsg.devType != *(uint16_t*)&msg->comInfo.info[0])){
                    printf("收到2000指令，设备类型和SN不匹配\r\n");
                    return;
                }
            }
        }
    }
    //data_dump("收到数据",readBuf,readlen);
    printf("收到指令 %0d-%0x\r\n",msg->msgType1,msg->msgType2);
    switch(msg->msgType1){
    case 0x01: // 系统指令
        analysis_cmd_system(msg->msgType2,readBuf,readlen);
        break;
    case 0x02: // 状态指令
        analysis_cmd_status(msg->msgType2,readBuf,readlen); // 直接透传
        break;
    case 0x03: // 数据指令
        analysis_cmd_data(msg->msgType2,readBuf,readlen);
        break;
    case 0x04: // 升级指令
        analysis_cmd_update(msg->msgType2,readBuf,readlen);
        break;
    case 0x10: // 日志指令
        analysis_cmd_log(msg->msgType2,readBuf,readlen);
        break;
    }
    if(msg->msgType1 != 0x04){
        timeout_start(&g_taskRunDa.delayRead);
    }
}