#include "DpcTask.h"
#include "OutPutGpioTask.h"
#include "WatchdogTask.h"
#include "McuBspUart.h"
#include "FileSysTask.h"
#include "McuBspAdc.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#include <cpu.h>
#include <os.h>

#define TASK_DPC_UART_ID            MCU_BSP_UART3
#define TASK_DPC_UART_BANDRATE      MCU_BSP_UART_BANDRATE_9600
#define TASK_DPC_UART_DATABIT       MCU_BSP_UART_DATABIT_8
#define TASK_DPC_UART_STOPBIT       MCU_BSP_UART_STOPBIT_ONE
#define TASK_DPC_UART_CHECKBIT      MCU_BSP_UART_CHECKBIT_NONE

#define TASK_DPC_DATA_IDLING   0 // 空闲态
#define TASK_DPC_DATA_SORTING  1 // 分拣态
#define TASK_DPC_DATA_HANDLING 2 // 处理态

#define TASK_DPC_GND_CTRL_GPIO      GPIO_PORTL_BASE
#define TASK_DPC_GND_CTRL_PIN       GPIO_PIN_4
#define TASK_DPC_GND_CTRL_CLK       SYSCTL_PERIPH_GPIOL

#define TASK_DPC_375GND1_CTRL_GPIO      GPIO_PORTN_BASE
#define TASK_DPC_375GND1_CTRL_PIN       GPIO_PIN_3
#define TASK_DPC_375GND1_CTRL_CLK       SYSCTL_PERIPH_GPION

#define TASK_DPC_375GND2_CTRL_GPIO      GPIO_PORTN_BASE
#define TASK_DPC_375GND2_CTRL_PIN       GPIO_PIN_4
#define TASK_DPC_375GND2_CTRL_CLK       SYSCTL_PERIPH_GPION

#define TASK_DPC_48GND1_CTRL_GPIO      GPIO_PORTN_BASE
#define TASK_DPC_48GND1_CTRL_PIN       GPIO_PIN_1
#define TASK_DPC_48GND1_CTRL_CLK       SYSCTL_PERIPH_GPION

#define TASK_DPC_48GND2_CTRL_GPIO      GPIO_PORTN_BASE
#define TASK_DPC_48GND2_CTRL_PIN       GPIO_PIN_2
#define TASK_DPC_48GND2_CTRL_CLK       SYSCTL_PERIPH_GPION

#define TASK_DPC_24GND1_CTRL_GPIO      GPIO_PORTP_BASE
#define TASK_DPC_24GND1_CTRL_PIN       GPIO_PIN_5
#define TASK_DPC_24GND1_CTRL_CLK       SYSCTL_PERIPH_GPIOP

#define TASK_DPC_24GND2_CTRL_GPIO      GPIO_PORTN_BASE
#define TASK_DPC_24GND2_CTRL_PIN       GPIO_PIN_0
#define TASK_DPC_24GND2_CTRL_CLK       SYSCTL_PERIPH_GPION

#define TASK_DPC_12GND1_CTRL_GPIO      GPIO_PORTP_BASE
#define TASK_DPC_12GND1_CTRL_PIN       GPIO_PIN_3
#define TASK_DPC_12GND1_CTRL_CLK       SYSCTL_PERIPH_GPIOP

#define TASK_DPC_12GND2_CTRL_GPIO      GPIO_PORTP_BASE
#define TASK_DPC_12GND2_CTRL_PIN       GPIO_PIN_4
#define TASK_DPC_12GND2_CTRL_CLK       SYSCTL_PERIPH_GPIOP

#define TASK_DPC_CO2_INPUT_GPIO      GPIO_PORTM_BASE
#define TASK_DPC_CO2_INPUT_PIN       GPIO_PIN_7
#define TASK_DPC_CO2_INPUT_CLK       SYSCTL_PERIPH_GPIOM

#define TASK_DPC_CTD_INPUT_GPIO      GPIO_PORTM_BASE
#define TASK_DPC_CTD_INPUT_PIN       GPIO_PIN_6
#define TASK_DPC_CTD_INPUT_CLK       SYSCTL_PERIPH_GPIOM

#define TASK_DPC_UV1_INPUT_GPIO      GPIO_PORTM_BASE
#define TASK_DPC_UV1_INPUT_PIN       GPIO_PIN_5
#define TASK_DPC_UV1_INPUT_CLK       SYSCTL_PERIPH_GPIOM

