/*******************************************************************************
*
*
* File:        app_tp_transfer.c
* Description  touch I2C/SPI 初始化、以及数据通信
* Version      V0.1
* Date         2021-10-14
* Author       zhanghz
*******************************************************************************/
#include "test_cfg_global.h"
#include "app_tp_transfer.h"
#include "hal_i2c_master.h"
#include "hal_i2c_slave.h"
#include "hal_spi_master.h"
#include "hal_spi_slave.h"
#include "tau_log.h"
#include "tau_delay.h"
#include "stdio.h"
#include "hal_system.h"
#ifdef BUFFER_SIZE_MAX

static uint8_t s_screen_read_buffer[BUFFER_SIZE_MAX];
static uint8_t s_phone_read_buffer[BUFFER_SIZE_MAX];

static const uint8_t *s_slave_txbuffer = NULL;
static size_t s_slave_txbuffer_size = 0;

static bool    s_spim_write = false;                   //记录SPI主机是否配置发送，是的话需要清除RXFIFO
static bool    s_screen_int_flag = false;              //记录是否接收到屏幕的报点中断
static bool    s_phone_reset_flag = false;             //记录是否接收到手机的开机复位信号
static bool    s_screen_int_transfer_status = false;   //记录是否已经开始通信
static bool    s_screen_init_complate = true;          //屏幕TP开机初始化完成标志,初始值为true，确保app_tp_transfer_screen_start之后才配置开机初始化
static uint8_t s_screen_const_transfer_count = 0xff;   //记录当前通信到哪一步,初始值必须大于 screen_reg_start_data_size

static void app_tp_transfer_phone(i2c_index_e index, size_t recieve_num);
static void app_tp_reset_callback(void *data);
#if PHONE_SLAVE_TRANSFER_I2C                           //消除warning
static void app_tp_i2cs_callback(i2c_index_e index, hal_i2cs_event_e int_status, size_t recieve_num);
#endif
#if PHONE_SLAVE_TRANSFER_SPI                           //消除warning
static void app_tp_spis_callback(hal_spis_event_e event, hal_spis_packet_info_t *packet_info);
#endif


/**************************************************************************
* @name : app_tp_screen_int_callback
* @brief : screen 报点中断 回调函数
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void app_tp_screen_int_callback(void *data)
{
    s_screen_int_flag = true;
}

/**************************************************************************
* @name : app_tp_screen_int_lvl_low
* @brief : 获取 screen 报点中断 IO 电平
* @param[in] :
* @return : true：IO 为低电平
* @retval :
**************************************************************************/
static bool app_tp_screen_int_lvl_low(void)
{
#if SCREEN_INT_LOW_DEFAULT
    return hal_gpio_get_input_data(g_screen_input_int_pad);     //INT 为高电平时，说明还有报点数据没读出
#else
    return !hal_gpio_get_input_data(g_screen_input_int_pad);    //INT 为低电平时，说明还有报点数据没读出
#endif
}

/**************************************************************************
* @name : app_tp_screen_int_init
* @brief : screen 报点中断 IO 初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void app_tp_screen_int_init(void)
{
    hal_gpio_ctrl_eint(g_screen_input_int_pad, false);                      // 1.关闭中断
#if SCREEN_INT_LOW_DEFAULT
    hal_gpio_set_pull_state(g_screen_input_int_pad, false, true);         // 2.配置下拉
    hal_gpio_init_eint(g_screen_input_int_pad, DETECT_RISING_EDGE);           // 3.中断初始化,INT 上升沿触发中断
#else
    hal_gpio_set_pull_state(g_screen_input_int_pad, true, false);         // 2.配置上拉
    hal_gpio_init_eint(g_screen_input_int_pad, DETECT_FALLING_EDGE);          // 3.中断初始化,INT 下降沿触发中断
#endif
    hal_gpio_reg_eint_cb(g_screen_input_int_pad, app_tp_screen_int_callback); // 4.注册回调
    hal_gpio_ctrl_eint(g_screen_input_int_pad, true);                       // 5.使能中断
}

/**************************************************************************
* @name : app_tp_phone_reset_init
* @brief : phone reset 中断 IO 初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void app_tp_phone_reset_init(void)
{
    /*0.配置为输入*/
    hal_gpio_init_input(g_phone_input_rst_pad);
    /*1.关闭中断*/
    hal_gpio_ctrl_eint(g_phone_input_rst_pad, false);
    /*2.中断初始化*/
    hal_gpio_init_eint(g_phone_input_rst_pad, DETECT_RISING_EDGE);
    /*3.注册回调*/
    hal_gpio_reg_eint_cb(g_phone_input_rst_pad, app_tp_reset_callback);
    /*4.使能中断*/
    hal_gpio_ctrl_eint(g_phone_input_rst_pad, true);
}

