/**
 * @file app_hart.c
 * @author xxx
 * @date 2023-07-06 13:08:52
 * @brief 此文件主要实现板卡的HART功能
 * @copyright Copyright (c) 2023 by xxx, All Rights Reserved.
 */

#include "app.h"
//#include "hart_frame.h"
#include "uarts.h"
//#include "test_bsp.h"
#include "at_hc24.h"

#define HART_UART1 USART1
#define HART_UART2 UART5

#define UART_RXSIZE (240u) // 接收240个字节
#define UART_TXSIZE (240u) // 发送240个字节
uart_t *uarts[APP_UART_MAX];

app_dynamics_t app_dynamics;
static volatile BOOL hart_idle = TRUE;

/**
 * @brief  蓝牙输出
 * @param {uint8_t} *data
 * @param {uint16_t} len
 * @return {*}
 * @note
 */
static void h24_bluetooth_output(uint8_t *data, uint16_t len)
{
    if (uarts[APP_UART_2] != NULL)
    {
        uart_send_data(uarts[APP_UART_2], data, len);
    }
}

void h24_bluetooth_output_dbg(uint8_t *data, uint16_t len)
{
#if H24_BLE_OUTPUT_DBG == TRUE
    h24_bluetooth_output(data, len);
#endif
}

/**
 * @brief 蓝牙H24模块配置工作
 * @return {*}
 * @note
 */
void h24_bluetooth_work(uint8_t index)
{
    uint8_t len = 0;
    char data[128];
    osel_memset((uint8_t *)data, 0, 128);
#ifdef V4
    char device_id[] = "LP4-???";
#elif V5
    char device_id[] = "LP5-???";
#else
    char device_id[] = "LP3-???";
#endif
    char *test_cmd[AT_END] = {
        "AT",
        "AT+NAME",
        "AT+NAME=%s",
    };
    switch (index)
    {
    case 1:
    {
        hc_24_state = 0;
        sprintf(data, test_cmd[AT_CMD_TEST]);
        len = osel_mstrlen((unsigned char *)data);
        h24_bluetooth_output((uint8_t *)data, len);
        break;
    }

    case 2:
    {
        at_set_memcmp_cache((unsigned char *)device_id, osel_mstrlen((unsigned char *)device_id));
        sprintf(data, test_cmd[AT_CMD_NAME_REQ]);
        len = osel_mstrlen((unsigned char *)data);
        h24_bluetooth_output((uint8_t *)data, len);
        break;
    }

    case 3:
    {
        at_set_memcmp_cache((unsigned char *)device_id, osel_mstrlen((unsigned char *)device_id));
        sprintf(data, test_cmd[AT_CMD_NAME], device_id);
        len = osel_mstrlen((unsigned char *)data);
        h24_bluetooth_output((uint8_t *)data, len);
        break;
    }

    case 4:
    {
        sprintf(data, "%f,%f,%f\r\n", 1.1, 2.2, 3.3);
        len = osel_mstrlen((unsigned char *)data);
        h24_bluetooth_output((uint8_t *)data, len);
        break;
    }
    default:
        break;
    }
}

// 串口1、5接收中断回调函数
static void hart_rx_cb(uint8_t uart_index, uint8_t *data, uint16_t len)
{
    DBG_ASSERT(uart_index < APP_UART_MAX __DBG_LINE);
    hart_idle = FALSE;
    if (len >= 2)
    {
        if (data[0] == 'O' && data[1] == 'K') // 蓝牙协议
        {
            data[0] = 'A';
            data[1] = 'T';
            at_cmd_parse(data, len);
        }
        else
        {

        }
    }
    hart_idle = TRUE;
}

static void hart_tx_complete_cb(void)
{
    // 串口1发送完成回调函数
    HART_RTS_ON();
}