#define TASK_DPC_UV2_INPUT_GPIO      GPIO_PORTM_BASE
#define TASK_DPC_UV2_INPUT_PIN       GPIO_PIN_4
#define TASK_DPC_UV2_INPUT_CLK       SYSCTL_PERIPH_GPIOM

#define TASK_DPC_UV3_INPUT_GPIO      GPIO_PORTB_BASE
#define TASK_DPC_UV3_INPUT_PIN       GPIO_PIN_2
#define TASK_DPC_UV3_INPUT_CLK       SYSCTL_PERIPH_GPIOB

#define TASK_DPC_UV4_INPUT_GPIO      GPIO_PORTB_BASE
#define TASK_DPC_UV4_INPUT_PIN       GPIO_PIN_3
#define TASK_DPC_UV4_INPUT_CLK       SYSCTL_PERIPH_GPIOB

#define TASK_DPC_375GND1_ADC_ID     MCU_BSP_ADC0
#define TASK_DPC_375GND2_ADC_ID     MCU_BSP_ADC1
#define TASK_DPC_375V_VADC_ID       MCU_BSP_ADC11
#define TASK_DPC_375V_IADC_ID       MCU_BSP_ADC10

#define TASK_DPC_48GND1_ADC_ID      MCU_BSP_ADC2
#define TASK_DPC_48GND2_ADC_ID      MCU_BSP_ADC3
#define TASK_DPC_48V_VADC_ID       MCU_BSP_ADC9
#define TASK_DPC_48V_IADC_ID       MCU_BSP_ADC8

#define TASK_DPC_24GND1_ADC_ID      MCU_BSP_ADC16
#define TASK_DPC_24GND2_ADC_ID      MCU_BSP_ADC17

#define TASK_DPC_12GND1_ADC_ID      MCU_BSP_ADC18
#define TASK_DPC_12GND2_ADC_ID      MCU_BSP_ADC19
#define TASK_DPC_12V_VADC_ID       MCU_BSP_ADC5
#define TASK_DPC_12V_IADC_ID       MCU_BSP_ADC4

#define TASK_DPC_VEDIO_V_ID   MCU_BSP_ADC7
#define TASK_DPC_VEDIO_I_ID   MCU_BSP_ADC6

#define STATUS_RUN_ASK_CMD "AABB\n"
#define RESTART_ASK_CMD "CCDD\n"
#define STATUS_OUTPUT_ASK_CMD "EEFF\n"

#define TASK_DPC_375GND_ID  1
#define TASK_DPC_48GND_ID   2
#define TASK_DPC_24GND_ID   3
#define TASK_DPC_12GND_ID   4

typedef struct {
    uint8_t RecvBuf[32];
    uint16_t RecvCount;
    uint16_t RecvStatus;
} DPC_RECVDATA;

typedef struct {
    uint32_t Status;
    float V375;
    float I375;
    float V48;
    float I48;
    float V12;
    float I12;
    float G375;
    float G48;
    float G24;
    float G12;
    uint8_t G375Sta;
    uint8_t G48Sta;
    uint8_t G24Sta;
    uint8_t G12Sta;
} RUN_ASK_DATA;

typedef struct {
    uint32_t Status;
    uint8_t CO2In;
    uint8_t CTDIn;
    uint8_t UV1In;
    uint8_t UV2In;
    uint8_t UV3In;
    uint8_t UV4In;
    float VedioV;
    float VedioI;
} OUTOUT_ASK_STATUS;

static int gTaskDpcId = -1; // 与下位机通信的看门狗事件ID

static DPC_RECVDATA gDpcUartBuf[10] = {{0}};
static RUN_ASK_DATA gDpcRunAskData = {0};
static OUTOUT_ASK_STATUS gDpcOutputAskData = {0};

static int gTaskDpcRunEnable = 0;
static int gTaskDpcOutputEnable = 0;

static char gTaskDpcSendBuf[1024] = {0};

static void TaskDpcUartRecvCallback(unsigned char rData);
/* 清除接收buf */
static void TaskUpcCommClearDataStatus(uint8_t CountId);
static void TaskDpcGndCtrl(int flag);
static void TaskDpcGndGet(uint8_t DpcGndId);
static void TaskDpcSend(void);

