/*!
 * \file      main.c
 *
 * \brief     Target main implementation
 *
 * \copyright Revised BSD License, see section \ref LICENSE.
 *
 * \code
 *
 *            _  __ _       ________    _
 *           | |/ /(_)___  / ____/ /_  (_)___
 *           |   // / __ \/ /   / __ \/ / __ \
 *          /   |/ / / / / /___/ / / / / /_/ /
 *         /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
 *                                   /_/
 *           (C) 2022-2025 XinChip
 *
 * \endcode
 *
 * \author     ( XinChip ) Alex-J
 *
 * \author     ( XinChip )
 */

/*-----------------------------------------------------------------------------------
                                   INCLUDE HEADE FILES
 ------------------------------------------------------------------------------------*/
#include "main.h"

/*------------------------------------------------------------------------------------
                                         Macros
 -------------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------------
                                     Global Variables
 -------------------------------------------------------------------------------------*/
bool rf_send_timer_flag    = false;

/*------------------------------------------------------------------------------------
                                     Func Prototype
 -------------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------------
                                        Functions
 -------------------------------------------------------------------------------------*/
/**
 ****************************************************************************************
 * @brief
 *
 * @param[in]
 * @param[in]
 ****************************************************************************************
 */
void timer_init(uint8_t timer_id, uint32_t timer_cnt)
{
    LOGI("timer_init\r\n");

    uint32_t timerx_us = timer_cnt * 1000;
    Timer_InitCfg_t timer_cfg;

    timer_cfg.timer_src_clk = TIMER_CLK_SRC_32M_DIV;
    timer_cfg.timer_div_clk = TIMER_DIV_CLK_1MHzOr1K;
    timer_cfg.timer_mode    = TIMER_MODE_CYCLE;

    xc_timer_init(timer_id, &timer_cfg);
    xc_timer_set_value(timer_id, timerx_us);
    xc_timer_start(timer_id);
}

/**
 * @brief       timer0_Callback
 * @param       void * - context
 *
 * @retval      void
 */
void timer0_callback(void *context)
{
#if !(XINCX_RF_MODE)
    rf_send_timer_flag = true;
#endif // !(XINCX_RF_MODE)
}

/**
 ****************************************************************************************
 * @brief      Clock Initialization
 *
 * @param[in]
 * @param[in]
 ****************************************************************************************
 */
void clock_init(void)
{
    CLOCK_InitCfg_t clock_cfg;

    clock_cfg.hfclk_src = CLOCK_HFCLK_SRC_XTAL;
    clock_cfg.hfclk_in  = CLOCK_HFCLK_IN_32M;
#if (RC_32K)
    clock_cb.lfclk_src = CLOCK_LFCLK_SRC_RC;
#endif //(RC_32K)

#if (XTAL_32K)
    clock_cb.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
#endif // (XTAL_32K)

#if (XTAL_32768K)
    clock_cb.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
#endif // (XTAL_32768K)

    if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_XTAL) {
        clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32768;
    } else if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_RC) {
        clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32K;
    }

    xc_clock_init_cfg(&clock_cfg);

    SysTick_Config(xc_clock_hfclk_in_get() / 100);
    SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
}

#ifdef DEBUG_LOG
/**
 * @brief       RF 2.4g register information printing
 * @param       void
 * @retval      void
 */
