#include "RunEnvTask.h"
#include "DpcCommTask.h"
#include "WatchDogTask.h"
#include "ToolDataTypeSwitch.h"
#include "FileSysTask.h"
#include "UpcCommTask.h"

#include "TempAndHumiDrv.h"
#include "ImuDrv.h"

#include "McuBspAdc.h"

#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"

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

/* ADC定义 */
#define V24_V_ADC_ID    MCU_BSP_ADC0
#define V24_I_ADC_ID    MCU_BSP_ADC1
#define LEAK1_ADC_ID    MCU_BSP_ADC2
#define LEAK2_ADC_ID    MCU_BSP_ADC3

/* 375V输入 */
static uint32_t gV375_Vu32 = 0;
static float gV375_Vf = 0.0f;
static uint32_t gV375_Iu32 = 0;
static float gV375_If = 0.0f;
static uint32_t gV375_Gu32 = 0;
static float gV375_Gf = 0.0f;
static uint8_t gV375_GSta = 0;
/* 48V输入 */
static uint32_t gV48_Vu32 = 0;
static float gV48_Vf = 0.0f;
static uint32_t gV48_Iu32 = 0;
static float gV48_If = 0.0f;
static uint32_t gV48_Gu32 = 0;
static float gV48_Gf = 0.0f;
static uint8_t gV48_GSta = 0;
/* 24V输入 */
static uint32_t gV24_Vu32 = 0;
static float gV24_Vf = 0.0f;
static uint32_t gV24_Iu32 = 0;
static float gV24_If = 0.0f;
static uint32_t gV24_Gu32 = 0;
static float gV24_Gf = 0.0f;
static uint8_t gV24_GSta = 0;
/* 12V输入 */
static uint32_t gV12_Vu32 = 0;
static float gV12_Vf = 0.0f;
static uint32_t gV12_Iu32 = 0;
static float gV12_If = 0.0f;
static uint32_t gV12_Gu32 = 0;
static float gV12_Gf = 0.0f;
static uint8_t gV12_GSta = 0;
/* 电子舱温湿度 */
static uint32_t gTemp_u32 = 0;
static float gTemp_f = 0.0f;
static uint32_t gHumi_u32 = 0;
static float gHumi_f = 0.0f;
/* 电子舱姿态 */
static uint32_t gRoll_u32 = 0;
static float gRoll_f = 0.0f;
static uint32_t gPitch_u32 = 0;
static float gPitch_f = 0.0f;
static uint32_t gYaw_u32 = 0;
static float gYaw_f = 0.0f;
static uint32_t gAtmos_u32 = 0;
/* 电子舱漏水 */
static uint32_t gLeak1_u32 = 0;
static float gLeak1_f = 0.0f;
static uint32_t gLeak2_u32 = 0;
static float gLeak2_f = 0.0f;

static RUN_DPC_DATA gTaskRunEnvRunDpcSta = {0};

static unsigned short gTaskRunEnvSendSerial = 0;

static int gTaskRunEnvWatchDogId = -1; // 心跳包看门狗事件ID
static int gTaskRunEnvPickEnable = -1; // 端口输出状态采集使能
static unsigned char gTaskRunEnvSendBuf[85] = {0}; // 端口输出发送的状态缓存,109因为该消息体大小为109

static char gTaskRunEnvFileDataBuf[1024] = {0};

void TaskRunEnvInit(void)
{
    /* 初始化ADC */
    McuBspAdcInit();
    /* 初始化IMU */
    DrvImuInit();
    /* 初始化温湿度 */
    DrvTempAndHumiInit();
    /* 看门狗事件注册 */
    gTaskRunEnvWatchDogId = TaskWatchdogRegEvent("TaskRunEnv");
}