// HART协议的使用的串口 --- 串口1
void hart_uart_init(void)
{
    LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_USART1);
    GPIO_SET_OUTPUT(HART_PWR_GPIO_Port, HART_PWR_Pin);
    GPIO_SET_OUTPUT(HART_RST_GPIO_Port, HART_RST_Pin);
    GPIO_SET_OUTPUT(HART_RTS_GPIO_Port, HART_RTS_Pin);
    GPIO_SET_ALTERNATE(HART_TX_GPIO_Port, HART_TX_Pin);
    GPIO_SET_ALTERNATE(HART_RX_GPIO_Port, HART_RX_Pin);
    LL_mDelay(10);
    // 串口1初始化开始
    HART_RTS_ON();
    HART_RST_OFF();
    LL_mDelay(20);
    HART_RST_ON();
    HART_EN_DISABLE();
    HART_EN_ENABLE();
    HART_RTS_ON();
    if (uarts[APP_UART_1] == NULL)
    {
        LL_mDelay(100);
        uarts[APP_UART_1] = uart_create(HART_UART1, TRUE, UART_RXSIZE, hart_rx_cb, TRUE, UART_TXSIZE, hart_tx_complete_cb);
        uarts[APP_UART_1]->uart_index = APP_UART_1;
        uarts[APP_UART_1]->dma = DMA2;
        uarts[APP_UART_1]->dma_rx_channel = LL_DMA_CHANNEL_7;
        uarts[APP_UART_1]->dma_tx_channel = LL_DMA_CHANNEL_6;
        uart_recv_en(uarts[APP_UART_1]);
    }
    // 串口1初始化结束
}

// HART协议使用的串口，为模拟IO口
void hart_uart_dinit(void)
{
    HART_EN_DISABLE();
    LL_APB2_GRP1_DisableClock(LL_APB2_GRP1_PERIPH_USART1);
    LL_USART_Disable(USART1);
    GPIO_SET_ANALOG(HART_PWR_GPIO_Port, HART_PWR_Pin);
    GPIO_SET_ANALOG(HART_RST_GPIO_Port, HART_RST_Pin);
    GPIO_SET_ANALOG(HART_CD_GPIO_Port, HART_CD_Pin);
    GPIO_SET_ANALOG(HART_TX_GPIO_Port, HART_TX_Pin);
    GPIO_SET_ANALOG(HART_RX_GPIO_Port, HART_RX_Pin);
}

// 蓝牙模块串口初始化
void hart_ble_init(void)
{
    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_UART5);
    GPIO_SET_OUTPUT(BLE_PWR_GPIO_Port, BLE_PWR_Pin);
    GPIO_SET_INPUT(BLE_RST_GPIO_Port, BLE_RST_Pin);
    GPIO_SET_ALTERNATE(BLE_TX_GPIO_Port, BLE_TX_Pin);
    GPIO_SET_ALTERNATE(BLE_RX_GPIO_Port, BLE_RX_Pin);
    BLE_EN_ENABLE();
    if (uarts[APP_UART_2] == NULL)
    {
        LL_mDelay(100);
        uarts[APP_UART_2] = uart_create(HART_UART2, TRUE, UART_RXSIZE, hart_rx_cb, TRUE, UART_TXSIZE, NULL);
        uarts[APP_UART_2]->uart_index = APP_UART_2;
        uarts[APP_UART_2]->dma = DMA2;
        uarts[APP_UART_2]->dma_rx_channel = LL_DMA_CHANNEL_2;
        uarts[APP_UART_2]->dma_tx_channel = LL_DMA_CHANNEL_1;
        uart_recv_en(uarts[APP_UART_2]);
    }
}

// 蓝牙模块端口IO口反初始化
void hart_ble_dinit(void)
{
    // 关闭蓝牙串口
    BLE_EN_DISABLE();
    LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_UART5);
    LL_USART_Disable(UART5);
    // 端口转成模拟IO口
    GPIO_SET_ANALOG(BLE_PWR_GPIO_Port, BLE_PWR_Pin);
    GPIO_SET_ANALOG(BLE_RST_GPIO_Port, BLE_RST_Pin);
    GPIO_SET_ANALOG(BLE_TX_GPIO_Port, BLE_TX_Pin);
    GPIO_SET_ANALOG(BLE_RX_GPIO_Port, BLE_RX_Pin);
}

// 判断是否闲置的结果
BOOL app_hart_is_idle(void)
{
    return hart_idle;
}