void rf_2M_reg_info(void)
{
    /* Register information printing */
    LOGI("CFG_TOP:       0x%08x\r\n", XC_RF_2_4G->CFG_TOP);
    LOGI("TXPROC_CFG:    0x%08x\r\n", XC_RF_2_4G->TXPROC_CFG);
    LOGI("RXPROC_CFG_L:  0x%08x\r\n", XC_RF_2_4G->RXPROC_CFG_L);
    LOGI("RF_CH:         0x%08x\r\n", XC_RF_2_4G->RF_CH);
    LOGI("rccal_reg_l:   0x%08x\r\n", XC_BT_RF->rccal_reg_l);
    LOGI("ana2_reg_l:    0x%08x\r\n", XC_BT_RF->ana2_reg_l);
    LOGI("ana3_reg_l:    0x%08x\r\n", XC_BT_RF->ana3_reg_l);
    LOGI("ana4_reg_l:    0x%08x\r\n", XC_BT_RF->ana4_reg_l);
    LOGI("ana5_reg_l:    0x%08x\r\n", XC_BT_RF->ana5_reg_l);
    LOGI("ana14_reg_l:   0x%08x\r\n", XC_BT_RF->ana14_reg_l);
    LOGI("ana15_reg_l:   0x%08x\r\n", XC_BT_RF->ana15_reg_l);
    LOGI("ana16_reg_l:   0x%08x\r\n", XC_BT_RF->ana16_reg_l);
    LOGI("ana17_reg_l:   0x%08x\r\n", XC_BT_RF->ana17_reg_l);
    LOGI("ana18_reg_l:   0x%08x\r\n", XC_BT_RF->ana18_reg_l);
    LOGI("ana21_reg_l:   0x%08x\r\n", XC_BT_RF->ana21_reg_l);
    LOGI("AON_RF_AONREG: 0x%08x\r\n", cprao_aon_rf_aonreg_get()); // 0x36
}

/**
 * @brief       Rf 2.4g dump log
 * @param       void
 *
 * @retval      void
 */
void rf_dump_log(void)
{
    LOGI("***************** 2.4G Param ******************\n");
    LOGI("CFG_TOP:       0x%08x\r\n", XC_RF_2_4G->CFG_TOP);
    LOGI("EN_AA:         0x%08x\r\n", XC_RF_2_4G->EN_AA);
    LOGI("EN_RXADDR:     0x%08x\r\n", XC_RF_2_4G->EN_RXADDR);
    LOGI("SETUP_AW:	     0x%08x\r\n", XC_RF_2_4G->SETUP_AW);
    LOGI("SETUP_RETR:    0x%08x\r\n", XC_RF_2_4G->SETUP_RETR);
    LOGI("RF_CH:         0x%08x\r\n", XC_RF_2_4G->RF_CH);
    LOGI("SETUP_RF:      0x%08x\r\n", XC_RF_2_4G->SETUP_RF);
    LOGI("STATUS:        0x%08x\r\n", XC_RF_2_4G->STATUS);
    LOGI("OBSERVE_TX:    0x%08x\r\n", XC_RF_2_4G->OBSERVE_TX);
    LOGI("RSSI:          0x%08x\r\n", XC_RF_2_4G->RSSI);
    LOGI("RX_ADDR_P0:    0x%02x %08x\r\n", 0xFF & (XC_RF_2_4G->RX_ADDR_P0_H), XC_RF_2_4G->RX_ADDR_P0_L);
    LOGI("RX_ADDR_P1:    0x%02x %08x\r\n", 0xFF & (XC_RF_2_4G->RX_ADDR_P1_H), XC_RF_2_4G->RX_ADDR_P1_L);
    LOGI("RX_ADDR_P2TOP5:0x%08x\r\n", XC_RF_2_4G->RX_ADDR_P2TOP5);
    LOGI("BER_RESULT:	 0x%08x%08x\r\n", XC_RF_2_4G->BER_ERR_CNT, XC_RF_2_4G->BER_RECV_CNT);
    LOGI("AGC_SETTING:   0x%08x\r\n", XC_RF_2_4G->AGC_SETTING);
    LOGI("PGA_SETTING:   0x%02x %08x\r\n", ((XC_RF_2_4G->TX_ADDR_H) & 0xFF00) >> 8, XC_RF_2_4G->PGA_SETTING);
    LOGI("TX_ADDR:	     0x%02x %08x\r\n", ((XC_RF_2_4G->TX_ADDR_H) & 0xFF), XC_RF_2_4G->TX_ADDR_L);
    LOGI("RX_PW_PX:	     0x%04x %08x\r\n", 0xFFFF & (XC_RF_2_4G->RX_PW_Px_H), XC_RF_2_4G->RX_PW_Px_L);
    LOGI("STATUS_FIFO:   0x%08x\r\n", XC_RF_2_4G->STATUS_FIFO);
    LOGI("RSSIREC:	     0x%08x\r\n", XC_RF_2_4G->RSSIREC);
    LOGI("TXPROC_CFG:    0x%08x\r\n", XC_RF_2_4G->TXPROC_CFG);
    LOGI("RXPROC_CFG:    0x%02x %08x\r\n", 0xFF & (XC_RF_2_4G->RXPROC_CFG_H), XC_RF_2_4G->RXPROC_CFG_L);
    LOGI("DYNPD:  	     0x%08x\r\n", XC_RF_2_4G->DYNPD);
    LOGI("FEATURE:	     0x%08x\r\n", XC_RF_2_4G->FEATURE);
    LOGI("PGA_SETTING_H: 0x%08x\r\n", XC_RF_2_4G->TX_ADDR_H);
    LOGI("TX_POWER       0x%08x\r\n", (XC_BT_RF->ana21_reg_l >> 6) & 0x3f);
    LOGI("ana11_reg_l:   0x%08x\r\n", XC_BT_RF->ana11_reg_l);
    LOGI("***********************************************\n");
    LOGI("\r\n");
}
#endif // DEBUG_LOG