/**************************************************************************
* @name : app_tp_screen_init
* @brief : screen IO 跳变，开始初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
void app_tp_screen_init(void)
{
    hal_gpio_init_output(g_screen_input_rst_pad, IO_LVL_HIGH);
    delayUs(200);
    hal_gpio_set_output_data(g_screen_input_rst_pad, IO_LVL_LOW);
    delayUs(200);
    hal_gpio_set_output_data(g_screen_input_rst_pad, IO_LVL_HIGH);
    delayUs(400);
}

#if SCREEN_MASTER_TRANSFER_I2C
/**************************************************************************
* @name : screen_i2cm_io_init
* @brief : screen通信的i2cm IO初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void screen_i2cm_io_init(void)
{
    io_pad_attr_t attrs[] =
    {
        {IO_PAD_TD_SPIM_CLK, PIN5_MODE_I2C1_SCL, IO_IOE_NONE, IO_LVL_HIGH},
        {IO_PAD_TD_SPIM_CSN, PIN6_MODE_I2C1_SDA, IO_IOE_NONE, IO_LVL_HIGH}
    };
    uint8_t size = sizeof(attrs) / sizeof(io_pad_attr_t);
    hal_gpio_config_pad(attrs, size);
}
#endif

#if PHONE_SLAVE_TRANSFER_I2C
/**************************************************************************
* @name : phone_i2cs_io_init
* @brief : phonet通信的i2cs IO初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void phone_i2cs_io_init(void)
{
    io_pad_attr_t attrs[] =
    {
        {IO_PAD_AP_SPIS_CLK, PIN32_MODE_I2C02_SCL, IO_IOE_NONE, IO_LVL_HIGH},
        {IO_PAD_AP_SPIS_CSN, PIN31_MODE_I2C02_SDA, IO_IOE_NONE, IO_LVL_HIGH}
    };
    uint8_t size = sizeof(attrs) / sizeof(io_pad_attr_t);
    hal_gpio_config_pad(attrs, size);
}
#endif


#if SCREEN_MASTER_TRANSFER_SPI
/**************************************************************************
* @name : screen_spim_io_init
* @brief : screen通信的spim IO初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void screen_spim_io_init(void)
{
    io_pad_attr_t attrs[] =
    {
        {IO_PAD_TD_SPIM_CLK, PIN5_MODE_SPIM_SCLK, IO_IOE_NONE, IO_LVL_HIGH},
        {IO_PAD_TD_SPIM_CSN, PIN6_MODE_SPIM_CSN, IO_IOE_NONE, IO_LVL_HIGH},
        {IO_PAD_TD_SPIM_MISO, PIN7_MODE_SPIM_MISO, IO_IOE_NONE, IO_LVL_HIGH},
        {IO_PAD_TD_SPIM_MOSI, PIN4_MODE_SPIM_MOSI, IO_IOE_NONE, IO_LVL_HIGH}
    };
    uint8_t size = sizeof(attrs) / sizeof(io_pad_attr_t);
    hal_gpio_config_pad(attrs, size);
}
#endif

#if PHONE_SLAVE_TRANSFER_SPI
/**************************************************************************
* @name : screen_spis_io_init
* @brief : phone通信的spis IO初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void phone_spis_io_init(void)
{
    io_pad_attr_t attrs[] =
    {
        {IO_PAD_AP_SPIS_CLK, PIN32_MODE_SPIS_SCLK, IO_IOE_NONE, IO_LVL_HIGH},
        {IO_PAD_AP_SPIS_CSN, PIN31_MODE_SPIS_CSN, IO_IOE_NONE, IO_LVL_HIGH},
        {IO_PAD_AP_SPIS_MISO, PIN30_MODE_SPIS_MISO, IO_IOE_NONE, IO_LVL_HIGH},
        {IO_PAD_AP_SPIS_MOSI, PIN33_MODE_SPIS_MOSI, IO_IOE_NONE, IO_LVL_HIGH}
    };
    uint8_t size = sizeof(attrs) / sizeof(io_pad_attr_t);
    hal_gpio_config_pad(attrs, size);
}
#endif


/**************************************************************************
* @name : app_tp_init
* @brief : 初始化通信相关
* @param[in] :
* @return :
* @retval :
**************************************************************************/
void app_tp_init(void)
{
#if _DEMO_IPHONE_X_EN
    app_tp_phone_data_init();
#endif
    app_tp_phone_reset_init();                                        //初始化手机复位的IO口
    app_tp_screen_int_init();                                         //配置screen中断输入引脚
    hal_gpio_init_output(g_phone_output_int_pad, IO_LVL_HIGH);        //配置phone报点输出中断IO口

#if SCREEN_MASTER_TRANSFER_I2C
    screen_i2cm_io_init();
    hal_i2cm_init(SCREEN_I2CM_INDEX, SCREEN_I2C_ADDRESS, SCREEN_I2C_ADDR_BITS, I2C_MASTER_SPEED);
#elif SCREEN_MASTER_TRANSFER_SPI
    screen_spim_io_init();
    hal_spim_init(SPI_MASTER_SPEED, SCREEN_SPI_CPHA, SCREEN_SPI_CPOL);
#endif

#if PHONE_SLAVE_TRANSFER_I2C
    phone_i2cs_io_init();
    hal_i2cs_init(PHONE_I2CS_INDEX, CHIP_I2C_ADDRESS, CHIP_I2C_ADDR_BITS);
    hal_i2cs_register_callback(PHONE_I2CS_INDEX, app_tp_i2cs_callback);
    hal_i2cs_update_rx_buffer(PHONE_I2CS_INDEX, s_phone_read_buffer, BUFFER_SIZE_MAX);
    hal_i2cs_update_tx_buffer(PHONE_I2CS_INDEX, phone_reg_const_data[0].write_back, phone_reg_const_data[0].write_back_size, false);
    hal_i2cs_start(PHONE_I2CS_INDEX);
#elif PHONE_SLAVE_TRANSFER_SPI
    phone_spis_io_init();
    hal_spis_init(PHONE_SPI_CPHA, PHONE_SPI_CPOL);                                   // 初始化spis
    hal_spis_update_rx_buffer(s_phone_read_buffer, BUFFER_SIZE_MAX);                 // 设置auto   rx buffer
    hal_spis_update_tx_buffer(phone_reg_const_data[0].write_back, phone_reg_const_data[0].write_back_size, false);   // 配置TX BUFFER
    hal_spis_register_callback(app_tp_spis_callback, SPIS_EVENT_RCV_FULL | SPIS_EVENT_RCV_CS_RISE, 0);               // 注册回调
    hal_spis_start();                              // 启动tx自动发送
#endif
}