void TaskRunEnv(void *arg)
{
    unsigned int RealWbyte;
    int i = 0;
    /* 将时钟同步任务开启写入日志 */
    TaskFileLogWrite("TaskRunEnv: Join in!!\n", strlen("TaskRunEnv: Join in!!\n"), &RealWbyte);
    while (1) {
        OSTimeDly(100);
        TaskWatchdogFreed(gTaskRunEnvWatchDogId);
        if (gTaskRunEnvPickEnable != 1) {
            continue;
        }
        /* 使能获取从板的数据 */
        i = 0;
        
        while (0 > TaskDpcCommSetAskEnable(STATUS_RUN_ASK_ID)){
            i++;
            OSTimeDly(100);
            TaskWatchdogFreed(gTaskRunEnvWatchDogId);
            if (i > 1000) {
                break;
            }
        }
        TaskWatchdogFreed(gTaskRunEnvWatchDogId);
        /* 等待从板新数据生成完毕 */
        i = 0;
        while (0 == TaskDpcCommGetRunDataStatus()) {
            i++;
            OSTimeDly(100);
            TaskWatchdogFreed(gTaskRunEnvWatchDogId);
            if (i > 1000) {
                break;
            }
        }
        if (0 > TaskDpcCommGetRunData(&gTaskRunEnvRunDpcSta)) {
            memset(&gTaskRunEnvRunDpcSta, 0, sizeof(gTaskRunEnvRunDpcSta));
        }
        TaskWatchdogFreed(gTaskRunEnvWatchDogId);
        gV375_Vf = gTaskRunEnvRunDpcSta.V375;
        gV375_If = gTaskRunEnvRunDpcSta.I375;
        gV48_Vf = gTaskRunEnvRunDpcSta.V48;
        gV48_If = gTaskRunEnvRunDpcSta.I48;
        McuBspAdcGetValue(V24_V_ADC_ID, &gV24_Vf);
        McuBspAdcGetValue(V24_I_ADC_ID, &gV24_If);
        gV12_Vf = gTaskRunEnvRunDpcSta.V12;
        gV12_If = gTaskRunEnvRunDpcSta.I12;
        gV375_Gf = gTaskRunEnvRunDpcSta.G375;
        gV48_Gf = gTaskRunEnvRunDpcSta.G48;
        gV24_Gf = gTaskRunEnvRunDpcSta.G24;
        gV12_Gf = gTaskRunEnvRunDpcSta.G12;
        
        gV375_GSta = gTaskRunEnvRunDpcSta.G375Sta;
        gV48_GSta = gTaskRunEnvRunDpcSta.G48Sta;
        gV24_GSta = gTaskRunEnvRunDpcSta.G24Sta;
        gV12_GSta = gTaskRunEnvRunDpcSta.G12Sta;
        ToolFloatToUint32(gV375_Vf, &gV375_Vu32);
        ToolFloatToUint32(gV375_If, &gV375_Iu32);
        ToolFloatToUint32(gV48_Vf, &gV48_Vu32);
        ToolFloatToUint32(gV48_If, &gV48_Iu32);
        ToolFloatToUint32(gV24_Vf, &gV24_Vu32);
        ToolFloatToUint32(gV24_If, &gV24_Iu32);
        ToolFloatToUint32(gV12_Vf, &gV12_Vu32);
        ToolFloatToUint32(gV12_If, &gV12_Iu32);
        ToolFloatToUint32(gV375_Gf, &gV375_Gu32);
        ToolFloatToUint32(gV48_Gf, &gV48_Gu32);
        ToolFloatToUint32(gV24_Gf, &gV24_Gu32);
        ToolFloatToUint32(gV12_Gf, &gV12_Gu32);
        /* 获取温湿度数据 */
        i = 0;
        while (0 > DrvTempAndHumiGet(&gTemp_f, &gHumi_f)) {
            i++;
            OSTimeDly(10);
            TaskWatchdogFreed(gTaskRunEnvWatchDogId);
            if (i > 1000) {
                gTemp_f = 0;
                gHumi_f = 0;
                break;
            }
        }
        TaskWatchdogFreed(gTaskRunEnvWatchDogId);
        ToolFloatToUint32(gTemp_f, &gTemp_u32);
        ToolFloatToUint32(gHumi_f, &gHumi_u32);
        /* 获取IMU数据 */
        i = 0;
        while (0 > DrvImuGetAtmosData(&gAtmos_u32)) {
            i++;
            OSTimeDly(10);
            TaskWatchdogFreed(gTaskRunEnvWatchDogId);
            if (i > 1000) {
                gAtmos_u32 = 0;
                break;
            }
        }
        TaskWatchdogFreed(gTaskRunEnvWatchDogId);
        i = 0;
        while (0 > DrvImuGetAngleData(&gRoll_f, &gPitch_f, &gYaw_f)) {
            i++;
            OSTimeDly(10);
            TaskWatchdogFreed(gTaskRunEnvWatchDogId);
            if (i > 1000) {
                gRoll_f = 0;
                gPitch_f = 0;
                gYaw_f = 0;
                break;
            }
        }
        TaskWatchdogFreed(gTaskRunEnvWatchDogId);
        ToolFloatToUint32(gRoll_f, &gRoll_u32);
        ToolFloatToUint32(gPitch_f, &gPitch_u32);
        ToolFloatToUint32(gYaw_f, &gYaw_u32);
        /* 获取漏水信号 */
        McuBspAdcGetValue(LEAK1_ADC_ID, &gLeak1_f);
        McuBspAdcGetValue(LEAK2_ADC_ID, &gLeak2_f);
        ToolFloatToUint32(gLeak1_f, &gLeak1_u32);
        ToolFloatToUint32(gLeak2_f, &gLeak2_u32);
        /* 打包 */
        gTaskRunEnvSendBuf[0] = 1;
        gTaskRunEnvSendBuf[1] = (gV375_Vu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[2] = (gV375_Vu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[3] = (gV375_Vu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[4] = gV375_Vu32 & 0xff;
        gTaskRunEnvSendBuf[5] = (gV375_Iu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[6] = (gV375_Iu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[7] = (gV375_Iu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[8] = gV375_Iu32 & 0xff;
        gTaskRunEnvSendBuf[9] = (gV48_Vu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[10] = (gV48_Vu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[11] = (gV48_Vu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[12] = gV48_Vu32 & 0xff;
        gTaskRunEnvSendBuf[13] = (gV48_Iu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[14] = (gV48_Iu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[15] = (gV48_Iu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[16] = gV48_Iu32 & 0xff;
        gTaskRunEnvSendBuf[17] = (gV24_Vu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[18] = (gV24_Vu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[19] = (gV24_Vu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[20] = gV24_Vu32 & 0xff;
        gTaskRunEnvSendBuf[21] = (gV24_Iu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[22] = (gV24_Iu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[23] = (gV24_Iu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[24] = gV24_Iu32 & 0xff;
        gTaskRunEnvSendBuf[25] = (gV12_Vu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[26] = (gV12_Vu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[27] = (gV12_Vu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[28] = gV12_Vu32 & 0xff;
        gTaskRunEnvSendBuf[29] = (gV12_Iu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[30] = (gV12_Iu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[31] = (gV12_Iu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[32] = gV12_Iu32 & 0xff;
        gTaskRunEnvSendBuf[33] = (gV375_Gu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[34] = (gV375_Gu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[35] = (gV375_Gu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[36] = gV375_Gu32 & 0xff;
        gTaskRunEnvSendBuf[37] = (gV48_Gu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[38] = (gV48_Gu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[39] = (gV48_Gu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[40] = gV48_Gu32 & 0xff;
        gTaskRunEnvSendBuf[41] = (gV24_Gu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[42] = (gV24_Gu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[43] = (gV24_Gu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[44] = gV24_Gu32 & 0xff;
        gTaskRunEnvSendBuf[45] = (gV12_Gu32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[46] = (gV12_Gu32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[47] = (gV12_Gu32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[48] = gV12_Gu32 & 0xff;
        gTaskRunEnvSendBuf[49] = (gTemp_u32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[50] = (gTemp_u32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[51] = (gTemp_u32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[52] = gTemp_u32 & 0xff;
        gTaskRunEnvSendBuf[53] = (gRoll_u32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[54] = (gRoll_u32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[55] = (gRoll_u32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[56] = gRoll_u32 & 0xff;
        gTaskRunEnvSendBuf[57] = (gPitch_u32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[58] = (gPitch_u32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[59] = (gPitch_u32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[60] = gPitch_u32 & 0xff;
        gTaskRunEnvSendBuf[61] = (gYaw_u32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[62] = (gYaw_u32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[63] = (gYaw_u32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[64] = gYaw_u32 & 0xff;
        gTaskRunEnvSendBuf[65] = (gHumi_u32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[66] = (gHumi_u32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[67] = (gHumi_u32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[68] = gHumi_u32 & 0xff;
        gTaskRunEnvSendBuf[69] = (gLeak1_u32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[70] = (gLeak1_u32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[71] = (gLeak1_u32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[72] = gLeak1_u32 & 0xff;
        gTaskRunEnvSendBuf[73] = (gLeak2_u32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[74] = (gLeak2_u32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[75] = (gLeak2_u32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[76] = gLeak2_u32 & 0xff;
        gTaskRunEnvSendBuf[77] = (gAtmos_u32 >> 24) & 0xff;
        gTaskRunEnvSendBuf[78] = (gAtmos_u32 >> 16) & 0xff;
        gTaskRunEnvSendBuf[79] = (gAtmos_u32 >> 8) & 0xff;
        gTaskRunEnvSendBuf[80] = gAtmos_u32 & 0xff;
        gTaskRunEnvSendBuf[81] = gV375_GSta;
        gTaskRunEnvSendBuf[82] = gV48_GSta;
        gTaskRunEnvSendBuf[83] = gV24_GSta;
        gTaskRunEnvSendBuf[84] = gV12_GSta;
        /* 发送函数 */
        TaskUpcCommSendMessage(TASK_RUN_ENV_MESSGAE_ID, &gTaskRunEnvSendSerial, gTaskRunEnvSendBuf, sizeof(gTaskRunEnvSendBuf));
        TaskRunEnvDisable();
        gTaskRunEnvSendSerial++;
        sprintf(gTaskRunEnvFileDataBuf, "V375_V:%.02f,V375_I:%.02f,V48_V:%.02f,V48_I:%.02f,V24_V:%.02f,V24_I:%.02f,V12_V:%.02f,V12_I:%.02f,\
        V375_G:%0.2f,V375_GSta:%d,V48_G:%0.2f,V48_GSta:%d,V24_G:%.02f,V24_GSta:%d,V12_G:%0.2f,12_GSta:%d,\
        Temp:%.02f,Humi:%.02f,Roll:%0.2f,Pitch:%0.2f,Yaw:%0.2f,Leak1:%0.2f,Leak2:%0.2f,Atmos:%d",
        gV375_Vf,gV375_If,gV48_Vf,gV48_If,gV24_Vf,gV24_If,gV12_Vf,gV12_If,gV375_Gf,gV375_GSta,gV48_Gf,gV48_GSta,
        gV24_Gf,gV24_GSta,gV12_Gf,gV12_GSta,gTemp_f,gHumi_f,gRoll_f,gPitch_f,gYaw_f,gLeak1_f,gLeak2_f,gAtmos_u32);
        TaskFileDataWrite(TASK_RUN_FILE_TYPE, gTaskRunEnvFileDataBuf, strlen(gTaskRunEnvFileDataBuf),&RealWbyte);
    }
}

void TaskRunEnvEnable(void)
{
    gTaskRunEnvPickEnable = 1;
}

void TaskRunEnvDisable(void)
{
    gTaskRunEnvPickEnable = 0;
}