/**
 * @brief       RF 2.4g data config
 * @param       uint8_t * - buff
 *              uint8    - len
 * @retval      uint8_t - 0
 */
uint8_t rf_data_config(uint8_t *buff, uint8_t len)
{
    if (len == 0) {
        return FAIL;
    }

    for (uint8_t i = 0; i < len; i++) {
        buff[i] = i;
    }
    return SUCCESS;
}

/**
 * @brief       RF 2.4g tx manage
 * @param       rf_data_typedef_t * - rf_data
 * @retval      uint8_t - cnt
 */
uint32_t rf_tx_manage(rf_data_typedef_t *rf_data)
{
    if ((rf_data->cnt < XC_SEND_NUM) && (rf_send_timer_flag)) {
        rf_send_timer_flag  = false;
        rf_data->cnt       += 1;
        /* Filling in software frame number */
        rf_data->buff[0]    = rf_data->cnt;

        LOGI("send_cnt:%d\r\n", rf_data->cnt);

        /* data transmission */
        rf_tx_event(rf_data->buff, rf_data->data_length);
    }
    if (rf_data->cnt == XC_SEND_NUM) {
        rf_data->cnt += 1;
        LOGI("SEND END\r\n");

        /* Turn off the send timer */
        xc_timer_stop(RF_TX_TIMERx);
    }
    return rf_data->cnt;
}

/**
 * @brief       RF 2.4g rx manage
 * @param       rf_data_typedef_t * - rf_data
 * @retval      uint32_t - 0
 */

#if !(XINCX_RF_NVIC_MODE)
uint32_t rf_rx_manage(rf_data_typedef_t *rf_data)
{
    static uint32_t conut = 0;
    /* Receive event processing */
    uint8_t len           = rf_rx_event(rf_data->buff);

    /* Receiving end polling data processing */
    if (len != 0) {
        /* Entering standby mode */
        CE_CTL_LOW;

        /* Receiving data processing */
        if (rf_data->buff[RF_CONFIRMED_VALUE] == RF_CONFIRMED_VALUE) {
            LOGI("%d\r\n", conut);
        }

        rf_buff_info(rf_data->buff, len);
        /* Receive Count */
        conut += 1;

        /* Receive read data buffer reset */
        memset(rf_data->buff, 0, len);
        len = 0;

        /* Entering the receiver */
        CE_CTL_HIGH;
    }
    return 0;
}
#else
uint32_t rf_rx_manage(rf_data_typedef_t *rf_data)
{
    static uint32_t conut = 0;
    uint8_t len           = recv_len;
    if (rf24g_handler_flag) {
        rf24g_handler_flag = false;
        /* Entering standby mode */
        CE_CTL_LOW;

        if ((len != 0) && (recv_buf[RF_CONFIRMED_VALUE] == RF_CONFIRMED_VALUE)) {
            LOGI("%d\r\n", recv_buf[0]);
        }
        //rf_buff_info(recv_buf, len);
        /* Receive Count */
        conut += 1;
        LOGI("recv:%d\r\n", conut);

        /* Receive read data buffer reset */
        memset(recv_buf, 0, len);
        len = 0;

        /* Entering the receiver */
        CE_CTL_HIGH;
    }
    return 0;
}
#endif //!(XINCX_RF_NVIC_MODE)