/**************************************************************************
* @name : app_tp_m_transfer_complate
* @brief : 获取主机通信完成状态
* @param[in] :
* @return :true: 通信完成
* @retval :
**************************************************************************/
bool app_tp_m_transfer_complate(void)
{
#if SCREEN_MASTER_TRANSFER_I2C
    return hal_i2cm_get_transfer_complete(SCREEN_I2CM_INDEX);
#elif SCREEN_MASTER_TRANSFER_SPI
    return hal_spim_get_transfer_complete();
#else
    return true;
#endif
}

#if 0
/**************************************************************************
* @name : app_tp_s_transfer_complate
* @brief : 获取从机通信完成状态
* @param[in] :
* @return :true: 通信完成
* @retval :
**************************************************************************/
bool app_tp_s_transfer_complate(void)
{
#if PHONE_SLAVE_TRANSFER_I2C
    return hal_i2c_s_write_complate() && hal_i2c_s_read_complate();
#elif PHONE_SLAVE_TRANSFER_SPI
    return !hal_spis_busy();
#else
    return true;
#endif
}
#endif

/**************************************************************************
* @name : app_tp_m_write
* @brief : 根据通信方式配置发送txbuffer中的数据
* @param[in] :txbuffer: 发送数据 buffer 头地址
* @param[in] :buffer_size: 发送数据 buffer 长度
* @return :
* @retval :
**************************************************************************/
static void app_tp_m_write(const uint8_t *txbuffer, size_t buffer_size)
{
#if SCREEN_MASTER_TRANSFER_I2C
    hal_i2cm_dma_write(SCREEN_I2CM_INDEX, txbuffer, buffer_size);
#elif SCREEN_MASTER_TRANSFER_SPI
    hal_spim_write(txbuffer, buffer_size);
    s_spim_write = true;
#endif
}

