#include "stdio.h"

#include "FM_ADC.h"
#include "FM_GPIO.h"
#include "uart_dev.h"

#include "hostFreerotsTask.h"
#include "hostBusIdleDetection.h"
#include "hostMcuComm.h"
#include "hostMcuDataParse.h"
#include "hostRecvSlaveDataParse.h"
#include "hostSensorDataParse.h"
#include "hostQueueUart.h"
#include "hostParameter.h"

/* 发送任务 */
#define J0_Transmit_TASK_PRIO     7
#define J0_Transmit_STK_SIZE      64
static TaskHandle_t J0_TransmitTask_Handler;
static void J0_transmit_Task(void *pvParameters);
#define J2_Transmit_TASK_PRIO     7
#define J2_Transmit_STK_SIZE      64
static TaskHandle_t J2_TransmitTask_Handler;
static void J2_transmit_Task(void *pvParameters);
#define J4_Transmit_TASK_PRIO     7
#define J4_Transmit_STK_SIZE      64
static TaskHandle_t J4_TransmitTask_Handler;
static void J4_transmit_Task(void *pvParameters);
#define J6_Transmit_TASK_PRIO     7
#define J6_Transmit_STK_SIZE      64
static TaskHandle_t J6_TransmitTask_Handler;
static void J6_transmit_Task(void *pvParameters);
#define Lora_Transmit_TASK_PRIO     7
#define Lora_Transmit_STK_SIZE      64
static TaskHandle_t Lora_TransmitTask_Handler;
static void Lora_transmit_Task(void *pvParameters);
#define Su806_Transmit_TASK_PRIO     7
#define Su806_Transmit_STK_SIZE      64
static TaskHandle_t Su806_TransmitTask_Handler;
static void Su806_transmit_Task(void *pvParameters);
#define HostMcu_Transmit_TASK_PRIO     7
#define HostMcu_Transmit_STK_SIZE      64
static TaskHandle_t HostMcu_TransmitTask_Handler;
static void HostMcu_transmit_Task(void *pvParameters);

/* 释放内存任务 */
#define hostFreeMemory_TASK_PRIO     8
#define hostFreeMemory_STK_SIZE      64
static TaskHandle_t hostFreeMemory_Handler;
static void hostFreeMemory_Task(void *pvParameters);

/* 解析任务 */
#define hostMcuDataParse_TASK_PRIO     5
#define hostMcuDataParse_STK_SIZE      512
static TaskHandle_t hostMcuDataParse_Handler;
static void hostMcuDataParse_Task(void *pvParameters);

#define hostSensorDataParse_TASK_PRIO     5
#define hostSensorDataParse_STK_SIZE      512
static TaskHandle_t hostSensorDataParse_Handler;
static void hostSensorDataParse_Task(void *pvParameters);

#define hostRecvSlaveDataParse_TASK_PRIO     5
#define hostRecvSlaveDataParse_STK_SIZE      512
static TaskHandle_t hostRecvSlaveDataParse_Handler;
static void hostRecvSlaveDataParse_Task(void *pvParameters);

/* 数据采集任务 */
#define dataCollection_TASK_PRIO     4
#define dataCollection_STK_SIZE      128
static TaskHandle_t dataCollection_Handler;
static void dataCollection_Task(void *pvParameters);

/* 其他任务 */
#define hostOther_TASK_PRIO     2
#define hostOther_STK_SIZE      128
static TaskHandle_t hostOther_Handler;
static void hostOther_Task(void *pvParameters);


/**
  * @brief  将数据发送
  * @param
  * @retval
  */
void J0_transmit_Task(void *pvParameters)
{
    while (1) {
        J0QueueSend();
    }
}
void J2_transmit_Task(void *pvParameters)
{
    while (1) {
        J2QueueSend();
    }
}
void J4_transmit_Task(void *pvParameters)
{
    while (1) {
        J4QueueSend();
    }
}
void J6_transmit_Task(void *pvParameters)
{
    while (1) {
        J6QueueSend();
    }
}
void Lora_transmit_Task(void *pvParameters)
{
    while (1) {
        LoraQueueSend();
    }
}
void Su806_transmit_Task(void *pvParameters)
{
    while (1) {
        Su806QueueSend();
    }
}
void HostMcu_transmit_Task(void *pvParameters)
{
    while (1) {
        HostMcuQueueSend();
    }
}

/**
  * @brief  释放内存任务
  * @param
  * @retval
  */
void hostFreeMemory_Task(void *pvParameters)
{
    while (1) {
        hostBinarySemaphoreFreeMemory();
    }
}

/**
  * @brief  解析su806传来的数据
  * @param
  * @retval
  */
void hostMcuDataParse_Task(void *pvParameters)
{
    while (1) {
        hostMcuUartDataAnalysis(g_Su806_handle);
        vTaskDelay(10);
    }
}

/**
  * @brief  解析传感器传来的数据
  * @param
  * @retval
  */
void hostSensorDataParse_Task(void *pvParameters)
{
    while (1) {
        J0_SensorDataAnalysis();
        J2_SensorDataAnalysis();
        J4_SensorDataAnalysis();
        J6_SensorDataAnalysis();
        Lora_SensorDataAnalysis();
        vTaskDelay(5);
    }
}

/**
  * @brief  解析从mcu传来的数据
  * @param
  * @retval
  */
void hostRecvSlaveDataParse_Task(void *pvParameters)
{
    while (1) {
        hostRecvSlaveDataParse(g_Mcu_handle);
        vTaskDelay(10);
    }
}