/**
 * @brief       RF 2.4g buff info
 * @param       uint8_t * - buff
 *              uint8_t len
 * @retval      void
 */
void rf_buff_info(uint8_t *buff, uint8_t len)
{
    for (uint8_t i = 0; i < len; i++)
        LOGI("%02x ", buff[i]);
    LOGI("\r\n");
}

void app_uart_init(void)
{
    GPIO_InitCfg_t gpio_cfg = {0};

    gpio_cfg.Mux            = GPIO_Mux0;
    gpio_cfg.Pull           = GPIO_PULLUP;
    gpio_cfg.Int            = NOT_INT;
    gpio_cfg.FunSel         = UART0_TX;

    gpio_cfg.Pin            = GPIO_18;
    gpio_cfg.Dir            = GPIO_DIR_OUTPUT;
    xc_gpio_init(&gpio_cfg);

    gpio_cfg.FunSel = UART0_RX;
    gpio_cfg.Pin    = GPIO_19;
    gpio_cfg.Dir    = GPIO_DIR_INPUT;
    xc_gpio_init(&gpio_cfg);

    UART_InitCfg_t uart_cfg      = {0};

    uart_cfg.Parity              = UART_PARITY_DISABLE;
    uart_cfg.StopBits            = UART_STOP_1_BITS;
    uart_cfg.WordLength          = UART_DATA_8_BITS;
    uart_cfg.BaudRate            = UART_BAUDRATE_115200;
    uart_cfg.HardwareFlowControl = UART_HWFC_DISABLE;

    xc_uart_init(UART0_IDX, &uart_cfg);
}

/**
 * @brief       main
 * @details
 * @param[in]   void
 * @param[out]  void
 * @retval      int - 0
 * @retval      void
 * @par identifier
 *              reserve
 * @par other
 *              void
 * @par change log
 *              Alex created on 2023-05-31
 */
int main(void)
{
    rf_data_typedef_t rf_data_t;
    /* TX data packaging filling */
    rf_data_config(rf_data_t.buff, sizeof(rf_data_t.buff));
    rf_data_t.cnt  = 0;
    rf_data_t.temp = SEND_TIMERMS_CNT;

    /* Clock initialization */
    clock_init();

    /* Serial port initialization */
    app_uart_init();

    /* rf 2.4g initialization configuration */
    rf24g_init();

    /* Set testing frequency points */
    rf_set_channel(XINCX_2_4G_CHANNEL);

#if (XINCX_RF_TRANS_RATE == RATE_2M)
    /* Set 2M mode register configuration */
    /* Don't move this function interface */
    rf_2M_config();
#endif //(XINCX_RF_TRANS_RATE == RATE_2M)

#ifdef DEBUG_LOG
    /* Register information printing */
    rf_dump_log();
#endif // DEBUG_LOG

#if XINCX_RF_MODE
    /* RX enters receiver */
    CE_CTL_HIGH;
#else
    /* Launch data packaging filling */
    rf_data_config(rf_data_t.buff, sizeof(rf_data_t.buff));

    /* Set emission interval */
    timer_init(RF_TX_TIMERx, SEND_TIMERMS_CNT);

#endif // XINCX_RF_MODE
    for (;;) {

#if XINCX_RF_MODE
        /* receive */
        rf_rx_manage(&rf_data_t);
#else

        /* Launch data packaging filling */
        rf_data_config(rf_data_t.buff, sizeof(rf_data_t.buff));

        /* sending */
        rf_data_t.cnt = rf_tx_manage(&rf_data_t);
#endif // XINCX_RF_MODE
    }
}