/**************************************************************************
* @name : app_tp_m_read
* @brief : 根据通信方式配置发送txbuffer中的数据和rxbuffer
* @param[in] :cmd: 发送命令 buffer 头地址
* @param[in] :cmd_size: 发送命令 buffer 长度
* @param[in] :data_buffer: 读取数据 buffer 头地址
* @param[in] :data_size: 读取数据 buffer 长度
* @return :
* @retval :
**************************************************************************/
static void app_tp_m_read(const uint8_t *cmd, size_t cmd_size, uint8_t *data_buffer, size_t data_size)
{
#if SCREEN_MASTER_TRANSFER_I2C
    uint8_t i = 0;
    uint32_t address = 0;

    for (i = 0; i < cmd_size; i++)                          //先将要发送的数据整合到 address
    {
        address |= (uint32_t)cmd[i] << i * 8;
    }
    hal_i2cm_dma_read(SCREEN_I2CM_INDEX, address, cmd_size, data_buffer, data_size);
#elif SCREEN_MASTER_TRANSFER_SPI
    hal_spim_read(cmd, cmd_size, data_buffer, data_size);
#endif
}

/**************************************************************************
* @name : app_tp_s_write
* @brief : 根据通信方式配置发送txbuffer中的数据
* @param[in] :txbuffer: 发送数据 buffer 头地址
* @param[in] :buffer_size: 发送数据 buffer 长度
* @return :
* @retval :
**************************************************************************/
void app_tp_s_write(i2c_index_e index, const uint8_t *txbuffer, size_t buffer_size)
{
#if PHONE_SLAVE_TRANSFER_I2C
    hal_i2cs_update_tx_buffer(index, txbuffer, buffer_size, true);
#elif PHONE_SLAVE_TRANSFER_SPI
    hal_spis_update_rx_buffer(s_phone_read_buffer, BUFFER_SIZE_MAX);
    hal_spis_update_tx_buffer(txbuffer, buffer_size, true);
    app_tp_write_other_operations(txbuffer, buffer_size);
#endif
}

/**************************************************************************
* @name : app_tp_s_read
* @brief : 根据通信方式配置rxbuffer
* @param[in] :rxBuffer: 读取数据 buffer 头地址
* @param[in] :data_size: 读取数据 buffer 长度
* @return :
* @retval :
**************************************************************************/
void app_tp_s_read(i2c_index_e index, void *rxBuffer, size_t data_size)
{
#if PHONE_SLAVE_TRANSFER_I2C
    hal_i2cs_update_rx_buffer(index, rxBuffer, data_size);
#endif
}

/**************************************************************************
* @name : app_tp_spis_callback
* @brief : SPI slave 中断处理函数
* @param[in] :
* @return :
* @retval :
**************************************************************************/
#if PHONE_SLAVE_TRANSFER_I2C                //消除warning
static void app_tp_i2cs_callback(i2c_index_e index, hal_i2cs_event_e int_status, size_t recieve_num)
{
    static bool i2cs_transfer = true;       //确保一次通信只解析一次
    if (i2cs_transfer)
    {
        i2cs_transfer = false;
        app_tp_transfer_phone(index, recieve_num);
    }
    if (int_status == I2CS_EVENT_READ)
    {
        app_tp_s_write(index, s_slave_txbuffer, s_slave_txbuffer_size);
    }
    else if (int_status == I2CS_EVENT_STOP)
    {
        i2cs_transfer = true;
    }
}
#endif

/**************************************************************************
* @name : app_tp_spis_callback
* @brief : SPI slave 中断处理函数
* @param[in] :
* @return :
* @retval :
**************************************************************************/
#if PHONE_SLAVE_TRANSFER_SPI                //消除warning
static void app_tp_spis_callback(hal_spis_event_e event, hal_spis_packet_info_t *packet_info)
{
    static bool spis_transfer = true;       //确保一次通信只解析一次

    // 1. 接收完数据, 完成一次解析??
    if (spis_transfer)
    {
        app_tp_transfer_phone(0, packet_info->packet_size);
        spis_transfer = false;
    }

    // 2.一帧通信结束, 需要重新设置 txbuffer
    if (event == SPIS_EVENT_RCV_CS_RISE)
    {
        spis_transfer = true;
        if (s_slave_txbuffer_size)
        {
            app_tp_s_write(0, s_slave_txbuffer, s_slave_txbuffer_size);
        }
    }
}
#endif