void TaskDpcInit(void)
{
    McuBspAdcInit();
    SysCtlPeripheralEnable(TASK_DPC_GND_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_GND_CTRL_GPIO, TASK_DPC_GND_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_GND_CTRL_GPIO, TASK_DPC_GND_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_GND_CTRL_GPIO, TASK_DPC_GND_CTRL_PIN, ~TASK_DPC_GND_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_375GND1_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_375GND1_CTRL_GPIO, TASK_DPC_375GND1_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_375GND1_CTRL_GPIO, TASK_DPC_375GND1_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_375GND1_CTRL_GPIO, TASK_DPC_375GND1_CTRL_PIN, ~TASK_DPC_375GND1_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_375GND2_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_375GND2_CTRL_GPIO, TASK_DPC_375GND2_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_375GND2_CTRL_GPIO, TASK_DPC_375GND2_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_375GND2_CTRL_GPIO, TASK_DPC_375GND2_CTRL_PIN, ~TASK_DPC_375GND2_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_48GND1_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_48GND1_CTRL_GPIO, TASK_DPC_48GND1_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_48GND1_CTRL_GPIO, TASK_DPC_48GND1_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_48GND1_CTRL_GPIO, TASK_DPC_48GND1_CTRL_PIN, ~TASK_DPC_48GND1_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_48GND2_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_48GND2_CTRL_GPIO, TASK_DPC_48GND2_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_48GND2_CTRL_GPIO, TASK_DPC_48GND2_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_48GND2_CTRL_GPIO, TASK_DPC_48GND2_CTRL_PIN, ~TASK_DPC_48GND2_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_24GND1_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_24GND1_CTRL_GPIO, TASK_DPC_24GND1_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_24GND1_CTRL_GPIO, TASK_DPC_24GND1_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_24GND1_CTRL_GPIO, TASK_DPC_24GND1_CTRL_PIN, ~TASK_DPC_24GND1_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_24GND2_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_24GND2_CTRL_GPIO, TASK_DPC_24GND2_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_24GND2_CTRL_GPIO, TASK_DPC_24GND2_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_24GND2_CTRL_GPIO, TASK_DPC_24GND2_CTRL_PIN, ~TASK_DPC_24GND2_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_12GND1_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_12GND1_CTRL_GPIO, TASK_DPC_12GND1_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_12GND1_CTRL_GPIO, TASK_DPC_12GND1_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_12GND1_CTRL_GPIO, TASK_DPC_12GND1_CTRL_PIN, ~TASK_DPC_12GND1_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_12GND2_CTRL_CLK);
    GPIODirModeSet(TASK_DPC_12GND2_CTRL_GPIO, TASK_DPC_12GND2_CTRL_PIN, GPIO_DIR_MODE_OUT);
    GPIOPadConfigSet(TASK_DPC_12GND2_CTRL_GPIO, TASK_DPC_12GND2_CTRL_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
    GPIOPinWrite(TASK_DPC_12GND2_CTRL_GPIO, TASK_DPC_12GND2_CTRL_PIN, ~TASK_DPC_12GND2_CTRL_PIN);
    
    SysCtlPeripheralEnable(TASK_DPC_CO2_INPUT_CLK);
    GPIODirModeSet(TASK_DPC_CO2_INPUT_GPIO, TASK_DPC_CO2_INPUT_PIN, GPIO_DIR_MODE_IN);
    
    SysCtlPeripheralEnable(TASK_DPC_CTD_INPUT_CLK);
    GPIODirModeSet(TASK_DPC_CTD_INPUT_GPIO, TASK_DPC_CTD_INPUT_PIN, GPIO_DIR_MODE_IN);
    
    SysCtlPeripheralEnable(TASK_DPC_UV1_INPUT_CLK);
    GPIODirModeSet(TASK_DPC_UV1_INPUT_GPIO, TASK_DPC_UV1_INPUT_PIN, GPIO_DIR_MODE_IN);
    
    SysCtlPeripheralEnable(TASK_DPC_UV2_INPUT_CLK);
    GPIODirModeSet(TASK_DPC_UV2_INPUT_GPIO, TASK_DPC_UV2_INPUT_PIN, GPIO_DIR_MODE_IN);
    
    SysCtlPeripheralEnable(TASK_DPC_UV3_INPUT_CLK);
    GPIODirModeSet(TASK_DPC_UV3_INPUT_GPIO, TASK_DPC_UV3_INPUT_PIN, GPIO_DIR_MODE_IN);
    
    SysCtlPeripheralEnable(TASK_DPC_UV4_INPUT_CLK);
    GPIODirModeSet(TASK_DPC_UV4_INPUT_GPIO, TASK_DPC_UV4_INPUT_PIN, GPIO_DIR_MODE_IN);

    McuBspUartInit(TASK_DPC_UART_ID, TASK_DPC_UART_BANDRATE, TASK_DPC_UART_DATABIT,
                   TASK_DPC_UART_STOPBIT, TASK_DPC_UART_CHECKBIT);
    McuBspUartStartRecv(TASK_DPC_UART_ID, TaskDpcUartRecvCallback);
    gTaskDpcId = TaskWatchdogRegEvent("TaskDpc");
}

void TaskDpc(void *arg)
{
    int i;
    while (1) {
        OSTimeDly(5);
        TaskWatchdogFreed(gTaskDpcId);
        for (i = 0; i < 10; i++) {
            if (gDpcUartBuf[i].RecvStatus == TASK_DPC_DATA_HANDLING) {
                if (NULL != strstr((char *)gDpcUartBuf[i].RecvBuf, STATUS_RUN_ASK_CMD)) {
                    gTaskDpcRunEnable = 1;
                } else if (NULL != strstr((char *)gDpcUartBuf[i].RecvBuf, STATUS_OUTPUT_ASK_CMD)) {
                    gTaskDpcOutputEnable = 1;
                } else if (NULL != strstr((char *)gDpcUartBuf[i].RecvBuf, RESTART_ASK_CMD)) {
                    SysCtlReset();
                }
                TaskUpcCommClearDataStatus(i);
                break;
            }
        }
        if (gTaskDpcRunEnable == 1) {
            /* 控制 */
            TaskDpcGndCtrl(1);
            TaskDpcGndGet(TASK_DPC_375GND_ID);
            TaskDpcGndGet(TASK_DPC_48GND_ID);
            TaskDpcGndGet(TASK_DPC_24GND_ID);
            TaskDpcGndGet(TASK_DPC_12GND_ID);
            TaskDpcGndCtrl(0);
            McuBspAdcGetValue(TASK_DPC_375V_VADC_ID, &gDpcRunAskData.V375);
            McuBspAdcGetValue(TASK_DPC_375V_IADC_ID, &gDpcRunAskData.I375);
            McuBspAdcGetValue(TASK_DPC_48V_VADC_ID, &gDpcRunAskData.V48);
            McuBspAdcGetValue(TASK_DPC_48V_IADC_ID, &gDpcRunAskData.I48);
            McuBspAdcGetValue(TASK_DPC_12V_VADC_ID, &gDpcRunAskData.V12);
            McuBspAdcGetValue(TASK_DPC_12V_IADC_ID, &gDpcRunAskData.I12);
            gDpcRunAskData.Status = 1;
            TaskDpcSend();
            gTaskDpcRunEnable = 0;
        }
        if (gTaskDpcOutputEnable == 1) {
            if (TASK_DPC_CO2_INPUT_PIN == GPIOPinRead(TASK_DPC_CO2_INPUT_GPIO, TASK_DPC_CO2_INPUT_PIN)) {
                gDpcOutputAskData.CO2In = 1;
            } else {
                gDpcOutputAskData.CO2In = 0;
            }
            if (TASK_DPC_CTD_INPUT_PIN == GPIOPinRead(TASK_DPC_CTD_INPUT_GPIO, TASK_DPC_CTD_INPUT_PIN)) {
                gDpcOutputAskData.CTDIn = 1;
            } else {
                gDpcOutputAskData.CTDIn = 0;
            }
            if (TASK_DPC_UV1_INPUT_PIN == GPIOPinRead(TASK_DPC_UV1_INPUT_GPIO, TASK_DPC_UV1_INPUT_PIN)) {
                gDpcOutputAskData.UV1In = 1;
            } else {
                gDpcOutputAskData.UV1In = 0;
            }
            if (TASK_DPC_UV2_INPUT_PIN == GPIOPinRead(TASK_DPC_UV2_INPUT_GPIO, TASK_DPC_UV2_INPUT_PIN)) {
                gDpcOutputAskData.UV2In = 1;
            } else {
                gDpcOutputAskData.UV2In = 0;
            }
            if (TASK_DPC_UV3_INPUT_PIN == GPIOPinRead(TASK_DPC_UV3_INPUT_GPIO, TASK_DPC_UV3_INPUT_PIN)) {
                gDpcOutputAskData.UV3In = 1;
            } else {
                gDpcOutputAskData.UV3In = 0;
            }
            if (TASK_DPC_UV4_INPUT_PIN == GPIOPinRead(TASK_DPC_UV4_INPUT_GPIO, TASK_DPC_UV4_INPUT_PIN)) {
                gDpcOutputAskData.UV4In = 1;
            } else {
                gDpcOutputAskData.UV4In = 0;
            }
            McuBspAdcGetValue(TASK_DPC_VEDIO_V_ID, &gDpcOutputAskData.VedioV);
            McuBspAdcGetValue(TASK_DPC_VEDIO_I_ID, &gDpcOutputAskData.VedioI);
            gDpcOutputAskData.Status = 1;
            gTaskDpcOutputEnable = 0;
            TaskDpcSend();
        }
    }
}

static void TaskDpcGndGet(uint8_t DpcGndId)
{
    float Value1;
    float Value2;
    float Value1All;
    float Value2All;
    int i = 0;
    if (DpcGndId == TASK_DPC_375GND_ID) {
        GPIOPinWrite(TASK_DPC_375GND1_CTRL_GPIO, TASK_DPC_375GND1_CTRL_PIN, TASK_DPC_375GND1_CTRL_PIN);
        GPIOPinWrite(TASK_DPC_375GND2_CTRL_GPIO, TASK_DPC_375GND2_CTRL_PIN, TASK_DPC_375GND2_CTRL_PIN);
        while(1) {
            i++;
            McuBspAdcGetValue(TASK_DPC_375GND1_ADC_ID, &Value1);
            McuBspAdcGetValue(TASK_DPC_375GND2_ADC_ID, &Value2);
            Value1All += Value1;
            Value2All += Value2;
            if (i > 1000) {
                Value1All = Value1All / 1000.0f;
                Value2All = Value2All / 1000.0f;
                break;
            }
            OSTimeDly(1);
        }
        GPIOPinWrite(TASK_DPC_375GND1_CTRL_GPIO, TASK_DPC_375GND1_CTRL_PIN, ~TASK_DPC_375GND1_CTRL_PIN);
        GPIOPinWrite(TASK_DPC_375GND2_CTRL_GPIO, TASK_DPC_375GND2_CTRL_PIN, ~TASK_DPC_375GND2_CTRL_PIN);
        if (fabs(Value1All - Value2All) < 500) {
            gDpcRunAskData.G375Sta = 0;
            gDpcRunAskData.G375 = 0;
        } else {
            if ((Value1All - Value2All) > 0) {
                gDpcRunAskData.G375 = (Value1All / Value2All) * 20.0f / 1000.0f;
                gDpcRunAskData.G375Sta = 1;
            } else {
                gDpcRunAskData.G375 = (Value2All / Value1All) * 20.0f / 1000.0f;
                gDpcRunAskData.G375Sta = 2;
            }
        }
    } else if (DpcGndId == TASK_DPC_48GND_ID) {
        GPIOPinWrite(TASK_DPC_48GND1_CTRL_GPIO, TASK_DPC_48GND1_CTRL_PIN, TASK_DPC_48GND1_CTRL_PIN);
        GPIOPinWrite(TASK_DPC_48GND2_CTRL_GPIO, TASK_DPC_48GND2_CTRL_PIN, TASK_DPC_48GND2_CTRL_PIN);
        while(1) {
            i++;
            McuBspAdcGetValue(TASK_DPC_48GND1_ADC_ID, &Value1);
            McuBspAdcGetValue(TASK_DPC_48GND2_ADC_ID, &Value2);
            Value1All += Value1;
            Value2All += Value2;
            if (i > 1000) {
                Value1All = Value1All / 1000.0f;
                Value2All = Value2All / 1000.0f;
                break;
            }
            OSTimeDly(1);
        }
        GPIOPinWrite(TASK_DPC_48GND1_CTRL_GPIO, TASK_DPC_48GND1_CTRL_PIN, ~TASK_DPC_48GND1_CTRL_PIN);
        GPIOPinWrite(TASK_DPC_48GND2_CTRL_GPIO, TASK_DPC_48GND2_CTRL_PIN, ~TASK_DPC_48GND2_CTRL_PIN);
        if (fabs(Value1All - Value2All) < 500) {
            gDpcRunAskData.G48Sta = 0;
            gDpcRunAskData.G48 = 0;
        } else {
            if ((Value1All - Value2All) > 0) {
                gDpcRunAskData.G48 = (Value1 / Value2) * 10.5f / 1000.0f;
                gDpcRunAskData.G48Sta = 1;
            } else {
                gDpcRunAskData.G48 = (Value2 / Value1) * 10.5f / 1000.0f;
                gDpcRunAskData.G48Sta = 2;
            }
        }
    } else if (DpcGndId == TASK_DPC_24GND_ID) {
        GPIOPinWrite(TASK_DPC_24GND1_CTRL_GPIO, TASK_DPC_24GND1_CTRL_PIN, TASK_DPC_24GND1_CTRL_PIN);
        GPIOPinWrite(TASK_DPC_24GND2_CTRL_GPIO, TASK_DPC_24GND2_CTRL_PIN, TASK_DPC_24GND2_CTRL_PIN);
        while(1) {
            i++;
            McuBspAdcGetValue(TASK_DPC_24GND1_ADC_ID, &Value1);
            McuBspAdcGetValue(TASK_DPC_24GND2_ADC_ID, &Value2);
            Value1All += Value1;
            Value2All += Value2;
            if (i > 1000) {
                Value1All = Value1All / 1000.0f;
                Value2All = Value2All / 1000.0f;
                break;
            }
            OSTimeDly(1);
        }
        GPIOPinWrite(TASK_DPC_24GND1_CTRL_GPIO, TASK_DPC_24GND1_CTRL_PIN, ~TASK_DPC_24GND1_CTRL_PIN);
        GPIOPinWrite(TASK_DPC_24GND2_CTRL_GPIO, TASK_DPC_24GND2_CTRL_PIN, ~TASK_DPC_24GND2_CTRL_PIN);
        if (fabs(Value1All - Value2All) < 500) {
            gDpcRunAskData.G24Sta = 0;
            gDpcRunAskData.G24 = 0;
        } else {
            if ((Value1All - Value2All) > 0) {
                gDpcRunAskData.G24 = (Value1 / Value2) * 11.0f / 1000.0f;
                gDpcRunAskData.G24Sta = 1;
            } else {
                gDpcRunAskData.G24 = (Value2 / Value1) * 11.0f / 1000.0f;
                gDpcRunAskData.G24Sta = 2;
            }
        }
    } else if (DpcGndId == TASK_DPC_12GND_ID) {
        GPIOPinWrite(TASK_DPC_12GND1_CTRL_GPIO, TASK_DPC_12GND1_CTRL_PIN, TASK_DPC_12GND1_CTRL_PIN);
        GPIOPinWrite(TASK_DPC_12GND2_CTRL_GPIO, TASK_DPC_12GND2_CTRL_PIN, TASK_DPC_12GND2_CTRL_PIN);
        while(1) {
            i++;
            McuBspAdcGetValue(TASK_DPC_12GND1_ADC_ID, &Value1);
            McuBspAdcGetValue(TASK_DPC_12GND2_ADC_ID, &Value2);
            Value1All += Value1;
            Value2All += Value2;
            if (i > 1000) {
                Value1All = Value1All / 1000.0f;
                Value2All = Value2All / 1000.0f;
                break;
            }
            OSTimeDly(1);
        }
        GPIOPinWrite(TASK_DPC_12GND1_CTRL_GPIO, TASK_DPC_12GND1_CTRL_PIN, ~TASK_DPC_12GND1_CTRL_PIN);
        GPIOPinWrite(TASK_DPC_12GND2_CTRL_GPIO, TASK_DPC_12GND2_CTRL_PIN, ~TASK_DPC_12GND2_CTRL_PIN);
        if (fabs(Value1All - Value2All) < 500) {
            gDpcRunAskData.G12Sta = 0;
            gDpcRunAskData.G12 = 0;
        } else {
            if ((Value1All - Value2All) > 0) {
                gDpcRunAskData.G12 = (Value1 / Value2) * 12.0f / 1000.0f;
                gDpcRunAskData.G12Sta = 1;
            } else {
                gDpcRunAskData.G12 = (Value2 / Value1) * 12.0f / 1000.0f;
                gDpcRunAskData.G12Sta = 2;
            }
        }
    }
}

static void TaskDpcGndCtrl(int flag)
{
    if (flag == 0) {
        GPIOPinWrite(TASK_DPC_GND_CTRL_GPIO, TASK_DPC_GND_CTRL_PIN, ~TASK_DPC_GND_CTRL_PIN);
    } else {
        GPIOPinWrite(TASK_DPC_GND_CTRL_GPIO, TASK_DPC_GND_CTRL_PIN, TASK_DPC_GND_CTRL_PIN);
    }
}

static void TaskDpcSend(void)
{
    if (gDpcRunAskData.Status == 1) {
        sprintf(gTaskDpcSendBuf, "AABB,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%0.2f,%d,%d,%d,%d\n",
        gDpcRunAskData.V375, gDpcRunAskData.I375, gDpcRunAskData.V48, gDpcRunAskData.I48,
        gDpcRunAskData.V12, gDpcRunAskData.I12, gDpcRunAskData.G375, gDpcRunAskData.G48,
        gDpcRunAskData.G24, gDpcRunAskData.G12, gDpcRunAskData.G375Sta, gDpcRunAskData.G48Sta,
        gDpcRunAskData.G24Sta, gDpcRunAskData.G12Sta);
        McuBspUartSendData(TASK_DPC_UART_ID, (uint8_t*)gTaskDpcSendBuf, strlen(gTaskDpcSendBuf));
        gDpcRunAskData.Status = 0;
    }
    if (gDpcOutputAskData.Status == 1) {
        sprintf(gTaskDpcSendBuf, "EEFF,%d,%d,%d,%d,%d,%d,%0.2f,%0.2f\n", gDpcOutputAskData.CO2In,
        gDpcOutputAskData.CTDIn, gDpcOutputAskData.UV1In, gDpcOutputAskData.UV2In, gDpcOutputAskData.UV3In,
        gDpcOutputAskData.UV4In, gDpcOutputAskData.VedioV, gDpcOutputAskData.VedioI);
        McuBspUartSendData(TASK_DPC_UART_ID, (uint8_t*)gTaskDpcSendBuf, strlen(gTaskDpcSendBuf));
        gDpcOutputAskData.Status = 0;
    }
}

static void TaskDpcUartRecvCallback(unsigned char rData)
{
    int i;
    for (i = 0; i < 10; i++) {
        if (gDpcUartBuf[i].RecvStatus == TASK_DPC_DATA_SORTING) {
            gDpcUartBuf[i].RecvBuf[gDpcUartBuf[i].RecvCount] = rData;
            gDpcUartBuf[i].RecvCount++;
            gDpcUartBuf[i].RecvCount = gDpcUartBuf[i].RecvCount % 32;
            if (rData == '\n') {
                gDpcUartBuf[i].RecvStatus = TASK_DPC_DATA_HANDLING;
            }
            return;
        }
    }
    for (i = 0; i < 10; i++) {
        if (gDpcUartBuf[i].RecvStatus == TASK_DPC_DATA_IDLING) {
            gDpcUartBuf[i].RecvBuf[gDpcUartBuf[i].RecvCount] = rData;
            gDpcUartBuf[i].RecvCount++;
            gDpcUartBuf[i].RecvCount = gDpcUartBuf[i].RecvCount % 32;
            if (rData == '\n') {
                gDpcUartBuf[i].RecvStatus = TASK_DPC_DATA_HANDLING;
            }
            gDpcUartBuf[i].RecvStatus = TASK_DPC_DATA_SORTING;
            return;
        }
    }
}

/* 清除接收buf */
static void TaskUpcCommClearDataStatus(uint8_t CountId)
{
    gDpcUartBuf[CountId].RecvStatus = TASK_DPC_DATA_IDLING;
    gDpcUartBuf[CountId].RecvCount = 0;
}