/* FreeRTOS hearder */
#include "thread.h"
#include "uart.h"
#include "nrf_delay.h"

/**************************** task handler ********************************/
/* 
 * create task handler
 * if operate self , value can be NULL。
 * 
 */
// static TaskHandle_t AppTaskCreate_Handle;

TaskHandle_t RunTimeStats_Task_Handle;
TaskHandle_t Uart_Task_Handle;

/********************************** core handler *********************************/
/*
 * sem，queue，event，timer...
 * 
 */


/******************************* Global variable ************************************/
/*
 * Global variable
 */

/******************************* Macro Define ***************************************/
/*
 * Macro Define
 */
/*
****************************************************************************
*                              task name
*****************************************************************************
*/
#define RunTimeStatsTaskName                             "RunTimeStatsTask"
#define Uart_TaskName                                    "Uart_Task"

/*
****************************************************************************
*                               size
*****************************************************************************
*/
#define RunTimeStatsTaskSize                                      ( 128 )
#define Uart_TaskSize                                             ( 1024 )

/*
****************************************************************************
*                               prio
*****************************************************************************
*/
/*
MAX prio in FreeRTOS

#define configMAX_PRIORITIES                                                      ( 7 )
*/

#define RunTimeStatsTaskPrio                                      ( 3 )
#define Uart_TaskPrio                                             ( 5 )

/*
*****************************************************************************
*                              handler
*****************************************************************************
*/

extern TaskHandle_t RunTimeStats_Task_Handle;                        // Run state
extern TaskHandle_t Uart_Task_Handle;                                // Uart

/*
*************************************************************************
*                             Funtion
*************************************************************************

 /**********************************************************************
  * @ Fun  ： RunTimeStatsTask
  * @ param   ：   
  * @ retval  ： null
  ********************************************************************/

void RunTimeStatsTask(void)
{
    while(1)
    {
        int val;
        SEGGER_RTT_printf(0, "TaskName\t\t\t\tPrio\t\t\t\tStackSize");
        val = uxTaskGetStackHighWaterMark(Uart_Task_Handle);
        SEGGER_RTT_printf(0, "%s\t\t\t\t%d\t\t\t\t%d", Uart_TaskName, Uart_TaskPrio, val);
        vTaskDelay(10000);
    }
}

/**********************************************************************
  * @ Fun  ： Uart_task test
  * @ param   ：   
  * @ retval  ： null
  ********************************************************************/
void Uart_Task(void* parameter)
{
    uart_init();

    while(1)
    {
        uart_main();
        vTaskDelay(2);
    }
}

/*****************************************************************
  * @brief  HardWare_init
  * @param  null
  * @retval null
  * @note   init all hardware
  ****************************************************************/
void HardWare_init(void)
{

}

/*****************************************************************
  * @brief  main
  * @param  null
  * @retval null
  * @note   thread manager main
  ****************************************************************/
int thread_main(void)
{
    BaseType_t xReturn = pdPASS;
    int size = 0;

    HardWare_init();

    taskENTER_CRITICAL();

    xReturn = xTaskCreate((TaskFunction_t )Uart_Task,                 // enter fun
                        (const char*    )Uart_TaskName,               // name
                        (uint16_t       )Uart_TaskSize,               // size
                        (void*          )NULL,                        // enter param
                        (UBaseType_t    )Uart_TaskPrio,               // prio
                        (TaskHandle_t*  )&Uart_Task_Handle);          // task handle 

    SEGGER_RTT_printf(0, " xTaskCreate Uart_Task = %d\r\n", xReturn);
    if(pdPASS == xReturn)
        SEGGER_RTT_printf(0, "Uart_Task Create Done!\r\n");

    size = xPortGetFreeHeapSize();
    SEGGER_RTT_printf(0, "heap size = %d\r\n", size);

    taskEXIT_CRITICAL();
    if(pdPASS != xReturn)
        return -1;
    return pdPASS;
}