/**************************************************************************
* @name : app_tp_reset_callback
* @brief : 手机 IO跳变复位的中断处理函数
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void app_tp_reset_callback(void *data)
{
    s_phone_reset_flag = true;
    //app_tp_s_write(phone_reg_const_data[0].write_back, phone_reg_const_data[0].write_back_size);    ///////S8 s8p

#if PHONE_SLAVE_TRANSFER_SPI
    hal_gpio_set_output_data(IO_PAD_AP_INT, IO_LVL_LOW);
#endif
    //TAU_LOGD("app_tp_reset_callback\n");
}

/**************************************************************************
* @name : app_tp_transfer_screen_const
* @brief : 按照flow读写screen，完成 开机 screen 初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
static void app_tp_transfer_screen_const(void)
{
    static bool    screen_const_transfer_buffer_ready = true;            //发送 buffer 是否已准备好

    /**** 1. 判断当前状态通信已结束, 并且开机初始化流程还未走完****/
    if (app_tp_m_transfer_complate() && (s_screen_const_transfer_count < screen_reg_start_data_size))
    {
        if (s_spim_write)                                                //SPI 写数据后需要把接收FIFO的数据读出，不然会影响下一次读取
        {
            hal_spim_flush();
            s_spim_write = false;
        }

        /**** 2. 发送或读取从机数据 ****/
        if (screen_const_transfer_buffer_ready)
        {
            screen_const_transfer_buffer_ready = false;
            if (screen_reg_start_data[s_screen_const_transfer_count].buffer)
            {
                if (!screen_reg_start_data[s_screen_const_transfer_count].read_flag)     //当前通信不需要读回，直接写
                {
                    app_tp_m_write(screen_reg_start_data[s_screen_const_transfer_count].buffer, screen_reg_start_data[s_screen_const_transfer_count].txbuffer_size);
                }
                else                                                             //当前通信需要读回，先写再读
                {
                    app_tp_m_read(screen_reg_start_data[s_screen_const_transfer_count].buffer, screen_reg_start_data[s_screen_const_transfer_count].txbuffer_size, \
                                  s_screen_read_buffer, screen_reg_start_data[s_screen_const_transfer_count].rxbuffer_size);
                }
            }
        }
        /**** 3. 解析本次通信数据，并准备下一次通信的buffer ****/
        else
        {
            screen_const_transfer_buffer_ready = true;
            s_screen_const_transfer_count = app_tp_screen_analysis_const(s_screen_const_transfer_count, s_screen_read_buffer, \
                                            screen_reg_start_data[s_screen_const_transfer_count].rxbuffer_size);

            if (s_screen_const_transfer_count >= screen_reg_start_data_size)
            {
                s_screen_init_complate = true;
            }
        }
    }
}

/**************************************************************************
* @name : app_tp_transfer_screen_start
* @brief : 按照flow读写screen，开始开机初始化
* @param[in] :
* @return :
* @retval :
**************************************************************************/
void app_tp_transfer_screen_start(void)
{
    s_screen_init_complate = false;
    s_screen_const_transfer_count = 0;
    app_tp_screen_init();
    app_tp_transfer_screen_const();
}