/**
  * @brief  数据采集任务
  * @param
  * @retval
  */
void dataCollection_Task(void *pvParameters)
{
    while (1) {
        setBoardTemperature(getTemperature());
        setWorkVoltage(getInVoltage());
        setWorkCurrent(getInCurrent());
        setPwrOnVoltage(getSOCPwrOnVoltage());
        vTaskDelay(500);        
    }
}

/**
  * @brief  其他任务
  * @param
  * @retval
  */
void hostOther_Task(void *pvParameters)
{
    while (1) {
        log_info("xPortGetFreeHeapSize : %d",xPortGetFreeHeapSize());
        vTaskDelay(1000);
    }
}




/**
  * @brief  启动
  * @param
  * @retval
  */
void hostStartApp(void)
{
    HostMcu_GPIO_Init();
    readHostConfigParameter();
    HostMcu_uartBuf_Init(256, 256, 256, 1024);
    Init_J0_485(getJ0_485_Baud());
    Init_J2_485(getJ2_485_Baud());
    Init_J4_485(getJ4_485_Baud());
    Init_J6_485(getJ6_485_Baud());
    Init_Lora_Uart(getLora_Uart_Baud());
    Init_Mcu_Uart(115200);
    Init_Su806_Uart(115200);

    FM_ADC_Init();
    proportionalInt();

    applyDataBuffer();
    hostUartSendInit();
    hostIdleInit();
    HostMcu_485DE_Read();

    /* create task */
    xTaskCreate((TaskFunction_t )J0_transmit_Task,
                    (const char*    )"J0TransmitTask",
                    (uint16_t       )J0_Transmit_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )J0_Transmit_TASK_PRIO,
                    (TaskHandle_t*  )&J0_TransmitTask_Handler);

    xTaskCreate((TaskFunction_t )J2_transmit_Task,
                    (const char*    )"J2TransmitTask",
                    (uint16_t       )J2_Transmit_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )J2_Transmit_TASK_PRIO,
                    (TaskHandle_t*  )&J2_TransmitTask_Handler);

    xTaskCreate((TaskFunction_t )J4_transmit_Task,
                    (const char*    )"J4TransmitTask",
                    (uint16_t       )J4_Transmit_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )J4_Transmit_TASK_PRIO,
                    (TaskHandle_t*  )&J4_TransmitTask_Handler);

    xTaskCreate((TaskFunction_t )J6_transmit_Task,
                    (const char*    )"J6TransmitTask",
                    (uint16_t       )J6_Transmit_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )J6_Transmit_TASK_PRIO,
                    (TaskHandle_t*  )&J6_TransmitTask_Handler);

    xTaskCreate((TaskFunction_t )Lora_transmit_Task,
                    (const char*    )"LoraTransmitTask",
                    (uint16_t       )Lora_Transmit_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )Lora_Transmit_TASK_PRIO,
                    (TaskHandle_t*  )&Lora_TransmitTask_Handler);

    xTaskCreate((TaskFunction_t )Su806_transmit_Task,
                    (const char*    )"Su806TransmitTask",
                    (uint16_t       )Su806_Transmit_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )Su806_Transmit_TASK_PRIO,
                    (TaskHandle_t*  )&Su806_TransmitTask_Handler);

    xTaskCreate((TaskFunction_t )HostMcu_transmit_Task,
                    (const char*    )"HostMcuTransmitTask",
                    (uint16_t       )HostMcu_Transmit_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )HostMcu_Transmit_TASK_PRIO,
                    (TaskHandle_t*  )&HostMcu_TransmitTask_Handler);

    xTaskCreate((TaskFunction_t )hostFreeMemory_Task,
                    (const char*    )"hostFreeMemoryTask",
                    (uint16_t       )hostFreeMemory_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )hostFreeMemory_TASK_PRIO,
                    (TaskHandle_t*  )&hostFreeMemory_Handler);

    xTaskCreate((TaskFunction_t )hostMcuDataParse_Task,
                    (const char*    )"hostMcuDataTask",
                    (uint16_t       )hostMcuDataParse_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )hostMcuDataParse_TASK_PRIO,
                    (TaskHandle_t*  )&hostMcuDataParse_Handler);

    xTaskCreate((TaskFunction_t )hostSensorDataParse_Task,
                    (const char*    )"hostSensorDataTask",
                    (uint16_t       )hostSensorDataParse_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )hostSensorDataParse_TASK_PRIO,
                    (TaskHandle_t*  )&hostSensorDataParse_Handler);

    xTaskCreate((TaskFunction_t )hostRecvSlaveDataParse_Task,
                    (const char*    )"hostRecvSlaveDataTask",
                    (uint16_t       )hostRecvSlaveDataParse_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )hostRecvSlaveDataParse_TASK_PRIO,
                    (TaskHandle_t*  )&hostRecvSlaveDataParse_Handler);

    xTaskCreate((TaskFunction_t )dataCollection_Task,
                    (const char*    )"dataCollectionTask",
                    (uint16_t       )dataCollection_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )dataCollection_TASK_PRIO,
                    (TaskHandle_t*  )&dataCollection_Handler);

    xTaskCreate((TaskFunction_t )hostOther_Task,
                    (const char*    )"hostOtherTask",
                    (uint16_t       )hostOther_STK_SIZE,
                    (void*          )NULL,
                    (UBaseType_t    )hostOther_TASK_PRIO,
                    (TaskHandle_t*  )&hostOther_Handler);

    vTaskStartScheduler();
}