/**************************************************************************
* @name : app_tp_transfer_screen_int
* @brief : 接收screen中断后，按照flow读写screen，即报点协议转换 注意接口实现不可阻塞!
* @param[in] :
* @return :
* @retval :
**************************************************************************/
void app_tp_transfer_screen_int(void)
{
    bool screen_gpio_int = false;
    static uint8_t screen_int_transfer_count = 0;            //记录当前通信到哪一步
    static bool    screen_int_transfer_buffer_ready = true;  //发送 buffer 是否已准备好
    volatile bool init_gpio = false;
    static bool Release_all_fingers = false;
    static volatile uint32_t current_time = 0;
    static volatile uint32_t back_time = 0;
    if (!s_screen_init_complate)                             //TP 初始化还未完成，则先进行初始化操作
    {
        app_tp_transfer_screen_const();
        return;
    }

    /**** 1. 判断 screen 是否发出中断信号 ****/
    // s_screen_int_flag:           中断信号标志位
    // app_tp_screen_int_lvl_low :  SPI 长时间通信时，偶尔会出现cs拉高导致通信异常卡死，该标志位用于解决卡死的问题
    init_gpio = app_tp_screen_int_lvl_low();
    screen_gpio_int = (s_screen_int_flag || init_gpio);
    if (((screen_gpio_int) || (s_screen_int_transfer_status)) && app_tp_m_transfer_complate()) //判断当前不处于通信状态，并且准备通信
    {
        s_screen_int_flag = false;
        if (s_spim_write)                                    //SPI 写数据后需要把接收FIFO的数据读出，不然会影响下一次读取
        {
            hal_spim_flush();
            s_spim_write = false;
        }

        /**** 2. 发送或读取从机数据 ****/
        if (screen_int_transfer_buffer_ready)
        {
            screen_int_transfer_buffer_ready = false;
            s_screen_int_transfer_status = true;
            if (!screen_reg_int_data[screen_int_transfer_count].read_flag)  //当前通信不需要读回，直接写
            {
                app_tp_m_write(screen_reg_int_data[screen_int_transfer_count].buffer, screen_reg_int_data[screen_int_transfer_count].txbuffer_size);
            }
            else                                                            //当前通信需要读回，先写再读
            {
                app_tp_m_read(screen_reg_int_data[screen_int_transfer_count].buffer, screen_reg_int_data[screen_int_transfer_count].txbuffer_size, \
                              s_screen_read_buffer, screen_reg_int_data[screen_int_transfer_count].rxbuffer_size);
            }
        }
        /**** 3. 解析本次通信数据，并准备下一次通信的buffer ****/
        else
        {
            screen_int_transfer_buffer_ready = true;
            screen_int_transfer_count = app_tp_screen_analysis_int(screen_int_transfer_count, s_screen_read_buffer, \
                                        screen_reg_int_data[screen_int_transfer_count].rxbuffer_size);
            Release_all_fingers = true;
            back_time = hal_system_get_tick();
            if (screen_int_transfer_count >= screen_reg_int_data_size)       //解析需要等最后一次通信结束，最后一次数据解析后，停止通信
            {
                screen_int_transfer_count = 0;
                s_screen_int_transfer_status = false;
                return;
            }
        }
    }
#if _DEMO_S8_EN
    else
    {
        current_time = hal_system_get_tick();
        if (((current_time - back_time) > 800) && Release_all_fingers)
        {
            app_tp_write_other_operations(s_screen_read_buffer, 8);
            Release_all_fingers = false;
        }
    }
#endif
}

/**************************************************************************
* @name : app_tp_transfer_phone
* @brief : 根据数据解析进行相应的答复
* @param[in] : recieve_num：接收数据长度
* @return :
* @retval :
**************************************************************************/
static void app_tp_transfer_phone(i2c_index_e index, size_t recieve_num)
{
    /* 数据解析，判断是否需要答复以及答复的buffer指针 */
    if (recieve_num > 0)
    {
        app_tp_phone_analysis_data(s_phone_read_buffer, recieve_num, &s_slave_txbuffer, &s_slave_txbuffer_size);
    }

    app_tp_s_read(index, s_phone_read_buffer, BUFFER_SIZE_MAX);
}

/**************************************************************************
* @name : app_tp_phone_reset_on
* @brief : 获取手机复位信号的状态
* @param[in] :
* @return :
* @retval :
**************************************************************************/
bool app_tp_phone_reset_on(void)
{
    return s_phone_reset_flag;
}

/**************************************************************************
* @name : app_tp_phone_clear_reset_on
* @brief : 清除手机复位信号的状态
* @param[in] :
* @return :
* @retval :
**************************************************************************/
void app_tp_phone_clear_reset_on(void)
{
    s_phone_reset_flag = false;
}

#else

void app_tp_screen_init(void)
{

}

void app_tp_init(void)
{

}

void app_tp_transfer_screen_int(void)
{

}

void app_tp_transfer_screen_start(void)
{

}

bool app_tp_phone_reset_on(void)
{
    return false;
}

void app_tp_phone_clear_reset_on(void)
{

}

void app_tp_s_write(i2c_index_e index, const uint8_t *txbuffer, size_t buffer_size)
{

}

#endif

