diff --git a/device/Inc/wk2114.h b/device/Inc/wk2114.h index a6de103..c17797a 100644 --- a/device/Inc/wk2114.h +++ b/device/Inc/wk2114.h @@ -14,8 +14,16 @@ #include #include "FreeRTOS.h" #include "task.h" -#include "cmsis_os.h" +#include "FreeRTOS.h" +#include "task.h" #include "main.h" +#include "cmsis_os.h" +#include "usart.h" +#include "stm32f4xx.h" +#include "elog.h" + +extern UART_HandleTypeDef *pWK2114Uart; +extern osEventFlagsId_t wk2114EventHandle; #define WK2114_CLOCK_HZ (12000000U) @@ -30,14 +38,78 @@ #define WK2114_REG_IS_GLOBAL(reg) ((reg&0x0f)<=0x02?1:0) #define WK2114_BUILD_SUB_REG(sub_uart,reg) ((sub_uart<<4)|(reg&0x0f)) +typedef enum +{ + MODULE_WK2114_EVENT_READY, + MODULE_WK2114_EVENT_EXTI_IRQ, + MODULE_WK2114_EVENT_EXTI_IDLE, + MODULE_WK2114_EVENT_EXTI_IT_TYPE_SENDING, + MODULE_WK2114_EVENT_EXTI_IT_TYPE_RECEIVED, + MODULE_WK2114_EVENT_EXTI_RCV_FIFO_COUNT_RECEIVED, + MODULE_WK2114_EVENT_EXTI_RCV_FIFO_BUF_RECEIVED, + // WK2114E_WK2114_EVENT_EXTI_READ_FIFO_BY_COUNT, + +} MODULE_WK2114_EVENT_TypeDef; + +typedef enum +{ + WK2114_WORK_STATE_WAIT, + WK2114_WORK_STATE_START, + WK2114_WORK_STATE_SET_BAUD, + WK2114_WORK_STATE_SET_BAUD_OK, + WK2114_WORK_STATE_SEND_40_RCV_F0, + WK2114_WORK_STATE_SEND_40_RCV_F0_OK, + WK2114_WORK_TEST_OK, + + WK2114_WORK_STATE_ADD_SUB_UART, + WK2114_WORK_STATE_ADD_SUB_UART_OK, + WK2114_WORK_STATE_OK, + + WK2114_WORK_STATE_IT_SOURCE_GETTING, + WK2114_WORK_STATE_IT_TYPE_GETTING, + + + WK2114_WORK_STATE_PROCESS_IT_TYPE, + WK2114_WORK_STATE_EXTI_IT_SOURCE_GETTING, + WK2114_WORK_STATE_EXTI_IT_SOURCE_RECEIVE, + WK2114_WORK_STATE_EXTI_IT_TYPE_GETTING, + WK2114_WORK_STATE_EXTI_IT_TYPE_RECEIVE, + WK2114_WORK_STATE_EXTI_PROCESS, + WK2114_WORK_STATE_EXTI_PROCESS_RFTRIG_INT, + WK2114_WORK_STATE_EXTI_PROCESS_RXOVT_INT, + WK2114_WORK_STATE_EXTI_PROCESS_TFTRIG_INT, + WK2114_WORK_STATE_EXTI_PROCESS_TFEMPTY_INT, + WK2114_WORK_STATE_EXTI_PROCESS_FERR_INT, + + WK2114_WORK_STATE_EXTI_PROCESS_GET_FIFO_COUNT, + WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT, + WK2114_WORK_STATE_EXTI_DEAL_FIFO_READOUT, + // WK2114_WORK_STATE_EXTI_READ_FIFO_DEAL, + + WK2114_WORK_STATE_EXTI_READ_SUB_FSR, + WK2114_WORK_STATE_EXTI_READ_SUB_LSR, + WK2114_WORK_STATE_EXTI_DEAL_LSR, + WK2114_WORK_STATE_EXTI_READ_REG, + + WK2114_WORK_STATE_ERROR, + WK2114_WORK_STATE_STOP +} WK2114_WORK_STATE_TypeDef; + +typedef enum +{ + WK2114_G_FLAG_MASK_BUSY_RCV = (1<<0), //< wk2114标志位 正在等待接收 + WK2114_G_FLAG_MASK_INTER = (1<<1), //< wk2114标志位 正在处理中断 + WK2114_G_FLAG_MASK_SENDING = (1<<2), //< wk2114标志位 正在发送 +} WK2114_G_FLAG_TypeDef; + #define WK2114_S_UART_FLAG_MASK_IDLE (1<<0) //< 子串口标志位 接收到串口空闲中断 #define WK2114_S_UART_FLAG_MASK_PAGE (1<<1) //< 子串口标志位 设置的寄存器页 -#define WK2114_S_UART_FLAG_MASK_PAGE_D (1<<2) //< 子串口标志位 当前寄存器页 +#define WK2114_S_UART_FLAG_MASK_PAGE_D (1<<2) //< 子串口标志位 当前寄存器页, 0->pahg0 ,1-page1 #define WK2114_S_UART_FLAG_MASK_ENABLE (1<<3) //< 子串口标志位 使能 -#define WK2114_G_FLAG_MASK_BUSY (1<<0) //< wk2114标志位 正在等待接收 -#define WK2114_G_FLAG_MASK_INTER (1<<1) //< wk2114标志位 正在处理中断 -#define WK2114_G_FLAG_MASK_SENDING (1<<2) //< wk2114标志位 正在发送 +// #define WK2114_G_FLAG_MASK_BUSY_RCV (1<<0) //< wk2114标志位 正在等待接收 +// #define WK2114_G_FLAG_MASK_INTER (1<<1) //< wk2114标志位 正在处理中断 +// #define WK2114_G_FLAG_MASK_SENDING (1<<2) //< wk2114标志位 正在发送 #define WK2114_G_REG_GIFR_MASK_UT1INT (1<<0) //< 串口1中断 #define WK2114_G_REG_GIFR_MASK_UT2INT (1<<1) //< 串口2中断 @@ -82,8 +154,8 @@ enum wk2114_s_reg{ WK2114_S_REG_FSR=0x0b, //< PAGE0: 子串口FIFO状态寄存器 WK2114_S_REG_LSR=0x0c, //< PAGE0: 子串口接收状态寄存器 WK2114_S_REG_FDAT=0x0d, //< PAGE0: 子串口FIFO数据寄存器 - WK2114_S_REG_BUAD1=0x04, //< PAGE1: 子串口波特率配置寄存器高字节 - WK2114_S_REG_BUAD0=0x05, //< PAGE1: 子串口波特率配置寄存器低字节 + WK2114_S_REG_BAUD1=0x04, //< PAGE1: 子串口波特率配置寄存器高字节 + WK2114_S_REG_BAUD0=0x05, //< PAGE1: 子串口波特率配置寄存器低字节 WK2114_S_REG_PRES=0x06, //< PAGE1: 子串口波特率配置寄存器小数部分 WK2114_S_REG_RFTL=0x07, //< PAGE1: 子串口接收FIFO中断触发点配置寄存器 WK2114_S_REG_TFTL=0x08 //< PAGE1: 子串口发送FIFO中断触发点配置寄存器 @@ -109,6 +181,17 @@ enum wk2114_uart_stop_bits{ WK2114_UART_STOP_BITS_2=1 //< 2位停止位 }; +// WK2xxx 复位IO 高电平，低电平重启 +#define WK2XXX_RST_GPIO_PORT GPIOF +#define WK2XXX_RST_PIN GPIO_PIN_6 +#define WK2XXX_RST_GPIO_CLK_ENABLE() __HAL_RCC_GPIOF_CLK_ENABLE() +// WK2xxx IRQ IO 默认Pulldown 下降沿触发 +#define WK2XXX_IRQ_GPIO_PORT GPIOF +#define WK2XXX_IRQ_PIN GPIO_PIN_7 +#define WK2XXX_IRQ_GPIO_CLK_ENABLE() __HAL_RCC_GPIOF_CLK_ENABLE() +#define WK2XXX_IRQ_EXTI_IRQ EXTI9_5_IRQn +#define WK2XXX_IRQ_HANDLER EXTI9_5_IRQHandler + typedef void (*wk2114_sub_uart_recv_fun)(void *recv_class,uint8_t *buf,uint32_t size); //< 子串口接收数据回调函数 typedef int (*wk2114_send_fun)(void *send_class,uint8_t *buf,uint32_t size); //< wk2114发送函数 @@ -125,31 +208,51 @@ struct wk2114_send_record typedef struct __wk2114 WK2114_TypeDef; typedef struct __wk2114_sub_uart WK2114_Sub_Uart_TypeDef; +typedef struct __wk2114_sub_uart_cfg WK2114_Sub_Uart_CFG_TypeDef; struct __wk2114 { volatile uint8_t flag; //< 标志位 - uint8_t cmd; //< 上一次的全局寄存器读命令 - uint8_t reg; //< 上一次接收到的全局寄存器 + volatile uint8_t cmd; //< 上一次的全局寄存器读命令 + volatile uint8_t reg; //< 上一次接收到的全局寄存器 + volatile uint8_t reg_readout; + osMessageQueueId_t cmd_queue; //< 命令队列 // struct queue cmd_queue; //< 命令队列 WK2114_Sub_Uart_TypeDef *sub_uart[4]; //< 子串口 + WK2114_Sub_Uart_CFG_TypeDef *sub_uart_cfg[4]; //< 子串口 + WK2114_Sub_Uart_TypeDef *it_sub_uart ; // 当前中断子串口 + uint8_t it_sub_uart_index; + + // uint8_t cmd_queue_msg[2] ; + uint8_t cmd_queue_msg_put[2] ; + uint8_t cmd_queue_msg_get[2] ; - uint8_t cmd_queue_msg[2] ; - - uint8_t cmd_buf[64][2]; //< 命令队列缓冲区 + // uint8_t cmd_buf[64][2]; //< 命令队列缓冲区 uint8_t send_buf[18]; //< 发送缓冲区 2+16 void *send_class; //< 发送函数的第一个参数 uint32_t dev_clock_hz; //< wk2114时钟源频率 wk2114_send_fun send_fun; //< 发送函数 + + uint16_t size_received; //< 当前接收到的字节数 + + // uint8_t it_type; + uint64_t timebase; + uint32_t timeout_ms; + volatile WK2114_WORK_STATE_TypeDef state; + // uint8_t setbaud_ok; + // uint8_t senf40_rcvF0_ok; + volatile uint8_t idle_receive_flag; + uint8_t reg_gifr; // 全局中断寄存器 } ; struct __wk2114_sub_uart { - uint8_t flag; //< 标志位 - uint8_t cmd; //< 上一次的子串口寄存器读命令 + volatile uint8_t flag; //< 标志位 + volatile uint8_t cmd; //< 上一次的子串口寄存器读命令 uint8_t reg; //< 上一次接收到的子串口寄存器 uint8_t uart_index; //< 串口地址 + void *recv_class; //< 接收回调函数的第一个参数 wk2114_sub_uart_recv_fun recv_fun; //< 接收回调函数 osMessageQueueId_t send_queue; //< 发送队列 ?? 子串口待发送出去的？还是通过主串口发回来的 @@ -158,20 +261,68 @@ struct __wk2114_sub_uart uint8_t *send_buf; //< 当前发送数据指针 uint32_t recv_buf_p; //< 接收缓冲区计数 uint32_t recv_buf_size; //< 接收缓冲区大小 - WK2114_TypeDef *wk2114; //< wk2114结构指针 uint32_t send_buf_p; //< 发送缓冲区计数 - struct wk2114_send_record send_record[8]; //< 发送记录 + WK2114_TypeDef *wk2114; //< wk2114结构指针 + struct wk2114_send_record send_record[8]; //< 发送记录 8*16 = 256 + uint8_t send_record_p; + + // uint8_t s_reg_sifr_read; // 子串口中断源 + // uint8_t s_reg_lsr; // 子串口中断源 + // uint8_t s_reg_lcr; // 子串口中断源 +} ; + +struct __wk2114_sub_uart_cfg +{ + // baud reg , baud_div =(dev_clock_hz*100/16/baud )/100 - 1 + uint8_t baud1_reg; // baud >>8 + uint8_t baud0_reg; // baud &0xFF + uint8_t pres_reg; // baud 小数部分 ((dev_clock_hz*100/16/baud)/10)%10 + + // lcr reg , parity stopbit , party|stop_bits + uint8_t lcr_reg; // party|stop_bits + uint8_t fwcr_reg; // WK2114_SUB_UART_FIFO_MODE_MASK_TX|WK2114_SUB_UART_FIFO_MODE_MASK_RX + uint8_t scr_reg; // 04 03 mode WK2114_SUB_UART_MODE_MASK_TX|WK2114_SUB_UART_MODE_MASK_RX + + uint8_t tftl_reg; // Tx fifo Trigger + uint8_t rftl_reg; // Rx fifo Trigger + uint8_t iser_reg; // 中断类型设置 + + uint8_t reg_sifr; // 子串口中断源 + uint8_t reg_fsr; // 子串口FIFO状态 + uint8_t reg_lsr; // 子串口接收状态寄存器 + uint8_t reg_fdat; // 子串口 FIFO 数据寄存器 , 需要读写状态 + // uint8_t line; + // uint8_t new_lcr_reg; + // uint8_t new_fwcr_reg; + // uint8_t new_scr_reg; + // /*baud register*/ + // uint8_t new_baud1_reg; + // uint8_t new_baud0_reg; + // uint8_t new_pres_reg; } ; extern WK2114_TypeDef *wk2114; +extern WK2114_Sub_Uart_TypeDef *sub_uart1 ; +extern uint8_t sub_uart1_receive_buf[1024]; + int WK2114_Init( ); +void WK2114_Port(); +void WK2114_Task(void * argument ); + +int Sub_rcv_callback(void * obj, uint8_t * buf, uint16_t len); +int WK2114_Add_Sub_Uart(WK2114_TypeDef *wk2114 ); + int wk2114_send(WK2114_TypeDef *wk2114); -int wk2114_read_reg(WK2114_TypeDef *wk2114,uint8_t reg_addr); -int wk2114_write_reg(WK2114_TypeDef *wk2114,uint8_t reg_addr,uint8_t reg); -int wk2114_read_fifo(WK2114_TypeDef *wk2114,enum wk2114_s_uart sub_uart,uint8_t size); -int wk2114_write_fifo(WK2114_TypeDef *wk2114,enum wk2114_s_uart sub_uart,uint8_t *buf,uint8_t size); + +int wk2114_read_global_reg(WK2114_TypeDef *wk2114 , uint8_t reg_addr); +int wk2114_write_global_reg(WK2114_TypeDef *wk2114,uint8_t reg_addr,uint8_t reg); +int wk2114_read_subuart_reg(WK2114_TypeDef *wk2114 ,enum wk2114_s_uart uart_addr, uint8_t reg_addr); +int wk2114_write_subuart_reg(WK2114_TypeDef *wk2114,enum wk2114_s_uart uart_addr, uint8_t reg_addr,uint8_t reg); +int wk2114_read_fifo(WK2114_TypeDef *wk2114,uint8_t sub_uart,uint8_t size); +int wk2114_write_fifo(WK2114_TypeDef *wk2114,uint8_t sub_uart,uint8_t *buf,uint8_t size); + int wk2114_sub_uart_set_page(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t page); int wk2114_flush_gena(WK2114_TypeDef *wk2114); int wk2114_flush_gier(WK2114_TypeDef *wk2114); @@ -179,36 +330,150 @@ int wk2114_sub_uart_set_inter(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t inter_fla int wk2114_sub_uart_set_fifo_trigger(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t tx_trigger,uint8_t rx_trigger); void wk2114_reg_recv_callback(WK2114_TypeDef *wk2114); +int wk2114_reset(WK2114_TypeDef *wk2114); int wk2114_set_baud( WK2114_TypeDef *wk2114 ); +int wk2114_test(WK2114_TypeDef *wk2114); +int wk2114_mainport_rcv(WK2114_TypeDef *wk2114, uint8_t *buf, uint16_t size); + int wk2114_set_uart(WK2114_TypeDef *wk2114,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits); -int wk2114_set_sub_uart(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t buad,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits); +int wk2114_set_sub_uart(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t baud,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits); int wk2114_sub_uart_set_mode(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t mode); int wk2114_sub_uart_set_fifo_mode(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t mode); int wk2114_sub_uart_enable(WK2114_Sub_Uart_TypeDef*sub_uart); int wk2114_sub_uart_disable(WK2114_Sub_Uart_TypeDef*sub_uart); int wk2114_sub_uart_reset(WK2114_Sub_Uart_TypeDef*sub_uart); -WK2114_TypeDef * wk2114_init(WK2114_TypeDef *wk2114,uint32_t dev_clock_hz,void *send_class,wk2114_send_fun send_fun); +// WK2114_TypeDef * wk2114_init(WK2114_TypeDef *wk2114,uint32_t dev_clock_hz,void *send_class,wk2114_send_fun send_fun); int wk2114_sub_uart_register(WK2114_TypeDef *wk2114,WK2114_Sub_Uart_TypeDef*sub_uart,enum wk2114_s_uart uart_addr,uint8_t *recv_buf,uint32_t recv_buf_size,void *recv_class,wk2114_sub_uart_recv_fun recv_fun); -int wk2114_sub_uart_init(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t buad,uint8_t mode,uint8_t fifo_mode,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits); +int wk2114_sub_uart_init(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t baud,uint8_t mode,uint8_t fifo_mode,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits); int wk2114_sub_uart_chenge_recv_fun(WK2114_Sub_Uart_TypeDef*sub_uart,void *recv_class,wk2114_sub_uart_recv_fun recv_fun); int wk2114_sub_uart_send(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t *buf,uint32_t size); int wk2114_sub_uart_isbusy(WK2114_Sub_Uart_TypeDef*sub_uart); void wk2114_recv_callback(WK2114_TypeDef *wk2114,uint8_t *buf,uint32_t size); + void wk2114_inter_callback(WK2114_TypeDef *wk2114); +// void wk2114_exti_callback(WK2114_TypeDef *wk2114); void wk2114_send_completed_callback(WK2114_TypeDef *wk2114); + +void wk2114_idle_callback(WK2114_TypeDef *wk2114,uint8_t *buf,uint32_t size); +void wk2114_get_it_type_by_it_source(WK2114_TypeDef *wk2114); +void wk2114_process_by_it_type(WK2114_TypeDef *wk2114, uint8_t it_type); #endif + +/* + +#define WK2114_RST_Pin GPIO_PIN_6 +#define WK2114_RST_GPIO_Port GPIOF +#define WK2114_IRQ_Pin GPIO_PIN_7 +#define WK2114_IRQ_GPIO_Port GPIOF + +__HAL_RCC_GPIOF_CLK_ENABLE(); + GPIO_InitTypeDef GPIO_InitStruct = {0}; + GPIO_InitStruct.Pin = WK2114_RST_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); + +// 以下可以启动子串口的产生的 接收外部中断 + GPIO_InitStruct.Pin = WK2114_IRQ_Pin; + GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING; + GPIO_InitStruct.Pull = GPIO_PULLDOWN; + HAL_GPIO_Init(WK2114_IRQ_GPIO_Port, &GPIO_InitStruct); + + // EXTI interrupt init + HAL_NVIC_SetPriority(EXTI9_5_IRQn, 5, 0); + HAL_NVIC_EnableIRQ(EXTI9_5_IRQn); + +void EXTI9_5_IRQHandler(void) +{ + + HAL_GPIO_EXTI_IRQHandler(WK2114_IRQ_Pin); + +} + +上次是否发送完成启用信号量控制，在 rtos中 +*/ + + /* -逻辑： +命令说明 + 7 6 5 4 3 2 1 0 + + [7] 0 reg读写 ; 1 FIFO读写 + [6] 0 写 1 读 + [5:4] 字串口号 全局寄存器为 00 + [3:0] 寄存器模式 寄存器地址， FIFO模式 为读写字节数 + + 0x55 return 0x00 + 0x40 return 0xF0 + + +初始化， 0x55设置子窗口波特率， 注册子串口， 子串口初始化(初始要有时间延迟) +如何确认初始成功？ + +注册初始化串口 1 , 命令参考函数的注释 +write reg 0x00 0x01 +write reg 0x01 0x01 +write reg 0x10 0x01 +write reg 0x03 0x01 +write reg 0x04 0x00 +write reg 0x05 0x4d(9600) 0505(115200) +write reg 0x06 0x01 0605 +write reg 0x03 0x00 +write reg 0x05 0x00 +write reg 0x03 0x01 +write reg 0x08 0x80 +write reg 0x07 0x80 +write reg 0x03 0x00 +write reg 0x07 0x83 +write reg 0x06 0x0c +write reg 0x04 0x03 + +//WK2xxx 初始化 +if(0==WK2114_Init()) +{ + log_i("wk2114 Init Ok..."); +}else{ + log_i("wk2114 Init Failure..."); +} +// 启动任务 +WK2114_Port(); +// 状态机初始化 +wk2114->state= WK2114_WORK_STATE_START; + + +// 发送 ， 调用wk2114_sub_uart_send函数， 装载子串口队列及buf +// wk2114_sub_uart_send启用子串口中断， 发送触点为空中断，调用wk2114_write_fifo 进行发送 +// 注意： 发送fifo 256, 发送触点中断设置为128超过128 自动启动发送触点中断 +wk2114_sub_uart_send(wk2114->sub_uart[0],send_buf,8); + +8.3.1 FIFO数据错误中断 +FIFO数据错误中断表明当前接收FIFO中有一个或以上的数据错误，产生错误的条件包括OE +（数据溢出错误），FE（数据帧错误），和PE（奇偶校验错），BE（Line-Break错误）。 +一旦有接收FIFO中有出错数据,当读取FSR寄存器后，清除相应的中断。 +8.3.2 发送FIFO空中断 -- +当发送FIFO中没有数据，产生该中断。 +当发送FIFO中的数据个数大于设定的发送FIFO触发点时，该中断被清除。 +8.3.3 发送FIFO触发点中断 +当发送FIFO中的数据个数小于设定的发送FIFO触发点时，产生该中断。 +当发送FIFO中的数据个数大于设定的发送FIFO触发点时，该中断被清除。 +8.3.4接收FIFO超时中断 +当接收FIFO中数据个数小于设定的接收FIFO触发点并且RX引脚4个字节之内没有数据，产生该中断。 +当接收FIFO中的数据被读走或者RX继续接收数据时，该中断消失。 +8.3.5 接收FIFO触发点中断 +当接收FIFO中的数据个数大于设定的发送FIFO触发点时，产生该中断。 +当接收FIFO中的数据个数小于设定的发送FIFO触发点时，该中断被清除。 + -如pH 传感器使用 子串口1 -pH里面回调函数 PH_Callback 注册到子串口1 +wk2114_read_reg( wk2114, 0x00 ); 自动加上 [7:6] 0 1 -1. 子串口1发送 - 调用主串口， 做好主串口的发送队列 + HAL_UART_DMAStop(pWK2114Uart); + HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, rcvbuf, 1024); + wk2114->cmd =0; + wk2114_read_reg( wk2114, 0x00 ); -2. 子串口接收，由外部中断启动，最后调用了PH_callback 将数据写回 */ \ No newline at end of file diff --git a/device/Src/base.c b/device/Src/base.c new file mode 100644 index 0000000..41ad488 --- /dev/null +++ b/device/Src/base.c @@ -0,0 +1,434 @@ +#include "base.h" +// #define USE_USB_HS +extern osSemaphoreId_t elog_dma_lockHandle; +int _write(int fd, char *ch, int len) +{ + // HAL_UART_Transmit(&huart1, (uint8_t *)ch, len, 0xFFFF); + if (osOK == osSemaphoreAcquire(elog_dma_lockHandle, osWaitForever)) + { + HAL_UART_Transmit_DMA(&huart2, (uint8_t *)ch, len); + } + return len; +} + +extern struct led led_0; +// extern struct led led_1; + +// extern osTimerId_t myTimer01Handle; + +// uint8_t send_buf[8] = {0x01,0x03,0x00,0x00,0x00,0x04,0x44,0x09}; +uint8_t send_buf[24] = {0x01,0x03,0x00,0x00,0x00,0x04,0x44,0x09,0x01,0x03,0x00,0x00,0x00,0x04,0x44,0x09,0x01,0x03,0x00,0x00,0x00,0x04,0x44,0x09}; +// uint8_t rcv_buf[14] = {0}; +// uint8_t rcv_buf_2[13] = {0}; + +// uint8_t wk2xxx_rcvbuf[1024] ={ 0}; +WK2114_Sub_Uart_TypeDef *sub_uart1 = NULL; +uint8_t sub_uart1_receive_buf[1024]; + +void MY_INIT( ) +{ + // max3243_enable( ); // 使能 3243 供电 + // uart2_power_enable( ); + // uart3_power_enable( ); + // uart4_power_enable( ); + // uart6_power_enable( ); + + // usart6_receive_enable(); + +} + + + void measureTimer_Callback(void *argument) +{ + log_i("measure timer begin .... " ); + led_set_state( &led_0, LED_STATE_FLICKER_QUICK ); + + int st ; + st = wk2114_sub_uart_send( wk2114->sub_uart[0], send_buf, sizeof(send_buf) ); + log_e("send_buf ok addr %d .... st %d " ,send_buf, st); + + // osEventFlagsSet(wk2114EventHandle, + // MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING); + // sc6.start(); + // oscar.start(); + // ph.start(); + // // my_ads1115.start(); + // memset((void* )result, 0 , 12); +} + + +void measureTask(void *argument) +{ + int step =0; + for (;;) + { + osDelay(40); + } +} + +static void Default_Task_Init() +{ + // measuring_flag = 0; + uint64_t ticks = 0; + if ( 0 == Led_Port() ) { + log_i("Led Port int Ok .... "); + } + led_set_state( &led_0, LED_STATE_FLICKER_SLOW ); + + +//WK2xxx 初始化 +if(0==WK2114_Init()) +{ + log_d("wk2114 Init Ok..."); +}else{ + log_w("wk2114 Init Failure..."); +} + + +// 启动任务, 多次重试baud +WK2114_Port(); +// 状态机初始化 +wk2114->state= WK2114_WORK_STATE_START; +while( wk2114->state!=WK2114_WORK_TEST_OK ) {osDelay(1);} +log_d("wk2114 test ok..."); +wk2114->state= WK2114_WORK_STATE_ADD_SUB_UART; +while( wk2114->state!=WK2114_WORK_STATE_OK ) {osDelay(1);} +log_d("wk2114 init subuart ok..."); +// HAL_Delay(2000); + // wk2114_mainport_rcv( wk2114); + // osEventFlagsSet(wk2114EventHandle, + // MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING); +// int st; +// // memset(rcvbuf, 0, 1024); +// // __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE); +// // st =HAL_UART_Receive_DMA(pWK2114Uart, rcvbuf, 1024); + + // wk2114_read_global_reg( wk2114, 0x00); +// // osDelay(1); + +// // // wk2114->cmd = (WK2114_CMD_READ_REG<<6)+WK2114_G_REG_GIFR; +// // HAL_UART_Transmit(pWK2114Uart, &wk2114->cmd, 1, 0xFFF); +// st = HAL_UART_Receive(pWK2114Uart, &wk2114->reg_readout, 1 , 0xFFF); +// log_i(" wk2114->reg_readout 0x%02X st %d ", wk2114->reg_readout,st); + // wk2114_inter_callback( wk2114); + + +// // 注册子串口，初始化 +// sub_uart1 = (WK2114_Sub_Uart_TypeDef *)malloc(sizeof(WK2114_Sub_Uart_TypeDef)); +// if (0!=wk2114_sub_uart_register(wk2114, sub_uart1,WK2114_S_UART_1,sub_uart1_receive_buf,1024, &huart2, Sub_rcv_callback)) +// { +// log_e("sub-uart 1 register Failure ! "); +// }; +// if (0!=wk2114_sub_uart_init( sub_uart1,115200,WK2114_SUB_UART_MODE_MASK_TX|WK2114_SUB_UART_MODE_MASK_RX,WK2114_SUB_UART_FIFO_MODE_MASK_TX|WK2114_SUB_UART_FIFO_MODE_MASK_RX,WK2114_UART_PARITY_NONE,WK2114_UART_STOP_BITS_1)) +// { +// log_e("sub-uart 1 init Failure ! "); +// } + +// log_w( " sub uart init ok .... " ); +// log_w( " --->>>> count %d " , osMessageQueueGetCount(wk2114->cmd_queue) ); + + // memset(rcvbuf, 0, 1024); + // __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE); + // HAL_UART_Receive_DMA(pWK2114Uart, rcvbuf, 1024); + +// while (osMessageQueueGetCount(wk2114->cmd_queue) > 0) +// { +// wk2114_send(wk2114); +// } +// log_i("sub-uart 1 init success ! "); + +// // 启动任务 +// WK2114_Port(); +// // 状态机初始化 +// wk2114->state= WK2114_WORK_STATE_START; + + + + + + // if ( 0 == ds1302_port() ) + // { + // log_i("ds1302 init Ok .... "); + // } + + // ph.init(); + // ph.port(); + // ph.test(); + + // viper.init(); + // viper.port(); + // viper.test(); + + // oscar.init(); + // oscar.port(); + // oscar.test(); + + // sc6.init(); + // sc6.port(); + // sc6.test(); + + // ramses.init(); + // ramses.port(); + // ramses.test(); + + // wh_lte.init(); + // wh_lte.port(); + // wh_lte.start(); + + // wk2114.init(); + // wh_lte.port(); + // wh_lte.start(); + // ticks = osKernelGetTickCount(); + // while ( viper.state!=Viper_State_Ready ) + // { + // if ( ( osKernelGetTickCount() -ticks) > 3000 ) + // { + // log_e(" VIPER_ state error.... ") ; + // break; + // } + // osDelay(10); + // } + // log_d(" VIPER_ state OK.... ") ; + + + // Modbus_Port( ); + RTOS_Port( ); + extern osTimerId_t measureTimerHandle; + osTimerStart( measureTimerHandle, 5000 ); + +} + + +void StartDefaultTask(void *argument) +{ + HAL_GPIO_WritePin( LED0_GPIO_Port,LED0_Pin,RESET); + // max3243_enable( ); + Init_Logger(); + log_i(" ****** System is initiating ****** "); + + Default_Task_Init(); + + for (;;) + { + // log_i("looo... "); + osDelay(1000 ); + // log_i(" aa bb cc dd : %d %d %d %d ",aa, bb, cc, dd ); + } +} + +void HAL_GPIO_EXTI_Callback(uint16_t GPIO_pin) +{ + // log_i( " irq ..... %d ",osKernelGetTickCount() ); + +} + +// void EXTI9_5_IRQHandler(void) +// { +// log_i( " irq ..... %d ",osKernelGetTickCount() ); +// // if( (osEventFlagsGet(wk2114EventHandle) & MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING) !=0){ +// // return; +// // } +// // osEventFlagsSet(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING); +// // log_i( " exti ..... %d ",osKernelGetTickCount() ); +// // HAL_GPIO_EXTI_IRQHandler(WK2114_INT_Pin); + +// // if(__HAL_GPIO_EXTI_GET_IT(WK2XXX_INT_GPIO_PIN) != RESET) +// // { +// // // 在中断处理函数中对GT911的寄存器0X814E写0 +// // log_i("WK2XXX_INT_IRQHandler ......"); +// // // GTP_TouchProcess(); +// // // INT_Callback(); +// // __HAL_GPIO_EXTI_CLEAR_IT(WK2XXX_INT_GPIO_PIN); + +// // } +// } + +void Soft_Reboot() +{ + __set_FAULTMASK(1);//关闭总中断 + NVIC_SystemReset();//请求单片机重启 + +} + + +/* + + // printf("test.... \r\n"); + // printf ( "max3243 ... %d \r\n", HAL_GPIO_ReadPin( MAX3242_EN_GPIO_Port,MAX3242_EN_Pin)); + // HAL_UART_Transmit(&huart1, pH_send_buf, 8,1000); + // HAL_UART_Transmit(&huart2, pH_send_buf, 8,1000); + // HAL_UART_Transmit(&huart4, pH_send_buf, 8,1000); + + // usart6_send_enable(); + // HAL_UART_Transmit(&huart6, pH_send_buf, 8,1000); + + log_i("test uart2 .... "); + HAL_GPIO_WritePin(UART_EN_GPIO_Port,UART_EN_Pin, SET); + HAL_UART_Transmit(&huart2, (uint8_t*)"usart2\r\n", 8,0xFF); + + HAL_UART_Transmit_IT(&huart4, send_buf, 8 ); + // while ( __HAL_UART_GET_FLAG(&huart4, UART_FLAG_TC) == RESET); + // HAL_UART_Receive_IT(&huart4, rcv_buf_2, 13 ); + + // HAL_GPIO_WritePin(UART_EN_GPIO_Port,UART_EN_Pin,RESET); + + log_i("test uart6 485.... "); + HAL_GPIO_WritePin(R_W_GPIO_Port,R_W_Pin, SET); + // HAL_UART_Transmit(&huart6, (uint8_t*)"uart66\r\n", 8,0xFF); + HAL_UART_Transmit_IT(&huart6, send_buf, 8 ); + while ( __HAL_UART_GET_FLAG(&huart6, UART_FLAG_TC) == RESET); + HAL_GPIO_WritePin(R_W_GPIO_Port,R_W_Pin,RESET); + HAL_UART_Receive_IT(&huart6, rcv_buf, 13 ); + + + // log_i("test uart3 3160 232.... "); + // HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, RESET); + // HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET); + // // HAL_UART_Transmit(&huart3, (uint8_t*)"uart3160\r\n", 10,0xFF); + // // HAL_UART_Transmit(&huart3, send_buf, 8,0xFF); + // HAL_UART_Receive_IT(&huart3, rcv_buf_2, 13 ); + // HAL_UART_Transmit_IT(&huart3, send_buf, 8 ); + // while ( __HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) == RESET); + + + // log_i("test uart3 3160 485.... "); + // HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, SET); + // HAL_GPIO_WritePin(DE485_GPIO_Port, DE485_Pin, RESET); + // HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, SET); + // // HAL_UART_Transmit(&huart3, (uint8_t*)"uart3160\r\n", 10,0xFF); + // // HAL_UART_Transmit(&huart3, send_buf, 8,0xFF); + + // // HAL_UART_Receive_IT(&huart3, rcv_buf_2, 13 ); + // HAL_UART_Transmit_IT(&huart3, send_buf, 8 ); + // while ( __HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) == RESET); + // HAL_GPIO_WritePin(DE485_GPIO_Port, DE485_Pin, SET); + // HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET); + // // HAL_UART_Receive_IT (&huart3, rcv_buf_2,2 ); + // if ( HAL_UART_Receive (&huart3, rcv_buf_2, 2 ,2000) ==HAL_OK) + // { + // log_i("rcv ok"); + // } + + // log_i( "rcvbuf : %d %d %d", rcv_buf_2[0], rcv_buf_2[1], rcv_buf_2[2]); + + // HAL_GPIO_WritePin(DE485_GPIO_Port, DE485_Pin, SET); + // HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET); + + +*/ + +// void measureTimer_Callback(void *argument) +// { +// log_i("measure timer begin .... " ); +// // led_set_state( &led_0, LED_STATE_FLICKER_QUICK ); +// // voltage = 0.0; +// // H2S = 0.0; +// // memset(pH_rcv_buf, 0, 9 ); +// // memset(result, 0, 12 ); +// // timebase = osKernelGetTickCount(); +// // measuring_flag = 1; +// // pH_send_flag = 0; +// // pH_rcv_flag = 0; +// // pH_measuring_flag = 0; +// // pH_measure_ok = 0; +// // voltage_measure_ok = 0; +// // measure_step = 0; +// } + +// void pH_Task(void *argument) +// { +// max3160_485_receive_mode(); +// for(;;) +// { + +// // if ( pH_measure_ok ==0 && pH_send_flag == 0) +// // { +// // log_i(" send stage ... "); +// // HAL_UART_Receive_DMA(&huart3, pH_rcv_buf, 9 ); +// // timebase = osKernelGetTickCount(); +// // max3160_485_send_mode(); +// // pH_send_flag = 1; +// // HAL_UART_Transmit_DMA(&huart3, pH_send_buf, 8 ); +// // } +// // if ( pH_measure_ok ==0 && pH_send_flag == 1 && pH_rcv_flag == 0 ) +// // { +// // uint64_t time_ticks = osKernelGetTickCount() ; +// // // log_i( " time_ticks :%d " , time_ticks); +// // if ( (time_ticks - timebase ) >400) +// // { +// // log_i( " pH timeout ..... " ); +// // measureTimer_Callback(NULL); +// // } +// // } +// // if ( pH_measure_ok ==0 && pH_rcv_flag == 1 ) +// // { +// // log_i( " pH ok ..... " ); +// // pH_measure_ok = 1; +// // } +// // if ( pH_measure_ok ==1 ) +// // { +// // ; +// // } +// osDelay(50); +// } +// } + + +// void Measure_Task(void *argument) +// { +// for (;;) +// { +// // /* convert */ +// // if ( measure_step==0 && pH_measure_ok == 1 && voltage_measure_ok == 1 ) +// // { +// // /** TODO ...*/ +// // result[1] = (pH_rcv_buf[5]*256 + pH_rcv_buf[6])/10.0; /* Temp /10.0*/ +// // result[2] = (pH_rcv_buf[3]*256 + pH_rcv_buf[4])/100.0; /* pH /10.0*/ +// // // log_i( " temperature :%.6f pH : %.6f " , temperature ,pH_value); +// // get_h2s_2(&H2S_concentration , voltage, result[1]); +// // result[0] = H2S_concentration; +// // led_set_state(&led_0, LED_STATE_FLICKER_SLOW); +// // // log_i( "H2S : %.6f " ,H2S); +// // measure_step++; +// // } + +// // /* 写modbus数据 */ +// // if ( measure_step==1 ) +// // { +// // /* 写modbus 临界区 */ +// // log_i( "-------> H2S: %.6f TEMP: %.6f pH: %.6f ", result[0] , result[1], result[2]); +// // // 数据全反过来 40db851f41a80000402771f2 -》 f2712740......// + +// // Modbus_Set_HoldingBuff( (uint8_t *)result, 12, 0); + +// // measure_step++; +// // /*pH 686 : 40db851f 41a80000 402771f2 */ +// // } +// // /* 输出数据 uart1 */ +// // if ( measure_step==2 ) +// // { +// // log_i( "send to screen... " ); +// // int ret= HAL_UART_Transmit_IT(&huart1, (uint8_t *)result, 12); +// // if( ret==HAL_OK) +// // log_i( "send ok.. " ); + +// // measure_step++; +// // } +// // if ( measure_step==3 ) +// // { +// // osDelay(2); +// // } +// osDelay(20); + +// } +// } + + + + // if ( 0 == ads1115_test(hi2c1) ) + // { + // log_i("ads1115 test Ok .... "); + // }else{ + // log_i("ads1115 test failure .... "); + + // } \ No newline at end of file diff --git a/device/Src/wk2114.c b/device/Src/wk2114.c index 44dc43c..65b52cd 100644 --- a/device/Src/wk2114.c +++ b/device/Src/wk2114.c @@ -9,76 +9,26 @@ * */ #include +#include #include "wk2114.h" // #include "critical_section.h" #include "usart.h" #include "elog.h" - -static uint8_t init_buf=0x55; -UART_HandleTypeDef *pWK2114Uart = &huart1; -#define WK2114_Uart_IRQHandler USART1_IRQHandler -WK2114_TypeDef *wk2114; +extern osSemaphoreId_t wk2xxx_lockHandle; +extern osSemaphoreId_t wk2xxx_irq_lockHandle; +extern osSemaphoreId_t wk2xxx_sub_lockHandle; +extern osEventFlagsId_t wk2114EventHandle; +extern osThreadId_t wk2114Handle; +static uint8_t init_buf=0x55; -osMessageQueueId_t wk2114CmdQueueHandle; -osMessageQueueId_t wk2114SndQueueHandle; -// osMessageQueueId_t osMessageQueueNew (uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr); -// osMessageQueueGet(TestQueueHandle,osWaitForever); -// osStatus_t osMessageQueueGet ( osMessageQueueId_t mq_id, +// uint8_t buf[1024]={0}; -void WK2114_Uart_IRQHandler(void) -{ - uint16_t count = 0; - uint16_t data_length = 0; - if (__HAL_UART_GET_FLAG(pWK2114Uart, UART_FLAG_TC) != RESET) - { - log_i("WK2114 ..huart TC callback ..."); - wk2114->flag&=~WK2114_G_FLAG_MASK_SENDING; - pWK2114Uart->gState = HAL_UART_STATE_READY; - __HAL_UART_CLEAR_FLAG(pWK2114Uart, UART_FLAG_TC); - } - - if (__HAL_UART_GET_FLAG(pWK2114Uart, UART_FLAG_IDLE) != RESET) - { - log_i("WK2114 ..huart IDLE ..."); - // count = __HAL_DMA_GET_COUNTER( pWK2114Uart->hdmarx ); - // data_length = Ramses_Rcv_Buf_Size - count; - // if ( data_length > 0 ) - // { - // // log_i("Ramses_ IDLE.. data_length %d", data_length); - // // Ramses_copy( wk2114, data_length ); - // // log_i("Oscar_. IDLE..res %02X %d %02X", oscar->uarthelper ->receive_buf[0], oscar->uarthelper ->receive_buf[2], oscar->uarthelper ->receive_buf[data_length-1]); - // } - __HAL_UART_CLEAR_IDLEFLAG( pWK2114Uart ); - } -} - - -int WK2114_Init( ) -{ - log_i( "..... init......... %d " , wk2114->flag); - wk2114 = (WK2114_TypeDef *)malloc(sizeof(WK2114_TypeDef)); - wk2114->send_class = pWK2114Uart; - wk2114->send_fun = HAL_UART_Transmit_DMA; - - // 命令队列 uint8_t cmd_buf[64][2] , 消息类型 2个uint8_t - wk2114->cmd_queue = osMessageQueueNew( 8, sizeof(wk2114->cmd_queue_msg), NULL); - if (wk2114->cmd_queue ==NULL) return -1; - - wk2114->flag = 0; - wk2114->dev_clock_hz = WK2114_CLOCK_HZ; - - for(size_t i=0;i<4;i++){ - wk2114->sub_uart[0]=NULL; - } +WK2114_TypeDef *wk2114; +static uint8_t mybuf[8] ={0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x01}; +uint8_t wk2xxx_rcvbuf[1024] ={ 0}; - if( wk2114_set_baud(wk2114)<0) { - return NULL; - } - log_i( "..... init.. 2....... %d " , wk2114->flag); - return 0; -} /** @@ -86,90 +36,24 @@ int WK2114_Init( ) * @note 请确保调用时上次发送的数据已经发送完毕 * @param wk2114 struct wk2114结构指针 * @return int >=0:成功 <0:失败 + * @desp 记录cmd 值，以面操作子串口和主串口混淆 */ -int wk2114_send(WK2114_TypeDef *wk2114) +// int wk2114_send(WK2114_TypeDef *wk2114,uint8_t *buf, uint16_t size) +// { +// int st; +// osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); +// st = wk2114->send_fun(wk2114->send_class,buf,size+1); +// osSemaphoreRelease(wk2xxx_lockHandle); +// return st; +// } + +int wk2114_mainport_rcv(WK2114_TypeDef *wk2114, uint8_t *buf, uint16_t size) { - log_i( "..... send.......... %d " , wk2114->flag); - int p_de; - uint8_t cmd; - volatile uint8_t size; - WK2114_Sub_Uart_TypeDef *p_sub_uart; - if((wk2114->flag&WK2114_G_FLAG_MASK_BUSY)!=0){ // busy,exit - return 0; - } - log_i( "..... send 22 ..... " ); - if((wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0){ // sending ,exit - return 0; - } - // p_de=queue_get_de_index(&wk2114->cmd_queue); // 取队列消息,即cmd_buf数组索引 - log_i( ".....get wk2114->cmd_queue_msg....111...... " ); - - osMessageQueueGet( wk2114->cmd_queue ,wk2114->cmd_queue_msg, sizeof(wk2114->cmd_queue_msg) ,osWaitForever); - log_i( ".....get wk2114->cmd_queue_msg.......... " ); - // if(p_de<0){ - // wk2114->flag&=~WK2114_G_FLAG_MASK_INTER; - // return 0; - // } - wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; - cmd=wk2114->cmd_queue_msg[0]; // first byte - if( WK2114_CMD_IS_REG(cmd) ){ // 若为命令 - if(WK2114_CMD_IS_READ(cmd)){ // 读命令 1byte 0+1 - size=0; - wk2114->flag|=WK2114_G_FLAG_MASK_BUSY; - wk2114->send_buf[0]=cmd; - } - else{ // 写命令 2byte 1+1 - size=1; - wk2114->send_buf[0]=cmd; - wk2114->send_buf[1]=wk2114->cmd_queue_msg[1]; - if( WK2114_CMD_GET_ADDR(cmd)==WK2114_S_REG_SPAGE ){ - if(wk2114->cmd_queue_msg[1]==0){ - wk2114->sub_uart[WK2114_CMD_GET_SUB_UART(cmd)]->flag&=~WK2114_S_UART_FLAG_MASK_PAGE_D; - } - else{ - wk2114->sub_uart[WK2114_CMD_GET_SUB_UART(cmd)]->flag|=WK2114_S_UART_FLAG_MASK_PAGE_D; - } - } - } - - // queue_dequeue(&wk2114->cmd_queue,NULL); // 出队 - // osMessageQueueGet(wk2114->cmd_queue ); - } - else{ // 若为数据,子串口发送 - p_sub_uart=wk2114->sub_uart[WK2114_CMD_GET_SUB_UART(cmd)]; - if(p_sub_uart==NULL){ - return -3; - } - if(WK2114_CMD_IS_READ(cmd)){ // read 1byte 0+1 - wk2114->flag|=WK2114_G_FLAG_MASK_BUSY; - size=0; - if(wk2114->cmd_queue_msg[1] < 16){ // 判断数据量 - wk2114->send_buf[0]=(cmd&0xf0)+wk2114->cmd_queue_msg[1]; - // queue_dequeue(&wk2114->cmd_queue,NULL); - } - else{ - wk2114->send_buf[0]=cmd|0x0f; - wk2114->cmd_queue_msg[1]-=16; - } - } - else{ // write - if(wk2114->cmd_queue_msg[1] < 16){ // 判断数据量 - size=wk2114->cmd_queue_msg[1]+1; - wk2114->send_buf[0]=(cmd&0xf0)+size-1; - memcpy(&wk2114->send_buf[1],p_sub_uart->send_buf,size-1); // 发送子串口的send_buf ?? size size-1 - // queue_dequeue(&wk2114->cmd_queue,NULL); - p_sub_uart->send_buf=NULL; - } - else{ - size=16; - wk2114->send_buf[0]=cmd|0x0f; - memcpy(&wk2114->send_buf[1],p_sub_uart->send_buf,size); - p_sub_uart->send_buf+=16; - wk2114->cmd_queue_msg[1]-=16; - } - } - } - return wk2114->send_fun(wk2114->send_class,wk2114->send_buf,size+1); + memset(buf, 0, size); + wk2114->idle_receive_flag = 0; + __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE); + HAL_UART_Receive_DMA(pWK2114Uart, buf, size); + return 0; } /** @@ -178,47 +62,34 @@ int wk2114_send(WK2114_TypeDef *wk2114) * @param wk2114 struct wk2114结构指针 * @param reg_addr 寄存器地址 * @return int 0:成功 负数:失败 + * @note 函数自己加上 [7:6] 这两位 */ -int wk2114_read_reg(WK2114_TypeDef *wk2114,uint8_t reg_addr) +int wk2114_read_global_reg(WK2114_TypeDef *wk2114, uint8_t reg_addr) { - int p_en; - int count; - int descriptor; - uint8_t sub_uart; - if( WK2114_REG_IS_GLOBAL(reg_addr) ){ - if(wk2114->cmd!=0){ - return -3; - } - wk2114->cmd = 0xff; - } - else{ - sub_uart=WK2114_CMD_GET_SUB_UART(reg_addr); - if(wk2114->sub_uart[sub_uart]->cmd!=0){ - return -3; - } - wk2114->sub_uart[sub_uart]->cmd=0xff; - } - // descriptor=critical_section_enter(); - // if(descriptor<0){ - // return -2; - // } - __disable_irq(); - count=queue_isempty(&wk2114->cmd_queue); - // p_en=queue_get_en_index(&wk2114->cmd_queue); - // if(p_en<0){ - // // critical_section_exit(descriptor); - // return -2; - // } - wk2114->cmd_queue_msg[0]=((WK2114_CMD_READ_REG<<6)+reg_addr); - wk2114->cmd_queue_msg[1]=0x00; - // queue_enqueue(&wk2114->cmd_queue,0); - osMessageQueuePut( wk2114->cmd_queue, (void *) wk2114->cmd_queue_msg, 0, osWaitForever ); - // critical_section_exit(descriptor); - __enable_irq(); - if(count){ - wk2114_send(wk2114); - } - return 0; + int ret; + // while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + wk2114->send_buf[0] = (WK2114_CMD_READ_REG<<6)+reg_addr ; + wk2114->send_buf[1] = 0x00; + // wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; + wk2114->timebase-osKernelGetTickCount(); + ret = wk2114->send_fun( wk2114->send_class, wk2114->send_buf, 1 ); + // wk2114->idle_receive_flag = 0; + ret = wk2114_mainport_rcv( wk2114,wk2xxx_rcvbuf,1024); + // ret = HAL_UART_Receive(pWK2114Uart, &wk2114->reg_readout, 1 , 0xFFF); + // osSemaphoreRelease(wk2xxx_lockHandle); + // while (wk2114->idle_receive_flag!=1) + // { + // if ( wk2114->timebase-osKernelGetTickCount() >300) + // { + // return -1; + // } + // } + // HAL_UART_DMAStop(pWK2114Uart); + // log_w( "wk2114_read_global_reg -> 0x%02X ret %d" , wk2114->send_buf[0] ,ret); + // osDelay(100); + return ret ; + } /** @@ -228,42 +99,82 @@ int wk2114_read_reg(WK2114_TypeDef *wk2114,uint8_t reg_addr) * @param reg_addr 寄存器地址 * @param reg 要写入的值 * @return int 0:成功 负数:失败 + * @note 队列采用值传递，没有buf, 一般无需确认在buf中的位置(数据值的数据量少) */ -int wk2114_write_reg(WK2114_TypeDef *wk2114,uint8_t reg_addr,uint8_t reg) +int wk2114_write_global_reg(WK2114_TypeDef *wk2114,uint8_t reg_addr,uint8_t reg) { - log_i( "..... wk2114_write_reg .. reg_addr %d reg %d ", reg_addr, reg); + int ret; + // while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + wk2114->send_buf[0] = (WK2114_CMD_WRITE_REG<<6)|reg_addr ; + wk2114->send_buf[1] = reg; + + // wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; + ret = wk2114->send_fun( wk2114->send_class, wk2114->send_buf, 2 ); + // osSemaphoreRelease(wk2xxx_lockHandle); + // log_w( "wk2114_write_global_reg -> 0x%02X 0x%02X " , wk2114->send_buf[0], wk2114->send_buf[1] ); + return ret ; + +} - int p_en; - int count; - // int descriptor; - // descriptor=critical_section_enter(); - // if(descriptor<0){ - // return -2; - // } - __disable_irq(); - // isempty=queue_isempty(&wk2114->cmd_queue); - count = osMessageQueueGetCount(wk2114->cmd_queue); - log_i( "..... wk2114_write_reg .. count %d wk2114->flag %d ", count, wk2114->flag); - // p_en = queue_get_en_index(&wk2114->cmd_queue); - // p_en = count; - // if(p_en<0){ - // critical_section_exit(descriptor); - // __enable_irq(); - // return -2; - // } - wk2114->cmd_queue_msg[0] = ( (WK2114_CMD_WRITE_REG<<6)+reg_addr); - wk2114->cmd_queue_msg[1] = reg; - // queue_enqueue(&wk2114->cmd_queue,0); // queue_enqueue 入队 - osMessageQueuePut( wk2114->cmd_queue, (void *) wk2114->cmd_queue_msg, 0, osWaitForever ); - // critical_section_exit(descriptor); - __enable_irq(); - // if(count){ - // log_i( "..... wk2114 send begin .. " ); - // wk2114_send(wk2114); +int wk2114_read_subuart_reg(WK2114_TypeDef *wk2114 ,enum wk2114_s_uart uart_addr,uint8_t reg_addr) +{ + int ret; + // while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + wk2114->send_buf[0] = (WK2114_CMD_READ_REG<<6)|(uart_addr<<4)|reg_addr ; + wk2114->send_buf[1] = 0x00; + // wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; + // wk2114->idle_receive_flag = 0; + + wk2114->timebase-osKernelGetTickCount(); + ret = wk2114->send_fun( wk2114->send_class, wk2114->send_buf, 1 ); + ret = wk2114_mainport_rcv( wk2114,wk2xxx_rcvbuf,1024); + // while (wk2114->idle_receive_flag!=1) + // { + // if ( wk2114->timebase-osKernelGetTickCount() >300) + // { + // // log_w( "wk2114_read_subuart_reg -> 0x%02X 0x%02X error " , uart_addr, reg_addr ); + // return -1; + // } + // } + // HAL_UART_DMAStop(pWK2114Uart); + // osSemaphoreRelease( wk2xxx_lockHandle ); + + // *readout = wk2xxx_rcvbuf[0]; + // log_d( "wk2114_read_subuart_reg -> 0x%02X ret %d 0x%02X" , wk2114->send_buf[0] , ret, wk2xxx_rcvbuf[0]); + // osDelay(200); + return ret ; + +} + + +int wk2114_write_subuart_reg(WK2114_TypeDef *wk2114,enum wk2114_s_uart uart_addr,uint8_t reg_addr,uint8_t reg) +{ + int ret; + + // while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + wk2114->send_buf[0]= (WK2114_CMD_WRITE_REG<<6)+ (uart_addr<<4) +reg_addr ; + wk2114->send_buf[1]= reg; + // if( reg_addr ==WK2114_S_REG_SPAGE ){ + // if(reg==0){ + // wk2114->sub_uart[uart_addr]->flag&=~WK2114_S_UART_FLAG_MASK_PAGE_D; + // } + // else{ + // wk2114->sub_uart[uart_addr]->flag|=WK2114_S_UART_FLAG_MASK_PAGE_D; + // } // } - wk2114_send(wk2114); - return 0; + // wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; + ret = wk2114->send_fun( wk2114->send_class, wk2114->send_buf, 2 ); + // osSemaphoreRelease(wk2xxx_lockHandle); + // while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + + // log_w( "wk2114_write_subuart_reg -> 0x%02X 0x%02X ret: %d " , wk2114->send_buf[0], wk2114->send_buf[1] , ret); + return ret ; + } + /** * @brief 内部函数 发送读取FIFO的命令 * @@ -272,31 +183,21 @@ int wk2114_write_reg(WK2114_TypeDef *wk2114,uint8_t reg_addr,uint8_t reg) * @param size 要读取的长度-1 * @return int 0:成功 负数:失败 */ -int wk2114_read_fifo(WK2114_TypeDef *wk2114,enum wk2114_s_uart sub_uart,uint8_t size) +int wk2114_read_fifo(WK2114_TypeDef *wk2114,uint8_t sub_uart,uint8_t size) { - int p_en; - int isempty; - int descriptor; + int ret; if(wk2114->sub_uart[sub_uart]==NULL){ return -1; } - descriptor=critical_section_enter(); - if(descriptor<0){ - return -2; - } - isempty=queue_isempty(&wk2114->cmd_queue); - p_en=queue_get_en_index(&wk2114->cmd_queue); - if(p_en<0){ - critical_section_exit(descriptor); - return -2; - } - wk2114->cmd_buf[p_en][0]=((WK2114_CMD_READ_FIFO<<6)+(sub_uart<<4)); - wk2114->cmd_buf[p_en][1]=size; - queue_enqueue(&wk2114->cmd_queue,0); - critical_section_exit(descriptor); - if(isempty){ - wk2114_send(wk2114); - } + while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + wk2114->send_buf[0]=((WK2114_CMD_READ_FIFO<<6)+(sub_uart<<4)) + size; + // wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; + wk2114_mainport_rcv( wk2114,wk2xxx_rcvbuf,1024); + ret = wk2114->send_fun( wk2114->send_class, wk2114->send_buf, 1); + wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; + // osSemaphoreRelease(wk2xxx_lockHandle); + return 0; } /** @@ -304,41 +205,44 @@ int wk2114_read_fifo(WK2114_TypeDef *wk2114,enum wk2114_s_uart sub_uart,uint8_t * * @param wk2114 struct wk2114结构指针 * @param sub_uart 子串口地址 - * @param buf 要发送的数据缓冲区 + * @param buf 要发送的数据缓冲区, 最大1+16， cmd_1+buf_16 * @param size 要发送的长度-1 * @return int 0:成功 负数:失败 */ -int wk2114_write_fifo(WK2114_TypeDef *wk2114,enum wk2114_s_uart sub_uart,uint8_t *buf,uint8_t size) +int wk2114_write_fifo(WK2114_TypeDef *wk2114,uint8_t sub_uart,uint8_t *buf,uint8_t size) { - int p_en; - int isempty; - int descriptor; + int ret; if(wk2114->sub_uart[sub_uart]==NULL){ return -1; } if(wk2114->sub_uart[sub_uart]->send_buf!=NULL){ return -2; } - descriptor=critical_section_enter(); - if(descriptor<0){ - return -2; - } - isempty=queue_isempty(&wk2114->cmd_queue); - p_en=queue_get_en_index(&wk2114->cmd_queue); - if(p_en<0){ - return -2; - } - wk2114->cmd_buf[p_en][0]=((WK2114_CMD_WRITE_FIFO<<6)+(sub_uart<<4)); - wk2114->cmd_buf[p_en][1]=size; - wk2114->sub_uart[sub_uart]->send_buf=buf; - queue_enqueue(&wk2114->cmd_queue,0); - critical_section_exit(descriptor); - if(isempty){ - wk2114_send(wk2114); - } + while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + + // send_buf[0] = writeFifo + subuart +size + wk2114->send_buf[0] = (WK2114_CMD_WRITE_FIFO<<6)+(sub_uart<<4) + size; + memcpy( &wk2114->send_buf[1], buf, size+1 ); + + wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; + ret = wk2114->send_fun( wk2114->send_class, wk2114->send_buf, size+2); + + // osSemaphoreRelease(wk2xxx_lockHandle); + while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + return 0; +} + +int wk2114_reset(WK2114_TypeDef *wk2114) +{ + HAL_GPIO_WritePin(WK2XXX_IRQ_GPIO_PORT, WK2XXX_RST_PIN,GPIO_PIN_RESET); + osDelay(1); + HAL_GPIO_WritePin(WK2XXX_IRQ_GPIO_PORT, WK2XXX_RST_PIN,GPIO_PIN_SET); + osDelay(1); return 0; } + /** * @brief 设置主串口波特率 * @note 此函数会被 \ref wk2114_init() 函数间接调用,一般不需要手动调用 @@ -352,6 +256,15 @@ int wk2114_set_baud(WK2114_TypeDef *wk2114) return wk2114->send_fun(wk2114->send_class,&init_buf,1); } +int wk2114_test(WK2114_TypeDef *wk2114) +{ + uint8_t writein = 0x40 ; + wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; + return wk2114->send_fun(wk2114->send_class,&writein,1); +} + + + /** * @brief 内部函数 设置子串口寄存器页 * @@ -368,7 +281,7 @@ int wk2114_sub_uart_set_page(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t page) if(((sub_uart->flag&WK2114_S_UART_FLAG_MASK_PAGE)!=0)==page){ return 0; } - ret=wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_SPAGE),page); + ret=wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index,WK2114_S_REG_SPAGE ,page); if(ret<0){ return ret; } @@ -388,17 +301,19 @@ int wk2114_sub_uart_set_page(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t page) */ int wk2114_flush_gena(WK2114_TypeDef *wk2114) { - log_i( "..... wk2114_flush_gena .. "); - uint8_t reg; int i; reg=0; - for(i=0;i<4;i++){ - if(wk2114->sub_uart[i]!=NULL && (wk2114->sub_uart[i]->flag&WK2114_S_UART_FLAG_MASK_ENABLE)!=0){ - reg|=(1<sub_uart[i]!=NULL ) + { + if ( (wk2114->sub_uart[i]->flag&WK2114_S_UART_FLAG_MASK_ENABLE)!=0) + { + reg|=(1<wk2114->dev_clock_hz*100/16/buad; + uint16_t baud_div; + tmp=sub_uart->wk2114->dev_clock_hz*100/16/baud; if(tmp<10){ return -1; } - buad_div=tmp/100-1; - if(wk2114_sub_uart_set_page(sub_uart,1)<0){ + baud_div=tmp/100-1; + if(wk2114_sub_uart_set_page(sub_uart,1)<0){ // 03 01 return -2; } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_BUAD1),buad_div>>8)<0){ + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_BAUD1 ,baud_div>>8)<0){ // 04 00 return -2; } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_BUAD0),buad_div&0xff)<0){ + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index,WK2114_S_REG_BAUD0 ,baud_div&0xff)<0){ //05 05 return -2; } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_PRES),(tmp/10)%10)<0){ + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_PRES ,(tmp/10)%10)<0){ // 06 05 return -2; } - if(wk2114_sub_uart_set_page(sub_uart,0)<0){ + if(wk2114_sub_uart_set_page(sub_uart,0)<0){ // 03 00 return -2; } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_LCR),party|stop_bits)<0){ + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_LCR ,party|stop_bits)<0){ // 0500 return -2; } + return 0; } /** @@ -479,10 +397,11 @@ int wk2114_set_sub_uart(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t buad,enum wk21 */ int wk2114_sub_uart_set_inter(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t inter_flag) { - if(wk2114_sub_uart_set_page(sub_uart,0)<0){ + if( wk2114_sub_uart_set_page(sub_uart,0)<0 ){ return -2; - } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_SIER),inter_flag)<0){ + } + if( wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_SIER ,inter_flag)<0 ){ + // log_i("wk2114_sub_uart_set_inter write") return -2; } return 0; @@ -499,7 +418,7 @@ int wk2114_sub_uart_set_mode(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t mode) if(wk2114_sub_uart_set_page(sub_uart,0)<0){ return -2; } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_SCR),mode)<0){ + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_SCR, mode)<0){ return -2; } return 0; @@ -517,10 +436,10 @@ int wk2114_sub_uart_set_fifo_trigger(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t tx if(wk2114_sub_uart_set_page(sub_uart,1)<0){ return -2; } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_TFTL),tx_trigger)<0){ + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_TFTL ,tx_trigger)<0){ return -2; } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_RFTL),rx_trigger)<0){ + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_RFTL,rx_trigger)<0){ return -2; } return 0; @@ -537,7 +456,7 @@ int wk2114_sub_uart_set_fifo_mode(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t mode) if(wk2114_sub_uart_set_page(sub_uart,0)<0){ return -2; } - if(wk2114_write_reg(sub_uart->wk2114,WK2114_BUILD_SUB_REG(sub_uart->uart_index,WK2114_S_REG_FCR),mode)<0){ + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index,WK2114_S_REG_FCR ,mode)<0){ return -2; } return 0; @@ -549,9 +468,7 @@ int wk2114_sub_uart_set_fifo_mode(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t mode) * @return int 成功:0 失败:负值 */ int wk2114_sub_uart_enable(WK2114_Sub_Uart_TypeDef*sub_uart) -{ - log_i( "..... wk2114_sub_uart_enable .. "); - +{ sub_uart->flag|=WK2114_S_UART_FLAG_MASK_ENABLE; return wk2114_flush_gena(sub_uart->wk2114); } @@ -574,42 +491,49 @@ int wk2114_sub_uart_disable(WK2114_Sub_Uart_TypeDef*sub_uart) */ int wk2114_sub_uart_reset(WK2114_Sub_Uart_TypeDef*sub_uart) { - return wk2114_write_reg(sub_uart->wk2114,WK2114_G_REG_GRST,1<uart_index); + return wk2114_write_global_reg(sub_uart->wk2114,WK2114_G_REG_GRST,1<uart_index); } /** * @brief 通过子串口向外发送数据 * @note buf参数指向的缓冲区在发送完成之前不能改变 * @param sub_uart 子串口结构 - * @param buf 要发送的数据缓冲区 + * @param buf 要发送的数据缓冲区 ， buf无需限制在FIFO的16bytes * @param size 要发送的长度 * @return int 成功:0 失败:负值 */ -int wk2114_sub_uart_send(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t *buf,uint32_t size) +int wk2114_sub_uart_send( WK2114_Sub_Uart_TypeDef*sub_uart, uint8_t *buf, uint32_t size ) { - int p_en; - int isimpty; - int descriptor; - descriptor=critical_section_enter(); - if(descriptor<0){ - return -2; - } - isimpty=queue_isempty(&sub_uart->send_queue); - p_en=queue_get_en_index(&sub_uart->send_queue); - if(p_en<0){ - critical_section_exit(descriptor); - return -2; - } - sub_uart->send_record[p_en].p_data=buf; - sub_uart->send_record[p_en].size=size; - queue_enqueue(&sub_uart->send_queue,0); - critical_section_exit(descriptor); - if(isimpty){ - return wk2114_sub_uart_set_inter(sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFTRIG_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); - } - return 0; + // TODO 发送结束后 会出现不能启动下次发送外部中断, 复位串口？？ + log_i("wk2114_sub_uart_send >> state %d ", wk2114->state); + int count; + int st; + uint8_t reg; + reg = WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT| + WK2114_S_REG_SIFR_MASK_TFTRIG_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT; + + osSemaphoreAcquire(wk2xxx_sub_lockHandle, osWaitForever); + count = osMessageQueueGetCount( sub_uart->send_queue ); + sub_uart->send_record[count].p_data = buf; + sub_uart->send_record[count].size = size; + osMessageQueuePut( sub_uart->send_queue, (void*) &sub_uart->send_record_p, 0, portMAX_DELAY ); // 指针 + sub_uart->send_record_p = (sub_uart->send_record_p+1)%8; + osSemaphoreRelease(wk2xxx_sub_lockHandle); + + // 启用子串口中断， 发送为空中断触发子串口队列发送 + // TODO 启动中断，可能不会产生外部中断卡死， 可以直接启动发送队列 + + if( count!=0 ) return 0; + + st = wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_SIER , reg); + // while( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + + osSemaphoreRelease(wk2xxx_lockHandle); + return st; + } /** - * @brief 判断子串口是否忙 + * @brief 判断子串口是否忙，判断子串口队列子串口buff * * @param sub_uart 子串口结构 * @return int -1:出错 0:不忙 1:忙 @@ -619,38 +543,15 @@ int wk2114_sub_uart_isbusy(WK2114_Sub_Uart_TypeDef*sub_uart) if(sub_uart==NULL){ return -1; } - return !queue_isempty(&sub_uart->send_queue)||sub_uart->send_buf!=NULL; + if (osMessageQueueGetCount(wk2114EventHandle) >0 ){ + return 1; + } + if (sub_uart->send_buf!=NULL) { + return 1; + } + return 0; } -/** - * @brief wk2114初始化 - * - * @param wk2114 WK2114_TypeDef 结构指针 - * @param dev_clock_hz wk2114的时钟源频率 - * @param send_class 发送函数的第一个参数 - * @param send_fun 发送函数 - * @return struct wk2114* 成功:wk2114 失败:NULL - */ -// WK2114_TypeDef * wk2114_init(WK2114_TypeDef *wk2114,uint32_t dev_clock_hz,void *send_class,wk2114_send_fun send_fun) -// { -// int i; -// if(wk2114==NULL || send_class==NULL || send_fun==NULL || dev_clock_hz>32000000 || dev_clock_hz<1000000){ -// return NULL; -// } -// if(queue_init(&wk2114->cmd_queue,NULL,64)==NULL){ -// return NULL; -// } -// wk2114->send_class=send_class; -// wk2114->send_fun=send_fun; -// wk2114->flag=0; -// wk2114->dev_clock_hz=dev_clock_hz; -// for(i=0;i<4;i++){ -// wk2114->sub_uart[0]=NULL; -// } -// if(wk2114_set_baud(wk2114)<0){ -// return NULL; -// }; -// return wk2114; -// } + /** * @brief 注册子串口 * @@ -665,275 +566,874 @@ int wk2114_sub_uart_isbusy(WK2114_Sub_Uart_TypeDef*sub_uart) */ int wk2114_sub_uart_register(WK2114_TypeDef *wk2114,WK2114_Sub_Uart_TypeDef*sub_uart,enum wk2114_s_uart uart_addr,uint8_t *recv_buf,uint32_t recv_buf_size,void *recv_class,wk2114_sub_uart_recv_fun recv_fun) { - log_i( ".....wk2114_sub_uart_register.. " ); - // if(wk2114==NULL || sub_uart==NULL || recv_class==NULL || recv_fun==NULL || uart_addr<0 || uart_addr>=4 || recv_buf==NULL || recv_buf_size<16){ - // return -1; - // } - // // TODO - // sub_uart->send_queue = osMessageQueueNew(8, sizeof(struct wk2114_send_record) ,NULL); - // if (sub_uart->send_queue ==NULL) return -2; - // // if(queue_init(&sub_uart->send_queue,NULL,8)==NULL){ - // // return -2; - // // } - // if(wk2114->sub_uart[uart_addr]!=NULL){ - // return -3; + // log_i( ".....wk2114_sub_uart_register.. addr %d ",uart_addr ); + if(wk2114==NULL || sub_uart==NULL || recv_class==NULL || recv_fun==NULL || uart_addr<0 || uart_addr>=4 || recv_buf==NULL || recv_buf_size<16){ + return -1; + } + // TODO 指针传递 + sub_uart->send_queue = osMessageQueueNew(8, sizeof(struct wk2114_send_record *) ,NULL); + if ( sub_uart->send_queue ==NULL ) return -2; + // if(queue_init(&sub_uart->send_queue,NULL,8)==NULL){ + // return -2; // } - // sub_uart->recv_class=recv_class; - // sub_uart->recv_fun=recv_fun; - // sub_uart->recv_buf=recv_buf; - // sub_uart->recv_buf_size=recv_buf_size; - // sub_uart->recv_buf_p=0; - // sub_uart->wk2114=wk2114; - // sub_uart->flag=0; - // sub_uart->cmd=0; - // sub_uart->reg=0; - // sub_uart->uart_index=uart_addr; - // sub_uart->send_buf_p=0; - // sub_uart->send_buf=NULL; - // wk2114->sub_uart[uart_addr]=sub_uart; - // log_i( ".....wk2114_sub_uart_register.. wk2114->flag %d " , wk2114->flag); - return 0; -}/** - * @brief 更改子串口接收回调函数 - * - * @param sub_uart 子串口结构 - * @param recv_class 接受回调函数的第一个参数 - * @param recv_fun 接收回调函数 - * @return int 成功:0 失败:负值 - */ -int wk2114_sub_uart_chenge_recv_fun(WK2114_Sub_Uart_TypeDef*sub_uart,void *recv_class,wk2114_sub_uart_recv_fun recv_fun) -{ - if(sub_uart==NULL || recv_class==NULL || recv_fun==NULL){ - return -1; + if(wk2114->sub_uart[uart_addr]!=NULL){ + return -3; } + sub_uart->recv_class=recv_class; sub_uart->recv_fun=recv_fun; + sub_uart->recv_buf=recv_buf; + sub_uart->recv_buf_size=recv_buf_size; + sub_uart->recv_buf_p=0; + sub_uart->wk2114=wk2114; + sub_uart->flag=0; + sub_uart->cmd=0; + sub_uart->reg=0; + sub_uart->uart_index=uart_addr; + sub_uart->send_buf_p=0; // ?? 0 or 0xffffffff + sub_uart->send_buf=NULL; + sub_uart->send_record_p=0; + wk2114->sub_uart[uart_addr]=sub_uart; + return 0; } + /** * @brief 子串口初始化 * * @param sub_uart 子串口结构 - * @param buad 波特率 + * @param baud 波特率 * @param mode 模式 WK2114_SUB_UART_MODE_MASK_XXX 的任意结合 * @param fifo_mode FIFO模式 WK2114_SUB_UART_FIFO_MODE_MASK_XXX 的任意结合 * @param party 校验 * @param stop_bits 停止位 * @return int 成功:0 失败:负值 */ -int wk2114_sub_uart_init(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t buad,uint8_t mode,uint8_t fifo_mode,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits) +int wk2114_sub_uart_init(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t baud,uint8_t mode,uint8_t fifo_mode,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits) { - log_i( "wk2114_sub_uart_init .. %d " , wk2114->flag); - if(wk2114_sub_uart_enable(sub_uart)<0){ + uint32_t tmp; + uint16_t baud_div; + uint8_t reg = 0; + tmp=sub_uart->wk2114->dev_clock_hz*100/16/baud; + if(tmp<10){ return -1; } - // if(wk2114_sub_uart_reset(sub_uart)<0){ - // return -1; - // } - // if(wk2114_flush_gier(sub_uart->wk2114)<0){ - // return -1; - // } - // if(wk2114_set_sub_uart(sub_uart,buad,party,stop_bits)<0){ - // return -1; - // } - // if(wk2114_sub_uart_set_fifo_trigger(sub_uart,128,128)<0){ - // return -1; - // } - // if(wk2114_sub_uart_set_inter(sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT)<0){ - // return -1; - // } - // if(wk2114_sub_uart_set_fifo_mode(sub_uart,fifo_mode)<0){ - // return -1; - // } - // if(wk2114_sub_uart_set_mode(sub_uart,mode)<0){ - // return -1; - // } - return 0; -} -/** - * @brief 内部函数 接收寄存器回调 - * - * @param wk2114 WK2114_TypeDef 结构指针 - */ -void wk2114_reg_recv_callback(WK2114_TypeDef *wk2114) -{ - int i; - int p_de; - if(WK2114_CMD_GET_ADDR(wk2114->cmd)==WK2114_G_REG_GIFR){ - wk2114->cmd=0; - if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT1INT)!=0 && wk2114->sub_uart[WK2114_S_UART_1]!=NULL){ - wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_1,WK2114_S_REG_SIFR)); - } - if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT2INT)!=0 && wk2114->sub_uart[WK2114_S_UART_2]!=NULL){ - wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_2,WK2114_S_REG_SIFR)); - } - if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT3INT)!=0 && wk2114->sub_uart[WK2114_S_UART_3]!=NULL){ - wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_3,WK2114_S_REG_SIFR)); - } - if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT4INT)!=0 && wk2114->sub_uart[WK2114_S_UART_4]!=NULL){ - wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_4,WK2114_S_REG_SIFR)); + baud_div=tmp/100-1; + for(int i=0;i<4;i++){ + if(wk2114->sub_uart[i]!=NULL){ + reg|=(1<sub_uart[i]!=NULL && (wk2114->sub_uart[i]->flag&WK2114_S_UART_FLAG_MASK_PAGE_D)==0){ - if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_SIFR)){ - wk2114->sub_uart[i]->cmd=0; - if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_RXOVT_INT)!=0){ - wk2114->sub_uart[i]->flag|=WK2114_S_UART_FLAG_MASK_IDLE; - wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(i,WK2114_S_REG_RFCNT)); - } - else if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_RFTRIG_INT)!=0){ - wk2114_read_fifo(wk2114,i,126); - } - if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_TFEMPTY_INT)!=0 && wk2114->sub_uart[i]->send_buf_p==0xffffffff){ // 发送FIFO触点空中断 发送下一个字符串 - wk2114->sub_uart[i]->send_buf_p=0; - p_de=queue_get_de_index(&wk2114->sub_uart[i]->send_queue); - if(p_de>=0){ - if(wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p <= 256){ - wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p-1); - wk2114->sub_uart[i]->send_buf_p=0xffffffff; - queue_dequeue(&wk2114->sub_uart[i]->send_queue,NULL); - } - else{ - wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],255); - wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFTRIG_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); - wk2114->sub_uart[i]->send_buf_p+=256; - } - } - else{ - wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); - } - } - else if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_TFTRIG_INT)!=0){ // 发送FIFO触点中断 发送同一个字符串 - p_de=queue_get_de_index(&wk2114->sub_uart[i]->send_queue); - if(p_de>=0){ - if(wk2114->sub_uart[i]->send_buf_p >= wk2114->sub_uart[i]->send_record[p_de].size){ - wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); - wk2114->sub_uart[i]->send_buf_p=0xffffffff; - return; - } - if(wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p <= 128){ - wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p-1); - wk2114->sub_uart[i]->send_buf_p=0xffffffff; - wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); - queue_dequeue(&wk2114->sub_uart[i]->send_queue,NULL); - } - else{ - wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],127); - wk2114->sub_uart[i]->send_buf_p+=128; - } - } - else{ - wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); - } - } - if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_FERR_INT)!=0){ - wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(i,WK2114_S_REG_LSR)); - } - } - else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_RFCNT)){ - wk2114->sub_uart[i]->cmd=0; - wk2114_read_fifo(wk2114,i,wk2114->sub_uart[i]->reg-1); - } - else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_LSR)){ - wk2114->sub_uart[i]->cmd=0; - wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(i,WK2114_S_REG_FSR)); - } - else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_FSR)){ - wk2114->sub_uart[i]->cmd=0; - } - } + // 子串口使能 00 01 + sub_uart->flag|=WK2114_S_UART_FLAG_MASK_ENABLE; + wk2114_write_global_reg(wk2114,WK2114_G_REG_GENA,reg); + HAL_Delay(0) ; + + // 子串口复位寄存器 01 01 + wk2114_write_global_reg(sub_uart->wk2114,WK2114_G_REG_GRST,1<uart_index); + HAL_Delay(0) ; + + // 子串口中断使能 10 01 //10 03 / 10 07 / 10 0F + wk2114_write_global_reg(wk2114,WK2114_G_REG_GIER,reg); + HAL_Delay(0) ; + + // 子串口baud 03 01 04 00 05 05 06 05 03 00 05 00 /054D0601 9600 + + // 切换子串口设置页面 1 + if(wk2114_sub_uart_set_page(sub_uart,1)<0){ // 03 01 + return -2; + } + HAL_Delay(0) ; + // + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_BAUD1 ,baud_div>>8)<0){ // 04 00 + return -2; + } + HAL_Delay(0) ; + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index,WK2114_S_REG_BAUD0 ,baud_div&0xff)<0){ //05 05 + return -2; + } + HAL_Delay(0) ; + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_PRES ,(tmp/10)%10)<0){ // 06 05 + return -2; + } + HAL_Delay(0) ; + if(wk2114_sub_uart_set_page(sub_uart,0)<0){ // 03 00 + return -2; + } + HAL_Delay(0) ; + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_LCR ,party|stop_bits)<0){ // 0500 + return -2; + } + HAL_Delay(0) ; + + // 发送 和接收 触点中断数设置为 128 128 // 03 01 08 80 07 80 + if(wk2114_sub_uart_set_page(sub_uart,1)<0){ + return -2; + } + HAL_Delay(0) ; + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_TFTL ,16)<0){ + return -2; } - return; + HAL_Delay(0) ; + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_RFTL,128)<0){ + return -2; + } + HAL_Delay(0) ; + if(wk2114_sub_uart_set_page(sub_uart,0)<0){ + return -2; + } + HAL_Delay(0) ; + + // 07 83 设置发送中断 + if( wk2114_write_subuart_reg(sub_uart->wk2114, + sub_uart->uart_index, + WK2114_S_REG_SIER , + WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT) + <0 ){ + // log_i("wk2114_sub_uart_set_inter write") + return -2; + } + HAL_Delay(0) ; + + //06 0C fifo Mode + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index,WK2114_S_REG_FCR ,fifo_mode)<0){ + return -2; + } + HAL_Delay(0) ; + + // 04 03 mode 子串口rx tx + if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_SCR, mode)<0){ + return -2; + } + return 0; } + /** - * @brief wk2114接收回调 + * @brief 更改子串口接收回调函数 * - * @param wk2114 WK2114_TypeDef 结构指针 - * @param buf 接收到的数据缓冲区 - * @param size 接收到的数据长度 - */ -void wk2114_recv_callback(WK2114_TypeDef *wk2114,uint8_t *buf,uint32_t size) -{ - int p_de; - uint8_t cmd; - uint8_t cmd_size; - uint8_t sub_uart; - WK2114_Sub_Uart_TypeDef*p_sub_uart; - cmd=wk2114->send_buf[0]; - wk2114->send_buf[0]=0; - cmd_size=WK2114_CMD_GET_SIZE(cmd); - sub_uart=WK2114_CMD_GET_SUB_UART(cmd); - p_sub_uart=wk2114->sub_uart[sub_uart]; - if(WK2114_CMD_IS_WRITE(cmd)){ - return; - } - if(WK2114_CMD_IS_REG(cmd)){ // 读寄存器 - if(size!=1){ - return; - } - if(WK2114_REG_IS_GLOBAL(cmd_size)){ // 全局寄存器 - if(wk2114->cmd!=0xff){ - return; - } - wk2114->cmd=cmd; - wk2114->reg=buf[0]; - } - else{ // 子串口寄存器 - if(p_sub_uart==NULL || wk2114->sub_uart[sub_uart]->cmd!=0xff){ - return; - } - p_sub_uart->cmd=cmd; - p_sub_uart->reg=buf[0]; - } - wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY; - wk2114_reg_recv_callback(wk2114); - return; - } - if(size!=cmd_size){ - return; - } - if(p_sub_uart->recv_buf_size-p_sub_uart->recv_buf_p < size){ - cmd_size=p_sub_uart->recv_buf_size-p_sub_uart->recv_buf_p; - } - memcpy(&p_sub_uart->recv_buf[p_sub_uart->recv_buf_p],buf,cmd_size); - p_sub_uart->recv_buf_p+=cmd_size; - p_de=queue_get_de_index(&wk2114->cmd_queue); - if((p_de<0 || (wk2114->cmd_buf[p_de][0]&0xf0)!=(cmd&0xf0)) && (p_sub_uart->flag&WK2114_S_UART_FLAG_MASK_IDLE)==1){ // 接收超时 - p_sub_uart->flag&=~WK2114_S_UART_FLAG_MASK_IDLE; - p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); - p_sub_uart->recv_buf_p=0; - } - else if(p_sub_uart->recv_buf_p==p_sub_uart->recv_buf_size) // 缓冲区满 - { - p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); - p_sub_uart->recv_buf_p=size-cmd_size; - memcpy(p_sub_uart->recv_buf,&buf[cmd_size],p_sub_uart->recv_buf_p); - } - wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY; -} -/** - * @brief wk2114中断回调 - * @note 不要将此函数放入中断中或比其他回调函数优先级更改的任务中 - * @param wk2114 WK2114_TypeDef 结构指针 + * @param sub_uart 子串口结构 + * @param recv_class 接受回调函数的第一个参数 + * @param recv_fun 接收回调函数 + * @return int 成功:0 失败:负值 */ -void wk2114_inter_callback(WK2114_TypeDef *wk2114) +int wk2114_sub_uart_chenge_recv_fun(WK2114_Sub_Uart_TypeDef*sub_uart,void *recv_class,wk2114_sub_uart_recv_fun recv_fun) { - if((wk2114->flag&WK2114_G_FLAG_MASK_INTER)!=0){ - return; + if(sub_uart==NULL || recv_class==NULL || recv_fun==NULL){ + return -1; } - wk2114->flag|=WK2114_G_FLAG_MASK_INTER; - wk2114_read_reg(wk2114,WK2114_G_REG_GIFR); + sub_uart->recv_class=recv_class; + sub_uart->recv_fun=recv_fun; + return 0; } -/** - * @brief wk2114发送完成回调 - * - * @param wk2114 WK2114_TypeDef 结构指针 - */ -void wk2114_send_completed_callback(WK2114_TypeDef *wk2114) -{ - wk2114->flag&=~WK2114_G_FLAG_MASK_SENDING; - wk2114_send(wk2114); -} \ No newline at end of file + + +// void wk2114_idle_callback(WK2114_TypeDef *wk2114, uint8_t *buf, uint32_t size) +// { +// // log_w( " wk2114_idle_callback .... %d ", wk2114->state ); +// wk2114->idle_receive_flag = 1; +// wk2114->size_received = size; +// // if (wk2114->state == WK2114_WORK_STATE_SET_BAUD) +// // { +// // if (wk2114->size_received == 1 && wk2xxx_rcvbuf[0] == 0) +// // { +// // log_d("0x55 ok rcv , byte_0 0x%02X", wk2xxx_rcvbuf[0] ); +// // wk2114->setbaud_ok = 1; +// // } +// // } +// // if (wk2114->state == WK2114_WORK_STATE_SEND_40_RCV_F0_OK) +// // { +// // if (wk2114->size_received == 1 && wk2xxx_rcvbuf[0] == 0xF0) +// // { +// // log_d("0x40 ok rcv , byte_0 0x%02X", wk2xxx_rcvbuf[0] ); +// // wk2114->senf40_rcvF0_ok = 1; +// // } +// // } +// // if (wk2114->state == WK2114_WORK_STATE_OK) +// // { +// // if (wk2114->size_received == 1 ) wk2114->idle_receive_flag = 1; +// // } +// // if (wk2114->state == WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT) +// // { +// // log_d("size %d byte_0 0x%02X",size,wk2xxx_rcvbuf[0]); +// // // if (wk2114->size_received == 1 ) wk2114->idle_receive_flag = 1; +// // } + +// return; +// } + +// /** +// * @brief 内部函数 接收寄存器回调 +// * +// * @param wk2114 WK2114_TypeDef 结构指针 +// * @note WK2114_G_REG_GIFR 判断哪个子串口中断，然后 子串口 WK2114_S_REG_SIFR 中断类型 +// */ +// void wk2114_reg_recv_callback(WK2114_TypeDef *wk2114) +// { +// int i; +// int p_de; +// if(WK2114_CMD_GET_ADDR(wk2114->cmd)==WK2114_G_REG_GIFR){ // 去读子串口中断类型 +// wk2114->cmd=0; +// if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT1INT)!=0 && wk2114->sub_uart[WK2114_S_UART_1]!=NULL){ +// wk2114_read_subuart_reg(wk2114, WK2114_S_UART_1, WK2114_S_REG_SIFR ); +// } +// if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT2INT)!=0 && wk2114->sub_uart[WK2114_S_UART_2]!=NULL){ +// wk2114_read_subuart_reg(wk2114, WK2114_S_UART_2,WK2114_S_REG_SIFR ); +// } +// if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT3INT)!=0 && wk2114->sub_uart[WK2114_S_UART_3]!=NULL){ +// wk2114_read_subuart_reg(wk2114, WK2114_S_UART_3, WK2114_S_REG_SIFR ); +// } +// if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT4INT)!=0 && wk2114->sub_uart[WK2114_S_UART_4]!=NULL){ +// wk2114_read_subuart_reg(wk2114, WK2114_S_UART_4, WK2114_S_REG_SIFR ); +// } +// return; +// } + +// // 判断中断类型 +// for(i=0;i<4;i++){ +// if(wk2114->sub_uart[i]!=NULL && (wk2114->sub_uart[i]->flag&WK2114_S_UART_FLAG_MASK_PAGE_D)==0){ +// if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_SIFR)){ // WK2114_S_REG_SIFR 子串口中断标志寄存器 +// wk2114->sub_uart[i]->cmd=0; +// if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_RXOVT_INT)!=0){ +// wk2114->sub_uart[i]->flag|=WK2114_S_UART_FLAG_MASK_IDLE; +// wk2114_read_subuart_reg(wk2114, i,WK2114_S_REG_RFCNT ); +// } +// else if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_RFTRIG_INT)!=0){ +// wk2114_read_fifo(wk2114,i,126); +// } +// if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_TFEMPTY_INT)!=0 && wk2114->sub_uart[i]->send_buf_p==0xffffffff){ // 发送FIFO触点空中断 发送下一个字符串 +// wk2114->sub_uart[i]->send_buf_p=0; +// // 判断 子串口的 发送队列是否为空 +// // p_de=queue_get_de_index(&wk2114->sub_uart[i]->send_queue); +// // if(p_de>=0){ +// if (osMessageQueueGetCount(wk2114->sub_uart[i]->send_queue) >= 0){ +// if(wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p <= 256){ +// struct wk2114_send_record record; +// osMessageQueueGet(wk2114->sub_uart[i]->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); +// wk2114_write_fifo(wk2114,i,record.p_data[wk2114->sub_uart[i]->send_buf_p],record.size-wk2114->sub_uart[i]->send_buf_p-1); +// // wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p-1); +// wk2114->sub_uart[i]->send_buf_p=0xffffffff; +// // queue_dequeue(&wk2114->sub_uart[i]->send_queue,NULL); +// } +// else{ +// wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],255); +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFTRIG_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// wk2114->sub_uart[i]->send_buf_p+=256; +// } +// } +// else{ +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// } +// } +// else if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_TFTRIG_INT)!=0){ // 发送FIFO触点中断 发送同一个字符串 +// // p_de=queue_get_de_index(&wk2114->sub_uart[i]->send_queue); +// // if(p_de>=0){ +// if (osMessageQueueGetCount(wk2114->sub_uart[i]->send_queue) >= 0){ +// if(wk2114->sub_uart[i]->send_buf_p >= wk2114->sub_uart[i]->send_record[p_de].size){ +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// wk2114->sub_uart[i]->send_buf_p=0xffffffff; +// return; +// } +// if(wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p <= 128){ +// struct wk2114_send_record record; +// osMessageQueueGet(wk2114->sub_uart[i]->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); +// wk2114_write_fifo(wk2114,i,record.p_data[wk2114->sub_uart[i]->send_buf_p],record.size-wk2114->sub_uart[i]->send_buf_p-1); + +// // wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p-1); +// wk2114->sub_uart[i]->send_buf_p=0xffffffff; +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// // queue_dequeue(&wk2114->sub_uart[i]->send_queue,NULL); +// } +// else{ +// wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],127); +// wk2114->sub_uart[i]->send_buf_p+=128; +// } +// } +// else{ +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// } +// } +// if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_FERR_INT)!=0){ +// wk2114_read_subuart_reg(wk2114, i, WK2114_S_REG_LSR ); +// } +// } +// else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_RFCNT)){ +// wk2114->sub_uart[i]->cmd=0; +// wk2114_read_fifo(wk2114,i,wk2114->sub_uart[i]->reg-1); +// } +// else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_LSR)){ +// wk2114->sub_uart[i]->cmd=0; +// wk2114_read_subuart_reg(wk2114, i, WK2114_S_REG_FSR ); +// } +// else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_FSR)){ +// wk2114->sub_uart[i]->cmd=0; +// } +// } +// } +// return; +// } + +// void wk2114_idle_callback(WK2114_TypeDef *wk2114,uint8_t *buf,uint32_t size) +// { +// log_w( " wk2114_idle_callback ...., "); +// wk2114->size_received = size; +// switch (wk2114->state) +// { +// case WK2114_WORK_STATE_EXTI_READ_IT_SOURCE: +// // osThreadSuspend(wk2114Handle ); +// wk2114->state = WK2114_WORK_STATE_EXTI_READ_IT_SOURCE_OK; +// // osThreadResume(wk2114Handle ); +// return; +// case WK2114_WORK_STATE_EXTI_READ_IT_TYPE: +// log_w( " wk2114_idle_callback READ_IT_TYPE ...., "); +// // osThreadSuspend(wk2114Handle ); +// wk2114->state = WK2114_WORK_STATE_EXTI_READ_IT_TYPE_OK; +// // osThreadResume(wk2114Handle ); +// return; +// case WK2114_WORK_STATE_EXTI_PROCESS_DATA: +// log_w( " wk2114_idle_callback PROCESS_DATA ...., "); +// // osThreadSuspend(wk2114Handle ); +// wk2114->state = WK2114_WORK_STATE_EXTI_PROCESS_DATA_OK; +// // osThreadResume(wk2114Handle ); +// return; +// default: +// break; +// } +// } + + +// /** +// * @brief wk2114接收回调 读FIFO +// * +// * @param wk2114 WK2114_TypeDef 结构指针 +// * @param buf 接收到的数据缓冲区 +// * @param size 接收到的数据长度 +// */ +// void wk2114_recv_callback(WK2114_TypeDef *wk2114,uint8_t *buf,uint32_t size) +// { +// int p_de; +// uint8_t cmd; +// uint8_t cmd_size; +// uint8_t sub_uart; +// WK2114_Sub_Uart_TypeDef*p_sub_uart; +// cmd=wk2114->send_buf[0]; +// wk2114->send_buf[0]=0; +// cmd_size=WK2114_CMD_GET_SIZE(cmd); // 命令要读取的数量 +// sub_uart=WK2114_CMD_GET_SUB_UART(cmd); +// p_sub_uart=wk2114->sub_uart[sub_uart]; +// if(WK2114_CMD_IS_WRITE(cmd)){ +// return; +// } +// if(WK2114_CMD_IS_REG(cmd)){ // 读寄存器 +// if(size!=1){ +// return; +// } +// if(WK2114_REG_IS_GLOBAL(cmd_size)){ // 全局寄存器， 重写wk2114的 cmd reg +// if(wk2114->cmd!=0xff){ +// return; +// } +// wk2114->cmd=cmd; +// wk2114->reg=buf[0]; +// } +// else{ // 子串口寄存器, 重写子串口的 cmd reg +// if(p_sub_uart==NULL || wk2114->sub_uart[sub_uart]->cmd!=0xff){ +// return; +// } +// p_sub_uart->cmd=cmd; +// p_sub_uart->reg=buf[0]; +// } +// wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; +// wk2114_reg_recv_callback(wk2114); +// return; +// } + +// // 读数据回调 +// if(size!=cmd_size){ // 命令读取数量和实际读取数量不一致 +// return; +// } +// if(p_sub_uart->recv_buf_size-p_sub_uart->recv_buf_p < size){ // subuart buf 空间不足 +// cmd_size=p_sub_uart->recv_buf_size-p_sub_uart->recv_buf_p; +// } +// memcpy(&p_sub_uart->recv_buf[p_sub_uart->recv_buf_p],buf,cmd_size); +// p_sub_uart->recv_buf_p+=cmd_size; + +// // 判断 发送队列是否为空，或缓冲区满，数据进一步回调 +// if ( osMessageQueueGetCount(wk2114->cmd_queue) == 0 && (p_sub_uart->flag&WK2114_S_UART_FLAG_MASK_IDLE)==1 ) +// { +// p_sub_uart->flag&=~WK2114_S_UART_FLAG_MASK_IDLE; +// p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); +// p_sub_uart->recv_buf_p=0; +// } +// if(p_sub_uart->recv_buf_p==p_sub_uart->recv_buf_size) // 缓冲区满 +// { +// p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); +// p_sub_uart->recv_buf_p=size-cmd_size; +// memcpy(p_sub_uart->recv_buf,&buf[cmd_size],p_sub_uart->recv_buf_p); +// } +// wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; + +// // p_de=queue_get_de_index(&wk2114->cmd_queue); +// // if((p_de<0 || (wk2114->cmd_buf[p_de][0]&0xf0)!=(cmd&0xf0)) && (p_sub_uart->flag&WK2114_S_UART_FLAG_MASK_IDLE)==1){ // 接收超时 +// // p_sub_uart->flag&=~WK2114_S_UART_FLAG_MASK_IDLE; +// // p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); +// // p_sub_uart->recv_buf_p=0; +// // } +// // else if(p_sub_uart->recv_buf_p==p_sub_uart->recv_buf_size) // 缓冲区满 +// // { +// // p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); +// // p_sub_uart->recv_buf_p=size-cmd_size; +// // memcpy(p_sub_uart->recv_buf,&buf[cmd_size],p_sub_uart->recv_buf_p); +// // } +// // wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; +// } + +// /** +// * @brief wk2114中断回调 +// * @note 不要将此函数放入中断中或比其他回调函数优先级更高的任务中 +// * @param wk2114 WK2114_TypeDef 结构指针 +// * 外部中断, +// */ +// void wk2114_inter_callback(WK2114_TypeDef *wk2114) +// { +// if((wk2114->flag&WK2114_G_FLAG_MASK_INTER)!=0){ +// return; +// } + +// // wk2114->flag|=WK2114_G_FLAG_MASK_INTER; +// // wk2114_read_reg( wk2114, WK2114_G_REG_GIFR ); +// // log_i("EXTI cmd QUeue count %d", osMessageQueueGetCount(wk2114->cmd_queue) ); +// // osThreadSuspend(wk2114Handle); +// wk2114->state = WK2114_WORK_STATE_EXTI; +// // osThreadResume(wk2114Handle); +// } + +// /** +// * @brief wk2114发送完成回调 +// * +// * @param wk2114 WK2114_TypeDef 结构指针 +// */ +// void wk2114_send_completed_callback(WK2114_TypeDef *wk2114) +// { +// wk2114->flag&=~WK2114_G_FLAG_MASK_SENDING; +// // wk2114_send(wk2114); +// } + + +// void wk2114_get_it_type_by_it_source(WK2114_TypeDef *wk2114) +// { +// // log_i("get_it_type_by_it_source....reg %d", wk2114->reg ); +// int i; +// int p_de; +// if(WK2114_CMD_GET_ADDR(wk2114->cmd)==WK2114_G_REG_GIFR){ // 去读子串口中断类型 +// wk2114->cmd=0; +// if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT1INT)!=0 && wk2114->sub_uart[WK2114_S_UART_1]!=NULL){ +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_1,WK2114_S_REG_SIFR)); +// } +// if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT2INT)!=0 && wk2114->sub_uart[WK2114_S_UART_2]!=NULL){ +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_2,WK2114_S_REG_SIFR)); +// } +// if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT3INT)!=0 && wk2114->sub_uart[WK2114_S_UART_3]!=NULL){ +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_3,WK2114_S_REG_SIFR)); +// } +// if((wk2114->reg&WK2114_G_REG_GIFR_MASK_UT4INT)!=0 && wk2114->sub_uart[WK2114_S_UART_4]!=NULL){ +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_4,WK2114_S_REG_SIFR)); +// } +// return; +// } + +// } + +// void wk2114_process_by_it_type(WK2114_TypeDef *wk2114) +// { +// int i; +// int p_de; +// log_i( " wk2114_process_by_it_type ...., "); +// // 判断中断类型 +// for(i=0;i<4;i++){ +// // 判断子串口是否注册， 子串口flag的 标志位当前寄存器页 page0 +// if(wk2114->sub_uart[i]!=NULL && (wk2114->sub_uart[i]->flag&WK2114_S_UART_FLAG_MASK_PAGE_D)==0){ +// if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_SIFR)){ // WK2114_S_REG_SIFR 子串口中断标志寄存器 +// wk2114->sub_uart[i]->cmd=0; +// if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_RXOVT_INT)!=0){ // 接收超时 +// wk2114->sub_uart[i]->flag|=WK2114_S_UART_FLAG_MASK_IDLE; +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(i,WK2114_S_REG_RFCNT)); +// } +// else if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_RFTRIG_INT)!=0){ // 接收FIFO触点中断 +// wk2114_read_fifo(wk2114,i,126); +// } +// if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_TFEMPTY_INT)!=0 && wk2114->sub_uart[i]->send_buf_p==0xffffffff){ // FIFO触点发送为空中断 发送下一个字符串 +// wk2114->sub_uart[i]->send_buf_p=0; +// // 判断 子串口的 发送队列是否为空 +// // p_de=queue_get_de_index(&wk2114->sub_uart[i]->send_queue); +// // if(p_de>=0){ +// if (osMessageQueueGetCount(wk2114->sub_uart[i]->send_queue) >= 0){ +// if(wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p <= 256){ +// struct wk2114_send_record record; +// osMessageQueueGet(wk2114->sub_uart[i]->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); +// wk2114_write_fifo(wk2114,i,record.p_data[wk2114->sub_uart[i]->send_buf_p],record.size-wk2114->sub_uart[i]->send_buf_p-1); +// // wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p-1); +// wk2114->sub_uart[i]->send_buf_p=0xffffffff; +// // queue_dequeue(&wk2114->sub_uart[i]->send_queue,NULL); +// } +// else{ +// wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],255); +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFTRIG_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// wk2114->sub_uart[i]->send_buf_p+=256; +// } +// } +// else{ +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// } +// } +// else if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_TFTRIG_INT)!=0){ // 发送FIFO触点中断 发送同一个字符串 +// // p_de=queue_get_de_index(&wk2114->sub_uart[i]->send_queue); +// // if(p_de>=0){ +// if (osMessageQueueGetCount(wk2114->sub_uart[i]->send_queue) >= 0){ +// if(wk2114->sub_uart[i]->send_buf_p >= wk2114->sub_uart[i]->send_record[p_de].size){ +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// wk2114->sub_uart[i]->send_buf_p=0xffffffff; +// return; +// } +// if(wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p <= 128){ +// struct wk2114_send_record record; +// osMessageQueueGet(wk2114->sub_uart[i]->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); +// wk2114_write_fifo(wk2114,i,record.p_data[wk2114->sub_uart[i]->send_buf_p],record.size-wk2114->sub_uart[i]->send_buf_p-1); + +// // wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],wk2114->sub_uart[i]->send_record[p_de].size-wk2114->sub_uart[i]->send_buf_p-1); +// wk2114->sub_uart[i]->send_buf_p=0xffffffff; +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// // queue_dequeue(&wk2114->sub_uart[i]->send_queue,NULL); +// } +// else{ +// wk2114_write_fifo(wk2114,i,&wk2114->sub_uart[i]->send_record[p_de].p_data[wk2114->sub_uart[i]->send_buf_p],127); +// wk2114->sub_uart[i]->send_buf_p+=128; +// } +// } +// else{ +// wk2114_sub_uart_set_inter(wk2114->sub_uart[i],WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// } +// } +// if((wk2114->sub_uart[i]->reg&WK2114_S_REG_SIFR_MASK_FERR_INT)!=0){ // 接收错误中断 +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(i,WK2114_S_REG_LSR)); +// } +// } +// else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_RFCNT)){ //子串口接收FIFO计数寄存器 +// wk2114->sub_uart[i]->cmd=0; +// wk2114_read_fifo(wk2114,i,wk2114->sub_uart[i]->reg-1); +// } +// else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_LSR)){ //子串口接收状态寄存器 +// wk2114->sub_uart[i]->cmd=0; +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(i,WK2114_S_REG_FSR)); +// } +// else if(WK2114_CMD_GET_ADDR(wk2114->sub_uart[i]->cmd)==WK2114_BUILD_SUB_REG(i,WK2114_S_REG_FSR)){ //子串口FIFO状态寄存器 +// wk2114->sub_uart[i]->cmd=0; +// } +// } +// } +// return; +// } + +// void wk2114_process_data_by_it_type(WK2114_TypeDef *wk2114,uint8_t *buf,uint32_t size) +// { +// int p_de; +// uint8_t cmd; +// uint8_t cmd_size; +// uint8_t sub_uart; +// WK2114_Sub_Uart_TypeDef*p_sub_uart; +// cmd=wk2114->send_buf[0]; +// wk2114->send_buf[0]=0; +// cmd_size=WK2114_CMD_GET_SIZE(cmd); // 命令要读取的数量 +// sub_uart=WK2114_CMD_GET_SUB_UART(cmd); +// p_sub_uart=wk2114->sub_uart[sub_uart]; +// if(WK2114_CMD_IS_WRITE(cmd)){ +// return; +// } +// if(WK2114_CMD_IS_REG(cmd)){ // 读寄存器 +// if(size!=1){ +// return; +// } +// if(WK2114_REG_IS_GLOBAL(cmd_size)){ // 全局寄存器 +// if(wk2114->cmd!=0xff){ +// return; +// } +// wk2114->cmd=cmd; +// wk2114->reg=buf[0]; +// } +// else{ // 子串口寄存器 +// if(p_sub_uart==NULL || wk2114->sub_uart[sub_uart]->cmd!=0xff){ +// return; +// } +// p_sub_uart->cmd=cmd; +// p_sub_uart->reg=buf[0]; +// } +// wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; +// wk2114_reg_recv_callback(wk2114); +// return; +// } + +// // 读数据回调 +// if(size!=cmd_size){ // 命令读取数量和实际读取数量不一致 +// return; +// } +// if(p_sub_uart->recv_buf_size-p_sub_uart->recv_buf_p < size){ // subuart buf甚于空间不足 +// cmd_size=p_sub_uart->recv_buf_size-p_sub_uart->recv_buf_p; +// } +// memcpy(&p_sub_uart->recv_buf[p_sub_uart->recv_buf_p],buf,cmd_size); +// p_sub_uart->recv_buf_p+=cmd_size; + +// // 判断 发送队列是否为空，或缓冲区满，数据进一步回调 +// if ( osMessageQueueGetCount(wk2114->cmd_queue) == 0 && (p_sub_uart->flag&WK2114_S_UART_FLAG_MASK_IDLE)==1 ) +// { +// p_sub_uart->flag&=~WK2114_S_UART_FLAG_MASK_IDLE; +// p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); +// p_sub_uart->recv_buf_p=0; +// } +// if(p_sub_uart->recv_buf_p==p_sub_uart->recv_buf_size) // 缓冲区满 +// { +// p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); +// p_sub_uart->recv_buf_p=size-cmd_size; +// memcpy(p_sub_uart->recv_buf,&buf[cmd_size],p_sub_uart->recv_buf_p); +// } +// wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; + +// // p_de=queue_get_de_index(&wk2114->cmd_queue); +// // if((p_de<0 || (wk2114->cmd_buf[p_de][0]&0xf0)!=(cmd&0xf0)) && (p_sub_uart->flag&WK2114_S_UART_FLAG_MASK_IDLE)==1){ // 接收超时 +// // p_sub_uart->flag&=~WK2114_S_UART_FLAG_MASK_IDLE; +// // p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); +// // p_sub_uart->recv_buf_p=0; +// // } +// // else if(p_sub_uart->recv_buf_p==p_sub_uart->recv_buf_size) // 缓冲区满 +// // { +// // p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); +// // p_sub_uart->recv_buf_p=size-cmd_size; +// // memcpy(p_sub_uart->recv_buf,&buf[cmd_size],p_sub_uart->recv_buf_p); +// // } +// // wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; +// } + + +// WK2114_TypeDef * wk2114_init(WK2114_TypeDef *wk2114,uint32_t dev_clock_hz,void *send_class,wk2114_send_fun send_fun) +// { +// int i; +// if(wk2114==NULL || send_class==NULL || send_fun==NULL || dev_clock_hz>32000000 || dev_clock_hz<1000000){ +// return NULL; +// } +// if(queue_init(&wk2114->cmd_queue,NULL,64)==NULL){ +// return NULL; +// } +// wk2114->send_class=send_class; +// wk2114->send_fun=send_fun; +// wk2114->flag=0; +// wk2114->dev_clock_hz=dev_clock_hz; +// for(i=0;i<4;i++){ +// wk2114->sub_uart[0]=NULL; +// } +// if(wk2114_set_baud(wk2114)<0){ +// return NULL; +// }; +// return wk2114; +// } + + + + +// int wk2114_sub_uart_init(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t baud,uint8_t mode,uint8_t fifo_mode,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits) +// { +// uint32_t tmp; +// uint16_t baud_div; +// uint8_t reg = 0; +// tmp=sub_uart->wk2114->dev_clock_hz*100/16/baud; +// if(tmp<10){ +// return -1; +// } +// baud_div=tmp/100-1; +// for(int i=0;i<4;i++){ +// if(wk2114->sub_uart[i]!=NULL){ +// reg|=(1<flag|=WK2114_S_UART_FLAG_MASK_ENABLE; +// wk2114_write_global_reg(wk2114,WK2114_G_REG_GENA,reg); +// HAL_Delay(0); + +// wk2114_write_global_reg(sub_uart->wk2114,WK2114_G_REG_GRST,1<uart_index); +// HAL_Delay(0); + +// // 子串口中断使能 10 01 //10 03 / 10 07 / 10 0F +// wk2114_write_global_reg(wk2114,WK2114_G_REG_GIER,reg); +// HAL_Delay(0); + +// // 子串口baud 03 01 04 00 05 05 06 05 03 00 05 00 /054D0601 9600 + +// // 切换子串口设置页面 1 +// if(wk2114_sub_uart_set_page(sub_uart,1)<0){ // 03 01 +// return -2; +// } +// HAL_Delay(0); +// // +// if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_BAUD1 ,baud_div>>8)<0){ // 04 00 +// return -2; +// } +// HAL_Delay(0); +// if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index,WK2114_S_REG_BAUD0 ,baud_div&0xff)<0){ //05 05 +// return -2; +// } +// HAL_Delay(0); +// if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_PRES ,(tmp/10)%10)<0){ // 06 05 +// return -2; +// } +// HAL_Delay(0); +// if(wk2114_sub_uart_set_page(sub_uart,0)<0){ // 03 00 +// return -2; +// } +// HAL_Delay(0); +// if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_LCR ,party|stop_bits)<0){ // 0500 +// return -2; +// } +// HAL_Delay(0); + + +// // 发送 和接收 触点中断数设置为 128 128 // 03 01 08 80 07 80 +// if(wk2114_sub_uart_set_page(sub_uart,1)<0){ +// return -2; +// } +// HAL_Delay(0); +// if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_TFTL ,128)<0){ +// return -2; +// } +// HAL_Delay(0); +// if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_RFTL,128)<0){ +// return -2; +// } +// HAL_Delay(0); +// if(wk2114_sub_uart_set_page(sub_uart,0)<0){ +// return -2; +// } +// HAL_Delay(0); + +// // 07 83 设置发送中断 +// if( wk2114_write_subuart_reg(sub_uart->wk2114, +// sub_uart->uart_index, +// WK2114_S_REG_SIER , +// WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT) +// <0 ){ +// // log_i("wk2114_sub_uart_set_inter write") +// return -2; +// } +// HAL_Delay(0); + +// //06 0C fifo Mode +// if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index,WK2114_S_REG_FCR ,fifo_mode)<0){ +// return -2; +// } +// HAL_Delay(0); + +// // 04 03 mode 子串口rx tx +// if(wk2114_write_subuart_reg(sub_uart->wk2114, sub_uart->uart_index, WK2114_S_REG_SCR, mode)<0){ +// return -2; +// } +// return 0; +// } + + +// int wk2114_send(WK2114_TypeDef *wk2114) +// { +// // log_i( "..... wk2114_send .---->>> flag %d " , wk2114->flag ); +// // int p_de; +// uint8_t cmd; +// volatile uint8_t size; +// WK2114_Sub_Uart_TypeDef *p_sub_uart = NULL; +// // if( osEventFlagsGet(wk2114EventHandle)&WK2114_G_FLAG_MASK_BUSY_RCV != 0){ // 如果接收状态退出,exit +// if( (wk2114->flag&WK2114_G_FLAG_MASK_BUSY_RCV)!=0 ){ // 如果接收状态退出,exit +// return 0; +// } +// // if( osEventFlagsGet(wk2114EventHandle)&WK2114_G_FLAG_MASK_SENDING != 0){ // 如果接收状态退出,exit +// if( (wk2114->flag&WK2114_G_FLAG_MASK_SENDING)!=0 ){ // 如果 sending ,exit +// return 0; +// } + +// // TODO: 如何消掉 EXTI 中断标记, 消息数量是否为 0 +// if (osMessageQueueGetCount( wk2114->cmd_queue) > 0) +// { +// osMessageQueueGet( wk2114->cmd_queue, (void*)wk2114->cmd_queue_msg_get, 0 ,portMAX_DELAY); +// } +// if (osMessageQueueGetCount( wk2114->cmd_queue) == 0) +// { +// wk2114->flag&=~WK2114_G_FLAG_MASK_INTER; +// } + +// wk2114->flag|=WK2114_G_FLAG_MASK_SENDING; +// // osEventFlagsSet( wk2114EventHandle, WK2114_G_FLAG_MASK_SENDING ); +// cmd=wk2114->cmd_queue_msg_get[0]; // first byte +// if( WK2114_CMD_IS_REG(cmd) ){ // 若为命令 +// // printf(" send -> is cmd %02X\n " , cmd ); +// // log_i( "..... send.......... cmd ... %02X", cmd ); +// if(WK2114_CMD_IS_READ(cmd)){ // 读命令 1byte 0+1 +// // printf(" send read -> is cmd %02X \r\n " , cmd ); +// // log_i( "..... send.......... read" ); +// size=0; +// wk2114->flag|=WK2114_G_FLAG_MASK_BUSY_RCV; +// // osEventFlagsSet( wk2114EventHandle, WK2114_G_FLAG_MASK_BUSY_RCV ); +// wk2114->send_buf[0]=cmd; + + +// } +// else{ // 写命令 2byte 1+1 +// size=1; +// wk2114->send_buf[0]=cmd; +// wk2114->send_buf[1]=wk2114->cmd_queue_msg_get[1]; +// if( WK2114_CMD_GET_ADDR(cmd)==WK2114_S_REG_SPAGE ){ +// if(wk2114->cmd_queue_msg_get[1]==0){ +// wk2114->sub_uart[WK2114_CMD_GET_SUB_UART(cmd)]->flag&=~WK2114_S_UART_FLAG_MASK_PAGE_D; +// } +// else{ +// wk2114->sub_uart[WK2114_CMD_GET_SUB_UART(cmd)]->flag|=WK2114_S_UART_FLAG_MASK_PAGE_D; +// } +// } +// } +// // queue_dequeue(&wk2114->cmd_queue,NULL); // 出队 +// // osMessageQueueGet(wk2114->cmd_queue ); +// } +// else{ // 若为数据, ?? 需要开启接收？？ +// // printf(" send -> is data \n " ); +// // log_i( "..... send.......... data ... %02X", cmd ); +// p_sub_uart=wk2114->sub_uart[WK2114_CMD_GET_SUB_UART(cmd)]; +// if(p_sub_uart==NULL){ +// return -3; +// } +// // printf(" sub uart ok \n " ); +// if(WK2114_CMD_IS_READ(cmd)){ // read 1byte 0+1 +// wk2114->flag|=WK2114_G_FLAG_MASK_BUSY_RCV; +// // osEventFlagsSet( wk2114EventHandle, WK2114_G_FLAG_MASK_BUSY_RCV ); +// size=0; +// if(wk2114->cmd_queue_msg_get[1] < 16){ // 判断数据量 +// wk2114->send_buf[0]=(cmd&0xf0)+wk2114->cmd_queue_msg_get[1]; +// // queue_dequeue(&wk2114->cmd_queue,NULL); +// } +// else{ +// wk2114->send_buf[0]=cmd|0x0f; +// wk2114->cmd_queue_msg_get[1]-=16; +// } +// } +// else{ // write +// if(wk2114->cmd_queue_msg_get[1] < 16){ // 判断数据量 +// size=wk2114->cmd_queue_msg_get[1]+1; +// wk2114->send_buf[0]=(cmd&0xf0)+size-1; +// memcpy(&wk2114->send_buf[1],p_sub_uart->send_buf,size-1); // 发送子串口的send_buf ?? size size-1 +// // queue_dequeue(&wk2114->cmd_queue,NULL); +// p_sub_uart->send_buf=NULL; +// } +// else{ +// size=16; +// wk2114->send_buf[0]=cmd|0x0f; +// memcpy(&wk2114->send_buf[1],p_sub_uart->send_buf,size); +// p_sub_uart->send_buf+=16; +// wk2114->cmd_queue_msg_get[1]-=16; +// } +// } +// } +// log_i( "..... send. buf %02X %02X size %d" , wk2114->send_buf[0] , wk2114->send_buf[1],size+1); + +// return wk2114->send_fun(wk2114->send_class,wk2114->send_buf,size+1); +// } diff --git a/device/Src/wk2114_port.c b/device/Src/wk2114_port.c new file mode 100644 index 0000000..03ad01c --- /dev/null +++ b/device/Src/wk2114_port.c @@ -0,0 +1,1903 @@ +#include "wk2114.h" +#include "usart.h" + +static uint8_t reg_readout[1] = { 0 }; +extern WK2114_Sub_Uart_TypeDef *sub_uart1 ; +extern uint8_t sub_uart1_receive_buf[1024]; +extern uint8_t wk2xxx_rcvbuf[1024]; +// extern UART_HandleTypeDef *pWK2114Uart; + +extern osSemaphoreId_t wk2xxx_lockHandle; +extern osSemaphoreId_t wk2xxx_irq_lockHandle; +extern osEventFlagsId_t wk2114EventHandle; + +osSemaphoreId_t wk2xxx_lockHandle; +const osSemaphoreAttr_t wk2xxx_lock_attributes = { + .name = "wk2xxx_lock"}; + +osSemaphoreId_t wk2xxx_sub_lockHandle; +const osSemaphoreAttr_t wk2xxx_sub_lock_attributes = { + .name = "wk2xxx_sub_lock"}; + + + + // osMutexId_t wk2xxx_irq_MutexHandle; + // const osMutexAttr_t wk2xxx_irq_Mutex_attributes = { + // .name = "wk2xxx_irq_Mutex" + // }; +osSemaphoreId_t wk2xxx_irq_lockHandle; +const osSemaphoreAttr_t wk2xxx_irq_lock_attributes = { + .name = "wk2xxx_irq_lock"}; + +osSemaphoreId_t wk2xxx_idle_lockHandle; +const osSemaphoreAttr_t wk2xxx_idle_lock_attributes = { + .name = "wk2xxx_idle_lock"}; + +osThreadId_t wk2114Handle; +const osThreadAttr_t wk2114Handle_attributes = { + .name = "wk2114", + .stack_size = 1024, + .priority = (osPriority_t)osPriorityBelowNormal, +}; + +osEventFlagsId_t wk2114EventHandle; +const osEventFlagsAttr_t wk2114Event_attributes = { + .name = "wk2114Event" +}; + + +#define WK2114_Uart_IRQHandler USART3_IRQHandler +UART_HandleTypeDef *pWK2114Uart = &huart3; + + +int Sub_rcv_callback(void * obj, uint8_t * buf, uint16_t len) +{ + return 0; +} + +void WK2XXX_IRQ_HANDLER(void) +{ + if( __HAL_GPIO_EXTI_GET_IT( WK2XXX_IRQ_PIN ) ) + { + // log_i("EXTI9_5_IRQHandler..WK2XXX IRQ HANDLER .. " ); + // osSemaphoreRelease(wk2xxx_irq_lockHandle); + osEventFlagsSet(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IRQ); + // osMutexRelease(wk2xxx_irq_MutexHandle ); + log_i(" irq EXTI9_5_ PIN7 set flag ..... " ); + + __HAL_GPIO_EXTI_CLEAR_IT(WK2XXX_IRQ_PIN); + } + // HAL_GPIO_EXTI_IRQHandler(WK2114_IRQ_Pin); + +} + +// TODO 何时开启接收， 在 wk2114_read_reg 的时候 +void WK2114_Uart_IRQHandler(void) +{ + uint16_t count = 0; + uint16_t data_length = 0; + // send cplt + if (__HAL_UART_GET_FLAG(pWK2114Uart, UART_FLAG_TC) != RESET) + { + + // log_i("WK2114 ..huart TC callback .. " ); + // wk2114_send_completed_callback( wk2114); + wk2114->flag&=~WK2114_G_FLAG_MASK_SENDING; + osSemaphoreRelease(wk2xxx_lockHandle ); + + pWK2114Uart->gState = HAL_UART_STATE_READY; + __HAL_UART_CLEAR_FLAG(pWK2114Uart, UART_FLAG_TC); + } + + if (__HAL_UART_GET_FLAG(pWK2114Uart, UART_FLAG_IDLE) != RESET) + { + count = __HAL_DMA_GET_COUNTER( pWK2114Uart->hdmarx ); + // log_i("WK2114 ..huart IDLE ... %d", 1024 - count); + data_length = 1024 - count; + if ( data_length > 0 ) + { + wk2114->idle_receive_flag = 1; + wk2114->size_received = data_length; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + // osEventFlagsSet(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IDLE); + + // wk2114_idle_callback(wk2114, wk2xxx_rcvbuf, data_length); + // wk2114_reg_recv_callback(wk2114); + // wk2114_recv_callback(wk2114, wk2xxx_rcvbuf, data_length ); + // log_i("WK2114_ IDLE.. data_length %d %02X", data_length, wk2xxx_rcvbuf[0]); + } + __HAL_UART_CLEAR_IDLEFLAG( pWK2114Uart ); + } +} + +int WK2114_Add_Sub_Uart(WK2114_TypeDef *wk2114 ) +{ + sub_uart1 = (WK2114_Sub_Uart_TypeDef *)malloc(sizeof(WK2114_Sub_Uart_TypeDef)); + if (0!=wk2114_sub_uart_register(wk2114, sub_uart1,WK2114_S_UART_1,sub_uart1_receive_buf,sizeof(sub_uart1_receive_buf), &huart2, Sub_rcv_callback)) + { + log_e("sub-uart 1 register Failure ! "); + }; + + if (0!=wk2114_sub_uart_init( sub_uart1,115200,WK2114_SUB_UART_MODE_MASK_TX|WK2114_SUB_UART_MODE_MASK_RX,WK2114_SUB_UART_FIFO_MODE_MASK_TX|WK2114_SUB_UART_FIFO_MODE_MASK_RX,WK2114_UART_PARITY_NONE,WK2114_UART_STOP_BITS_1)) + { + log_e("sub-uart 1 init Failure ! "); + } + return 0; +} + + +int WK2114_Init( ) +{ + GPIO_InitTypeDef GPIO_InitStruct = {0}; + WK2XXX_RST_GPIO_CLK_ENABLE(); + WK2XXX_IRQ_GPIO_CLK_ENABLE(); + // wk2XXX rst + GPIO_InitStruct.Pin = WK2XXX_RST_PIN; + GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; + GPIO_InitStruct.Pull = GPIO_PULLUP; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init(WK2XXX_RST_GPIO_PORT, &GPIO_InitStruct); + + // wk2XXX irq + GPIO_InitStruct.Pin = WK2XXX_IRQ_PIN; + GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING; + GPIO_InitStruct.Pull = GPIO_PULLDOWN; + HAL_GPIO_Init(WK2XXX_IRQ_GPIO_PORT, &GPIO_InitStruct); + + HAL_NVIC_SetPriority(WK2XXX_IRQ_EXTI_IRQ, 5, 0); + HAL_NVIC_EnableIRQ(WK2XXX_IRQ_EXTI_IRQ); + + wk2114 = (WK2114_TypeDef *)malloc(sizeof(WK2114_TypeDef)); + wk2114->send_class = pWK2114Uart; + wk2114->send_fun = HAL_UART_Transmit_DMA; + + // 命令队列 uint8_t cmd_buf[64][2] , 消息类型 2个uint8_t + wk2114->cmd_queue = osMessageQueueNew( 64, sizeof(wk2114->cmd_queue_msg_put), NULL); + if (wk2114->cmd_queue ==NULL) return -1; + + wk2114->cmd = 0; + wk2114->flag = 0; + wk2114->dev_clock_hz = WK2114_CLOCK_HZ; + + for(size_t i=0;i<4;i++){ + wk2114->sub_uart[i] = NULL; + wk2114->sub_uart_cfg[i] = NULL; + } + + // osSemaphoreRelease(wk2xxx_lockHandle); + // osSemaphoreRelease(wk2xxx_sub_lockHandle); + // // osSemaphoreRelease(wk2xxx_irq_lockHandle); + // osSemaphoreAcquire(wk2xxx_irq_lockHandle, osWaitForever); + + wk2114->size_received = 0; + // wk2114->setbaud_ok = 0; + // wk2114->senf40_rcvF0_ok = 0; + wk2114->idle_receive_flag = 0; + wk2114->state = WK2114_WORK_STATE_WAIT; + + + return 0; +} + + +void WK2114_Port() +{ + wk2114Handle = osThreadNew(WK2114_Task, (void*)(&wk2114->state), &wk2114Handle_attributes); + // wk2114EventHandle = osEventFlagsNew ( &wk2114Event_attributes ); + // wk2xxx_irq_MutexHandle = osMutexNew(&wk2xxx_sub_lock_attributes); + + wk2xxx_lockHandle = osSemaphoreNew(1,1,&wk2xxx_lock_attributes); +osSemaphoreRelease(wk2xxx_lockHandle ); +// osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + + + wk2xxx_sub_lockHandle = osSemaphoreNew(1,1,&wk2xxx_sub_lock_attributes); +osSemaphoreRelease(wk2xxx_sub_lockHandle ); +// osSemaphoreAcquire(wk2xxx_sub_lockHandle, osWaitForever); + + wk2xxx_irq_lockHandle = osSemaphoreNew(1,1,&wk2xxx_irq_lock_attributes); +osSemaphoreRelease(wk2xxx_irq_lockHandle ); +osSemaphoreAcquire(wk2xxx_irq_lockHandle, osWaitForever); + + wk2xxx_idle_lockHandle = osSemaphoreNew(1,1,&wk2xxx_idle_lock_attributes); +osSemaphoreRelease(wk2xxx_idle_lockHandle ); +osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + + // osMutexAcquire(wk2xxx_irq_MutexHandle, osWaitForever); + // wk2xxx_irq_MutexHandle = osMutexNew(&wk2xxx_sub_lock_attributes); + + wk2114EventHandle = osEventFlagsNew ( &wk2114Event_attributes ); + osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IRQ ); + osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IDLE ); + // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_RECEIVED ); + // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_TYPE_SENDING ); + // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_TYPE_RECEIVED ); + // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_COUNT_RECEIVED ); + // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_BUF_RECEIVED ); +} + + +void WK2114_Task(void * argument ) +{ + WK2114_WORK_STATE_TypeDef *state = argument; + static int err_con = 0; + static int state_ok_count = 0; + static uint8_t cmd; + static uint8_t reg_readout; + static uint8_t sub_uart_index; + static uint8_t evt_flag = 0; + static uint32_t fifo_readout_count = 0; + static uint32_t subuart_sendqueue_count = 0; + static WK2114_Sub_Uart_TypeDef *p_sub_uart; + static WK2114_Sub_Uart_CFG_TypeDef *p_sub_uart_cfg; + for ( ; ; ) + { + switch (*state) + { + case WK2114_WORK_STATE_WAIT: + log_i( "WK2114_wait .... " ); + osDelay(100); + break; + case WK2114_WORK_STATE_START: + err_con = 0; + wk2114->timebase = osKernelGetTickCount(); + *state = WK2114_WORK_STATE_SET_BAUD; + continue; + case WK2114_WORK_STATE_SET_BAUD: + { + log_i( "WK2114_WORK_STATE_SET_BAUD .... " ); + wk2114->cmd = 0x55; + reg_readout = 0xFF; + wk2114->timebase = osKernelGetTickCount(); + wk2114_reset( wk2114); + wk2114_mainport_rcv( wk2114, wk2xxx_rcvbuf, 1024 ); + wk2114_set_baud( wk2114); + osDelay(1); + wk2114_set_baud( wk2114); + *state = WK2114_WORK_STATE_SET_BAUD_OK; + // osEventFlagsClear( wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IDLE ); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + continue; + } + + case WK2114_WORK_STATE_SET_BAUD_OK: + { + log_i( "WK2114_WORK_STATE_SET_BAUD OK .... " ); + // osDelay(1); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + *state = WK2114_WORK_STATE_IT_SOURCE_GETTING; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + if ( wk2xxx_rcvbuf[0] != 0x00 ) + { + err_con++; + log_i( " setbaud , retry %d times ", err_con ); + if (err_con>40) + { + *state = WK2114_WORK_STATE_ERROR; + break; + } + HAL_UART_DMAStop(pWK2114Uart); + *state = WK2114_WORK_STATE_SET_BAUD; + break; + } + // osSemaphoreWait(wk2xxx_idle_lockHandle ); + // uint32_t evt_flag = osEventFlagsWait(wk2114EventHandle,MODULE_WK2114_EVENT_EXTI_IDLE, 0, portMAX_DELAY); + // if ( evt_flag & MODULE_WK2114_EVENT_EXTI_IDLE != 0 ) { + // osEventFlagsClear( wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IDLE ); + // *state = WK2114_WORK_STATE_IT_SOURCE_GETTING; + // HAL_UART_DMAStop( pWK2114Uart ); + // continue; + // }else{ + // *state = WK2114_WORK_STATE_ERROR; + // HAL_UART_DMAStop( pWK2114Uart ); + // continue; + // } + // while (wk2114->idle_receive_flag!=1 || wk2xxx_rcvbuf[0] != 0x00) + // { + // if ( wk2114->timebase-osKernelGetTickCount() >200) + // { + // err_con++; + // log_i( " setbaud , retry %d times ", err_con ); + // if (err_con>10) + // { + // *state = WK2114_WORK_STATE_ERROR; + // break; + // } + // HAL_UART_DMAStop(pWK2114Uart); + // *state = WK2114_WORK_STATE_SET_BAUD; + // break; + // } + // } + + // log_d( "WK2114 SET_BAUD OK .... rcv0 0x%02X", wk2xxx_rcvbuf[0] ); + HAL_UART_DMAStop( pWK2114Uart ); + *state = WK2114_WORK_STATE_SEND_40_RCV_F0; + continue; + } + + case WK2114_WORK_STATE_SEND_40_RCV_F0: + { + log_i( "WK2114_WORK_STATE SEND_40 RCV_F0 ... " ); + wk2114->cmd = 0x40; + wk2114->timebase = osKernelGetTickCount(); + wk2114_mainport_rcv( wk2114, wk2xxx_rcvbuf, 1024 ); + wk2114->send_fun(wk2114->send_class,&wk2114->cmd,1); + *state = WK2114_WORK_STATE_SEND_40_RCV_F0_OK; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + continue; + } + + case WK2114_WORK_STATE_SEND_40_RCV_F0_OK: + { + log_d( "WK2114_WORK_STATE SEND_40 RCV_F0 OK .... " ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + // *state = WK2114_WORK_STATE_IT_SOURCE_GETTING; + // osSemaphoreRelease(wk2xxx_idle_lockHandle ); + if ( wk2xxx_rcvbuf[0] != 0xF0 ) + { + err_con++; + log_i( " SEND_40 RCV_F0 %d times ", err_con ); + if (err_con>40) + { + *state = WK2114_WORK_STATE_ERROR; + break; + } + HAL_UART_DMAStop(pWK2114Uart); + *state = WK2114_WORK_STATE_SET_BAUD; + break; + } + HAL_UART_DMAStop(pWK2114Uart); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + *state = WK2114_WORK_TEST_OK; + + } + + case WK2114_WORK_TEST_OK: + { + log_i( "WK2114_WORK_TEST_OK ... " ); + osDelay(20); + break; + } + + + case WK2114_WORK_STATE_ADD_SUB_UART: + { + log_i( "WK2114_WORK_STATE_ADD_SUB_UART .... " ); + WK2114_Add_Sub_Uart( wk2114 ); + *state = WK2114_WORK_STATE_ADD_SUB_UART_OK; + continue; + } + + case WK2114_WORK_STATE_ADD_SUB_UART_OK: + { + log_i( "WK2114_WORK_STATE_ADD_SUB_UART OK .... ?? " ); + *state = WK2114_WORK_STATE_OK; + osDelay(2); + continue; + } + + case WK2114_WORK_STATE_OK: + { + log_i( "WK2114_WORK_STATE_OK --> wait irq exti " ); + // osSemaphoreAcquire(wk2xxx_irq_lockHandle, osWaitForever); + + // *state = WK2114_WORK_STATE_IT_SOURCE_GETTING; + // osSemaphoreRelease(wk2xxx_irq_lockHandle); + // osSemaphoreAcquire(wk2xxx_irq_lockHandle, osWaitForever); + + uint32_t evt_flag = osEventFlagsWait(wk2114EventHandle, + MODULE_WK2114_EVENT_EXTI_IRQ, + 0, + portMAX_DELAY); + log_i( " WK2114 IRQ exti happened ....." ); + if ( evt_flag & MODULE_WK2114_EVENT_EXTI_IRQ != 0 ) { + osEventFlagsClear( wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IRQ ); + *state = WK2114_WORK_STATE_IT_SOURCE_GETTING; + continue; + } + // *state = WK2114_WORK_STATE_IT_SOURCE_GETTING; + // osDelay(20); + continue; + } + + case WK2114_WORK_STATE_IT_SOURCE_GETTING: + { + wk2114->timebase = osKernelGetTickCount(); + wk2114->cmd = WK2114_G_REG_GIFR; + cmd = WK2114_G_REG_GIFR; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114_read_global_reg( wk2114, wk2114->cmd ); + // wk2114->reg_gifr = wk2xxx_rcvbuf[0]; + // log_i( " WK2114 IRQ irq source 0x%02X", wk2114->reg_gifr ); + *state = WK2114_WORK_STATE_IT_TYPE_GETTING; + + continue; + + } + + case WK2114_WORK_STATE_IT_TYPE_GETTING: + { + log_d(" irq WK2114_WORK_STATE_IT_TYPE_GETTING .. by irq source 0x%02X", wk2114->reg_gifr); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + // *state = WK2114_WORK_STATE_IT_SOURCE_GETTING; + HAL_UART_DMAStop(pWK2114Uart); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + wk2114->reg_gifr = wk2xxx_rcvbuf[0]; + + wk2114->reg_readout = wk2114->reg_gifr; + log_i(" irq source 0x%02X", wk2114->reg_gifr ); + switch (wk2114->reg_readout) + { + case WK2114_G_REG_GIFR_MASK_UT1INT: + if( wk2114->sub_uart[WK2114_S_UART_1]!=NULL){ + wk2114->it_sub_uart_index = WK2114_S_UART_1; + } + break; + case WK2114_G_REG_GIFR_MASK_UT2INT: + if( wk2114->sub_uart[WK2114_S_UART_2]!=NULL){ + wk2114->it_sub_uart_index = WK2114_S_UART_2; + } + break; + case WK2114_G_REG_GIFR_MASK_UT3INT: + if( wk2114->sub_uart[WK2114_S_UART_3]!=NULL){ + wk2114->it_sub_uart_index = WK2114_S_UART_3; + } + break; + case WK2114_G_REG_GIFR_MASK_UT4INT: + if( wk2114->sub_uart[WK2114_S_UART_4]!=NULL){ + wk2114->it_sub_uart_index = WK2114_S_UART_4; + } + break; + default: + log_e(" it source error ! "); + *state = WK2114_WORK_STATE_OK; + break; + } + log_i(" it_sub_uart_index source 0x%02X", wk2114->it_sub_uart_index ); + p_sub_uart = wk2114->sub_uart[wk2114->it_sub_uart_index]; + + // 读子串口寄存器 it_type + p_sub_uart->cmd = WK2114_S_REG_SIFR; + cmd = WK2114_S_REG_SIFR; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114_read_subuart_reg(wk2114, wk2114->it_sub_uart_index, p_sub_uart->cmd ); + + *state = WK2114_WORK_STATE_PROCESS_IT_TYPE; + continue; + } + + case WK2114_WORK_STATE_PROCESS_IT_TYPE: + { + log_d("WK2114_WORK_STATE_PROCESS_IT_TYPE .. subuart 0x%02X it_type 0x%02X ", wk2114->it_sub_uart_index,wk2xxx_rcvbuf[0]); + // log_d("WK2114_WORK_STATE_PROCESS_IT_TYPE .. subuart 0x%02X it_type 0x%02X ", wk2114->it_sub_uart_index,wk2xxx_rcvbuf[0]); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + HAL_UART_DMAStop(pWK2114Uart); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + wk2114->reg_readout = wk2xxx_rcvbuf[0]; + osDelay(1); + + // wk2114->reg_readout = wk2114->sub_uart_cfg[wk2114->it_sub_uart_index]->reg_sifr; + p_sub_uart->reg = wk2xxx_rcvbuf[0]; + reg_readout = wk2xxx_rcvbuf[0]; + log_d(" subuart 0x%02X it_type 0x%02X 0x%02X ", wk2114->it_sub_uart_index, wk2114->reg_readout, wk2xxx_rcvbuf[0]); + // log_d(" it_type 0x%02X ",wk2114->sub_uart_cfg[wk2114->it_sub_uart_index]->reg_sifr); + + // 接收FIFO触点中断 ,接收FIFO中的数据个数大于设定的 128 ,0x01 + if( ( p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_RFTRIG_INT)!=0 ){ + *state = WK2114_WORK_STATE_EXTI_PROCESS_RFTRIG_INT; + continue; + } + // 接收字节超时中断 读取字节数未满 且空闲4字节 0x02 + if( ( p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_RXOVT_INT)!=0 ){ + *state = WK2114_WORK_STATE_EXTI_PROCESS_RXOVT_INT; + continue; + } + + // 发送FIFO触点中断 ,当发送FIFO中的数据个数小于设定的128时，产生该中断 /0x04 + if((p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFTRIG_INT)!=0){ + // log_d("_IT_ type .... %d", p_sub_uart->reg ); + *state = WK2114_WORK_STATE_EXTI_PROCESS_TFTRIG_INT; + continue; + } + // FIFO触点发送为空中断 , FIFO ,当发送FIFO中没有数据，大约设定的128 中断清除 ,0x08 + if( ( p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFEMPTY_INT)!=0 ) { + *state = WK2114_WORK_STATE_EXTI_PROCESS_TFEMPTY_INT; + continue; + } + // if( (p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFEMPTY_INT)!=0 + // && wk2114->sub_uart[wk2114->it_sub_uart_index]->send_buf_p==0xffffffff ) { + // *state = WK2114_WORK_STATE_EXTI_PROCESS_TFEMPTY_INT; + // continue; + // } + // 接收错误中断 0x80 + if( ( p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_FERR_INT)!=0 ){ + *state = WK2114_WORK_STATE_EXTI_PROCESS_FERR_INT; + continue; + } + + *state = WK2114_WORK_STATE_OK; + break; + } + + case WK2114_WORK_STATE_EXTI_PROCESS_RXOVT_INT: + { + log_w(" Rcv Fifo Byte Overtime Int .... "); + p_sub_uart->cmd = WK2114_S_REG_RFCNT; + cmd = WK2114_S_REG_SIFR; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114_read_subuart_reg(wk2114, wk2114->it_sub_uart_index, p_sub_uart->cmd ); + *state = WK2114_WORK_STATE_EXTI_PROCESS_GET_FIFO_COUNT; + continue; + } + + + case WK2114_WORK_STATE_EXTI_PROCESS_RFTRIG_INT: + { + log_i("Rcv Fifo Trigger .... read rcv fifo count "); + + // 读子串口寄存器 it_type + p_sub_uart->cmd = WK2114_S_REG_RFCNT; + cmd = WK2114_S_REG_SIFR; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114_read_subuart_reg(wk2114, wk2114->it_sub_uart_index, p_sub_uart->cmd ); + *state = WK2114_WORK_STATE_EXTI_PROCESS_GET_FIFO_COUNT; + continue; + } + + + case WK2114_WORK_STATE_EXTI_PROCESS_TFEMPTY_INT: + { + log_w("Tx Fifo Empty Int.... "); + if( p_sub_uart->send_buf_p==0xffffffff){ + log_w(" send fifo trigger == 0"); + p_sub_uart->send_buf_p=0; + uint8_t queue_count = osMessageQueueGetCount(p_sub_uart->send_queue); + // 判断 子串口的 发送队列是否为空 + // p_de=queue_get_de_index(&p_sub_uart->send_queue); + // if(p_de>=0){ + if (osMessageQueueGetCount(p_sub_uart->send_queue) >= 0){ + if(p_sub_uart->send_record[queue_count-1].size-p_sub_uart->send_buf_p <= 256){ + struct wk2114_send_record record; + osMessageQueueGet(p_sub_uart->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); + wk2114_write_fifo(wk2114,sub_uart_index,record.p_data[p_sub_uart->send_buf_p],record.size-p_sub_uart->send_buf_p-1); + // wk2114_write_fifo(wk2114,i,&p_sub_uart->send_record[p_de].p_data[p_sub_uart->send_buf_p],p_sub_uart->send_record[p_de].size-p_sub_uart->send_buf_p-1); + p_sub_uart->send_buf_p=0xffffffff; + // queue_dequeue(&p_sub_uart->send_queue,NULL); + } + else{ // buff 大于256， 发送 256, 记录发送位置 p_sub_uart->send_buf_p + wk2114_write_fifo(wk2114,sub_uart_index,&p_sub_uart->send_record[queue_count-1].p_data[p_sub_uart->send_buf_p],255); + wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFTRIG_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); + p_sub_uart->send_buf_p+=256; + } + } + else{ + // 子串口队列无发送任务，取消发送出点为空中断 + wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); + *state = WK2114_WORK_STATE_STOP; + } + } + continue; + } + + // 发送FIFO触点中断 ,当发送FIFO中的数据个数小于设定的128时，产生该中断 /0x04 + case WK2114_WORK_STATE_EXTI_PROCESS_TFTRIG_INT: + { + log_d("Tx Fifo Trigger Int TFTRIG ..... "); + uint8_t size; + uint8_t current_record_p =0; + + osSemaphoreAcquire(wk2xxx_sub_lockHandle, osWaitForever); + subuart_sendqueue_count = osMessageQueueGetCount(p_sub_uart->send_queue); + // osDelay(20); + + // log_w("Tx Fifo Trigger Int ..... subuart_sendqueue_count %d ",subuart_sendqueue_count); + if (subuart_sendqueue_count >= 0){ + if ( (p_sub_uart->send_record_p-subuart_sendqueue_count-1) > 0) + { + current_record_p = p_sub_uart->send_record_p-subuart_sendqueue_count; + }else{ + current_record_p = p_sub_uart->send_record_p + 8 -subuart_sendqueue_count ; + } + // log_d(" p_sub_uart->send_buf_p %d" , p_sub_uart->send_buf_p); + // log_d(" record size %d" , p_sub_uart->send_record[current_record_p]); + // 当前record数据发完，取出队列， 状态回到 state_ok + if( p_sub_uart->send_buf_p >= p_sub_uart->send_record[current_record_p].size ){ + log_d(" current record send cplt " ); + osMessageQueueGet( p_sub_uart->send_queue, (void*) ¤t_record_p, sizeof(current_record_p), portMAX_DELAY); // 发送完取出当前消息 + wk2114->reg = WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT; + wk2114_write_subuart_reg(wk2114, wk2114->it_sub_uart_index, WK2114_S_REG_SIER ,wk2114->reg); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + osSemaphoreRelease(wk2xxx_lockHandle); + // wk2114_sub_uart_set_inter(p_sub_uart,wk2114->reg); + p_sub_uart->send_buf_p = 0xffffffff; // 计数复原 + osSemaphoreRelease(wk2xxx_sub_lockHandle); + *state = WK2114_WORK_STATE_EXTI_READ_SUB_FSR; + continue; + } + // 当前record 没有发的小于 16 + if( p_sub_uart->send_record[current_record_p].size-p_sub_uart->send_buf_p <= 16){ + // log_w(" < < 16 ......" ); + size = p_sub_uart->send_record[current_record_p].size-p_sub_uart->send_buf_p; + // 快速写 128buf , 清除中断， 每次16 + wk2114_write_fifo(wk2114, + wk2114->it_sub_uart_index, + &p_sub_uart->send_record->p_data[current_record_p], + size-1); + + p_sub_uart->send_buf_p=0xffffffff; + + wk2114->reg = WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT; + wk2114_write_subuart_reg(wk2114, wk2114->it_sub_uart_index, WK2114_S_REG_SIER ,wk2114->reg); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + osSemaphoreRelease(wk2xxx_lockHandle); + // wk2114_sub_uart_set_inter(p_sub_uart,wk2114->reg); + osSemaphoreRelease(wk2xxx_sub_lockHandle); + continue; + } + else{ // 计数大于128 + // log_w(" > 16 ...... " ); + wk2114_write_fifo(wk2114, + wk2114->it_sub_uart_index, + &p_sub_uart->send_record->p_data[current_record_p], + 15); + p_sub_uart->send_buf_p+=16; + osSemaphoreRelease(wk2xxx_sub_lockHandle); + continue; + } + } + else{ + wk2114->reg = WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT; + wk2114_write_subuart_reg(wk2114, wk2114->it_sub_uart_index, WK2114_S_REG_SIER ,wk2114->reg); + // wk2114_sub_uart_set_inter(p_sub_uart,wk2114->reg); + osSemaphoreAcquire(wk2xxx_lockHandle, osWaitForever); + osSemaphoreRelease(wk2xxx_lockHandle); + osSemaphoreRelease(wk2xxx_sub_lockHandle); + *state = WK2114_WORK_STATE_OK; + continue; + + } + // osSemaphoreRelease(wk2xxx_sub_lockHandle); + + *state = WK2114_WORK_STATE_OK; + continue; + osDelay(20); + + break; + } + + case WK2114_WORK_STATE_EXTI_PROCESS_FERR_INT: + { + log_e("Fifo Error .... "); + __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE ); + HAL_UART_Receive_DMA(pWK2114Uart, &wk2114->reg_readout, 1 ); + // HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, wk2xxx_rcvbuf, 1024); + wk2114_read_subuart_reg( wk2114, wk2114->it_sub_uart_index, WK2114_S_REG_LSR ); + *state = WK2114_WORK_STATE_STOP; + break; + } + + case WK2114_WORK_STATE_EXTI_PROCESS_GET_FIFO_COUNT: + { + log_e("WK2114_WORK_STATE_EXTI_PROCESS GET_FIFO_COUNT ...%d ",wk2114->reg_readout ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + // *state = WK2114_WORK_STATE_IT_SOURCE_GETTING; + HAL_UART_DMAStop(pWK2114Uart); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + wk2114->reg_readout = wk2xxx_rcvbuf[0]; + // TODO 数量为0的情况处理 + // wk2114->reg_readout = wk2xxx_rcvbuf[0]; + log_i( " fifo number : 0x%02X ", wk2114->reg_readout ); + *state = WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT; + // osDelay(20); + continue; + } + + + case WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT: + { + log_e("Read Fifo BUF by fifo , number -> 0x%02X ",wk2114->reg_readout ); + fifo_readout_count = wk2114->reg_readout; + + // 接收数量为0 ， + + + if ( fifo_readout_count > 16 ) { + p_sub_uart->cmd = 16-1; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114_read_fifo( wk2114, wk2114->it_sub_uart_index, p_sub_uart->cmd); + fifo_readout_count -= 16; + log_w( "Fifo read out %d, remain %d ", p_sub_uart->cmd+1, fifo_readout_count ); + } else { + p_sub_uart->cmd = fifo_readout_count-1; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114_read_fifo( wk2114, wk2114->it_sub_uart_index, p_sub_uart->cmd); + fifo_readout_count = 0; + log_w( "Fifo read cplt .... " ); + *state = WK2114_WORK_STATE_EXTI_DEAL_FIFO_READOUT; + continue; + } + + *state = WK2114_WORK_STATE_EXTI_DEAL_FIFO_READOUT; + // osDelay(1000); + continue; + } + case WK2114_WORK_STATE_EXTI_DEAL_FIFO_READOUT: + { + log_e( " Deal FIFO BUF " ); + osSemaphoreAcquire( wk2xxx_idle_lockHandle, 0xFF ); + // TODO 判断字节数量 + if (wk2114->size_received == ( p_sub_uart->cmd + 1) ) + { + HAL_UART_DMAStop(pWK2114Uart); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + }else{ + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + + } + log_i(" deal buf : %d " , wk2114->size_received); + log_i(" deal buf : %02X %02X %02X %02X %02X %02X %02X %02X" , + wk2xxx_rcvbuf[0], wk2xxx_rcvbuf[1], wk2xxx_rcvbuf[2], wk2xxx_rcvbuf[3], wk2xxx_rcvbuf[4], wk2xxx_rcvbuf[5], wk2xxx_rcvbuf[6], wk2xxx_rcvbuf[7] ); + + // TODO 接收数量为0 ，FSR判断是否有数据再处理 + if (fifo_readout_count == 0 ) { + HAL_UART_DMAStop(pWK2114Uart); + *state = WK2114_WORK_STATE_EXTI_READ_SUB_FSR; + } + else{ + *state = WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT; + } + continue; + } + + case WK2114_WORK_STATE_EXTI_READ_SUB_FSR: + log_e("WK2114_WORK_STATE_EXTI_READ_SUB_FSR FIFO Status .... "); + + p_sub_uart->cmd = WK2114_S_REG_FSR; + cmd = WK2114_S_REG_FSR; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114_read_subuart_reg( wk2114, wk2114->it_sub_uart_index, p_sub_uart->cmd ); + // log_e("WK2114_S_REG_ FSR .... 0x%02X", wk2xxx_rcvbuf[0]); + *state = WK2114_WORK_STATE_EXTI_READ_SUB_LSR; + break; + case WK2114_WORK_STATE_EXTI_READ_SUB_LSR: + log_e("WK2114_WORK_STATE_EXTI_READ_SUB_FSR FIFO Status .... "); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + HAL_UART_DMAStop(pWK2114Uart); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + log_d("WK2114_S_REG_ FSR .... 0x%02X", wk2xxx_rcvbuf[0]); + + p_sub_uart->cmd = WK2114_S_REG_LSR ; + cmd = WK2114_S_REG_LSR; + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114_read_subuart_reg( wk2114, wk2114->it_sub_uart_index, p_sub_uart->cmd ); + // log_e("WK2114_S_REG_ LSR .... 0x%02X", wk2xxx_rcvbuf[0]); + *state = WK2114_WORK_STATE_EXTI_DEAL_LSR; + break; + case WK2114_WORK_STATE_EXTI_DEAL_LSR: + log_e("WK2114_WORK_STATE_EXTI_READ_SUB_FSR FIFO Status .... "); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + HAL_UART_DMAStop(pWK2114Uart); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + log_d("WK2114_S_REG_ LSR .... 0x%02X", wk2xxx_rcvbuf[0]); + + *state = WK2114_WORK_STATE_EXTI_READ_REG; + break; + + case WK2114_WORK_STATE_EXTI_READ_REG: + log_d(" read reg for check .... "); + + // 写入软复位 + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114->cmd = WK2114_G_REG_GRST ; + wk2114_write_global_reg( wk2114, wk2114->cmd, 0x0F ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114->cmd = WK2114_G_REG_GENA ; + wk2114_read_global_reg( wk2114, wk2114->cmd ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + log_d("WK2114 subuart enable .... 0x%02X", wk2xxx_rcvbuf[0]); + + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114->cmd = WK2114_G_REG_GIER ; + wk2114_read_global_reg( wk2114, wk2114->cmd ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + log_d("WK2114 subuart it enable .... 0x%02X", wk2xxx_rcvbuf[1]); + + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114->cmd = WK2114_G_REG_GRST ; + wk2114_read_global_reg( wk2114, wk2114->cmd ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + log_d("WK2114 subuart GRST .... 0x%02X", wk2xxx_rcvbuf[2]); + + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, osWaitForever); + wk2114->cmd = WK2114_S_REG_SIER ; + wk2114_read_subuart_reg( wk2114, wk2114->it_sub_uart_index, wk2114->cmd ); + osSemaphoreAcquire(wk2xxx_idle_lockHandle, 0xFF); + log_d("WK2114 subuart it type .... 0x%02X", wk2xxx_rcvbuf[3]); // 8B 发送触点中断确实被取消了 + HAL_UART_DMAStop(pWK2114Uart); + osSemaphoreRelease(wk2xxx_idle_lockHandle ); + + // 子串口软复位 + + + *state = WK2114_WORK_STATE_OK; + break; + + case WK2114_WORK_STATE_ERROR: + log_e("WK2114_WORK STATE ERROR .... "); + // TODO 重设Baud + // HAL_UART_DMAStop(pWK2114Uart); + osDelay(500); + // *state = WK2114_WORK_STATE_WAIT; + break; + case WK2114_WORK_STATE_STOP: + log_e("WK2114_WORK_STATE STOP .... "); + HAL_UART_DMAStop(pWK2114Uart); + *state = WK2114_WORK_STATE_WAIT; + break; + default: + break; + } + osDelay(1 ); + + } + +} + +void wk2114_FERR_INT_Handler(WK2114_TypeDef *wk2114, uint8_t it_type) +{ + +} +void wk2114_RXOVT_INT_Handler(WK2114_TypeDef *wk2114, uint8_t it_type) +{ + +} +void wk2114_RFTRIG_INT_Handler(WK2114_TypeDef *wk2114, uint8_t it_type) +{ + +} +void wk2114_TFEMPTY_INT_Handler(WK2114_TypeDef *wk2114, uint8_t it_type) +{ + +} +void wk2114_TFTRIG_INT_Handler(WK2114_TypeDef *wk2114, uint8_t it_type) +{ + +} +// void WK2114_Task2(void * argument ) +// { +// WK2114_WORK_STATE_TypeDef *state = argument; +// static int err_con = 0; +// static int state_ok_count = 0; +// static uint8_t cmd; +// static uint8_t sub_uart_index; +// static uint8_t evt_flag = 0; +// static uint32_t fifo_readout_count = 0; +// static uint32_t subuart_sendqueue_count = 0; +// static WK2114_Sub_Uart_TypeDef *p_sub_uart; +// for ( ; ; ) +// { +// // log_i( "WK2114 WORK .... %d", *state ); +// switch (*state) +// { +// case WK2114_WORK_STATE_WAIT: + +// log_i( "WK2114_wait .... %d" ); +// osDelay(100); +// break; +// case WK2114_WORK_STATE_START: +// err_con = 0; +// wk2114->timebase = osKernelGetTickCount(); +// // wk2114_set_baud(wk2114); +// *state = WK2114_WORK_STATE_SET_BAUD; +// continue; +// case WK2114_WORK_STATE_SET_BAUD: +// { +// log_i( "WK2114_WORK_STATE_SET_BAUD .... %d", wk2114->flag & WK2114_G_FLAG_MASK_SENDING); +// wk2114->timebase = osKernelGetTickCount(); +// HAL_GPIO_WritePin(WK2XXX_IRQ_GPIO_PORT, WK2XXX_RST_PIN,GPIO_PIN_RESET); +// osDelay(10); +// HAL_GPIO_WritePin(WK2XXX_IRQ_GPIO_PORT, WK2XXX_RST_PIN,GPIO_PIN_SET); +// wk2114_set_baud(wk2114); +// osDelay(2); +// wk2114_set_baud(wk2114); +// osDelay(2); +// wk2114_set_baud(wk2114); +// osDelay(2); +// *state = WK2114_WORK_STATE_ADD_SUB_UART; +// continue; +// } + +// case WK2114_WORK_STATE_ADD_SUB_UART: +// { +// // log_i( "WK2114_WORK_STATE_SUB_UART_REGISTER Init .... "); +// if ( (wk2114->flag & WK2114_G_FLAG_MASK_SENDING) == 0 ) +// { +// err_con = 0; +// wk2114->timebase = osKernelGetTickCount(); +// WK2114_Add_Sub_Uart( wk2114 ); +// *state = WK2114_WORK_STATE_ADD_SUB_UART_OK; +// osDelay(2); +// continue;; +// } +// break; +// } + +// case WK2114_WORK_STATE_ADD_SUB_UART_OK: +// { +// // log_i( "WK2114_WORK_STATE_SUB_UART_REGISTER Init .... "); +// if ( osMessageQueueGetCount(wk2114->cmd_queue) > 0 && (wk2114->flag & WK2114_G_FLAG_MASK_SENDING) == 0) +// { +// wk2114_send(wk2114); +// // osDelay(1); +// } +// if ( osMessageQueueGetCount(wk2114->cmd_queue) == 0 && (wk2114->flag & WK2114_G_FLAG_MASK_SENDING) == 0) +// { +// *state=WK2114_WORK_STATE_OK; +// continue; +// } +// break; +// } + +// case WK2114_WORK_STATE_OK: +// { +// log_i( "WK2114_WORK_STATE_OK -->> wait exti ... " ); +// // 等待外部中断 +// uint32_t evt_flag = osEventFlagsWait(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING,0, portMAX_DELAY); +// if (evt_flag &MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING != 0) { +// log_d( " WK2114 IRQ exti happened ..... " ); +// *state= WK2114_WORK_STATE_EXTI_IT_SOURCE_GETTING; +// } +// // 等待子串口的size>0 +// continue; +// } + + +// // 外部中断 +// case WK2114_WORK_STATE_EXTI_IT_SOURCE_GETTING: +// { +// log_i( " IT_SOURCE getting .... " ); +// osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING); +// err_con = 0; +// wk2114->size_received=0; + +// // wk2114->flag|=WK2114_G_FLAG_MASK_INTER; +// wk2114->send_buf[0] = (WK2114_CMD_READ_REG<<6)+WK2114_G_REG_GIFR; +// wk2114->send_buf[1] = 0x00; +// // log_i( " IT_SOURCE SENDING.... sendbuf %02X " , wk2114->send_buf[0] ); + +// // // 开启接收中断 +// memset(wk2xxx_rcvbuf, 0, 1024); +// __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE); +// HAL_UART_Receive_DMA(pWK2114Uart, wk2xxx_rcvbuf, 1024); +// // HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, wk2xxx_rcvbuf, 1024); +// wk2114->send_fun(wk2114->send_class, wk2114->send_buf , 2); +// // wk2114_read_reg( wk2114, WK2114_G_REG_GIFR ); +// p_sub_uart =NULL; +// *state = WK2114_WORK_STATE_EXTI_IT_SOURCE_RECEIVE ; +// continue; +// } + +// case WK2114_WORK_STATE_EXTI_IT_SOURCE_RECEIVE: +// { +// evt_flag = osEventFlagsWait(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_RECEIVED,0, 0x200); +// if (evt_flag & MODULE_WK2114_EVENT_EXTI_IT_SOURCE_RECEIVED == 0) { +// log_i( " Get It SOurce ..... TimeOut " ); +// *state = WK2114_WORK_STATE_ERROR; +// continue; +// } + +// // log_i(" it source reg >>>>>>>>>>>>>>> %02X ", wk2xxx_rcvbuf[0] ); + +// // 处理接收到的中断源数据 +// cmd = wk2114->send_buf[0]; // 上次发送buf第一位 send_buf[0] +// wk2114->send_buf[0] = 0; + +// if( wk2114->size_received == 1 ){ +// HAL_UART_DMAStop(pWK2114Uart); +// } + +// if( !WK2114_CMD_IS_READ(cmd) ){ +// *state=WK2114_WORK_STATE_ERROR; +// } + +// if ( !WK2114_CMD_IS_REG(cmd)) { +// *state=WK2114_WORK_STATE_ERROR; +// } + +// if(!WK2114_REG_IS_GLOBAL(cmd)){ +// *state=WK2114_WORK_STATE_ERROR; +// } + +// if(wk2114->cmd!=0xff){ +// *state=WK2114_WORK_STATE_ERROR; +// } + +// wk2114->cmd=cmd; +// wk2114->reg= wk2xxx_rcvbuf[0]; +// wk2114->it_sub_uart_index = wk2114->reg&0x03 -1; +// p_sub_uart = wk2114->sub_uart[wk2114->it_sub_uart_index]; +// // wk2114->it_sub_uart = wk2114->sub_uart[wk2114->it_sub_uart_index]; + +// if( (wk2114->reg&0x0F)==0 ) { +// *state = WK2114_WORK_STATE_OK; +// }else{ +// wk2114->it_sub_uart_index = wk2114->reg&0x03 -1; +// p_sub_uart = wk2114->sub_uart[wk2114->it_sub_uart_index]; +// // wk2114->it_sub_uart = wk2114->sub_uart[wk2114->it_sub_uart_index]; +// *state = WK2114_WORK_STATE_EXTI_IT_TYPE_GETTING; +// } +// continue; +// } + +// case WK2114_WORK_STATE_EXTI_IT_TYPE_GETTING: +// { +// log_i( "_IT_TYPE getting .... last rcv it_source --> subuart 0x%02X" , wk2114->reg); +// osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_RECEIVED ); + +// wk2114->send_buf[0] = (WK2114_CMD_READ_REG<<6) +// + (wk2114->it_sub_uart_index<<4) +// + WK2114_S_REG_SIFR ; +// wk2114->send_buf[1] = 0x00; +// // // 开启接收中断 +// memset(wk2xxx_rcvbuf, 0, 1024); +// __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE ); +// HAL_UART_Receive_DMA(pWK2114Uart, wk2xxx_rcvbuf, 1024); +// // HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, wk2xxx_rcvbuf, 1024); + +// // wk2114_read_reg(wk2114, WK2114_BUILD_SUB_REG( wk2114->it_sub_uart_index, WK2114_S_REG_SIFR) ); +// wk2114->send_fun( wk2114->send_class, wk2114->send_buf , 2 ); + +// *state = WK2114_WORK_STATE_EXTI_IT_TYPE_RECEIVE; +// continue; +// } + +// case WK2114_WORK_STATE_EXTI_IT_TYPE_RECEIVE: +// { +// log_d( "_IT_TYPE _RECEIVE .... " ); + +// evt_flag = osEventFlagsWait( wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_TYPE_RECEIVED, 0, 0x800 ); +// if ( (evt_flag & MODULE_WK2114_EVENT_EXTI_IT_TYPE_RECEIVED) == 0 ) { +// log_w( " GET IT TYPE ..... TimeOut ..... " ); +// *state = WK2114_WORK_STATE_ERROR; +// continue; +// } +// // if (p_sub_uart==NULL ) { +// // log_w( " GET IT TYPE ..... p_sub_uart==NULL " ); +// // *state = WK2114_WORK_STATE_ERROR; +// // } + +// // log_d("_IT_TYPE reg >>>>>>>>>>>>>>> cmd 0x%02X ittype 0x%02X ", wk2114->send_buf[0], wk2xxx_rcvbuf[0] ); + +// // cmd = wk2114->send_buf[0]; // 上次发送内容第一位 send_buf[0] +// // wk2114->send_buf[0] = 0; +// // p_sub_uart->cmd = wk2114->send_buf[0]; +// // p_sub_uart->reg = wk2xxx_rcvbuf[0]; + +// // log_d("_IT_TYPE reg >>>>>>>>>>>>>>> cmd 0x%02X ittype 0x%02X cmd 0x%02X", wk2114->send_buf[0], wk2xxx_rcvbuf[0] ,cmd); + +// // if( wk2114->size_received == 1 ){ +// // HAL_UART_DMAStop(pWK2114Uart); +// // } + +// // if( !WK2114_CMD_IS_READ(cmd) ){ +// // *state=WK2114_WORK_STATE_ERROR; +// // } + +// // if ( !WK2114_CMD_IS_REG(cmd) ) { +// // *state=WK2114_WORK_STATE_ERROR; +// // } + +// // if( WK2114_REG_IS_GLOBAL(cmd) ){ +// // *state=WK2114_WORK_STATE_ERROR; +// // } + +// // if( wk2114->cmd!=0xff ){ +// // *state=WK2114_WORK_STATE_ERROR; +// // } + +// *state = WK2114_WORK_STATE_EXTI_PROCESS; +// continue; +// } + +// case WK2114_WORK_STATE_EXTI_PROCESS: +// { +// log_d("_IT_ PROCESS .... p_sub_uart->reg (it type) 0x%02X p_sub_uart->cmd 0x%02X", +// p_sub_uart->reg, p_sub_uart->cmd); + +// if (p_sub_uart==NULL ) { +// *state = WK2114_WORK_STATE_ERROR; +// } +// // if ( (p_sub_uart->flag&WK2114_S_UART_FLAG_MASK_PAGE_D)==0 ) { +// // *state = WK2114_WORK_STATE_ERROR; +// // } + +// // WK2114_S_REG_SIFR 子串口中断标志寄存器 +// // if(WK2114_CMD_GET_ADDR(p_sub_uart->cmd)!=WK2114_BUILD_SUB_REG(wk2114->it_sub_uart_index,WK2114_S_REG_SIFR)){ +// // *state=WK2114_WORK_STATE_ERROR; +// // } + +// // log_d("_IT_ type .... %d state %d", p_sub_uart->reg,*state ); + +// // // 接收错误中断 +// // if( (p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_FERR_INT)!=0 ){ +// // *state = WK2114_WORK_STATE_EXTI_PROCESS_FERR_INT; +// // continue; +// // } +// // // 接收字节超时中断 读取字节数 +// // if( (p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_RXOVT_INT)!=0 ){ +// // *state = WK2114_WORK_STATE_EXTI_PROCESS_RXOVT_INT; +// // continue; +// // } +// // // 接收FIFO触点中断 +// // if( (p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_RFTRIG_INT)!=0 ){ +// // *state = WK2114_WORK_STATE_EXTI_PROCESS_RFTRIG_INT; +// // continue; +// // } +// // // FIFO触点发送为空中断 发送子串口队列 +// // if( (p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFEMPTY_INT)!=0 +// // && wk2114->sub_uart[wk2114->it_sub_uart_index]->send_buf_p==0xffffffff ) { +// // *state = WK2114_WORK_STATE_EXTI_PROCESS_TFEMPTY_INT; +// // continue; +// // } +// // // 发送FIFO触点中断 发送同一个字符串 +// // // if((p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFTRIG_INT)!=0){ +// // if( (p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFTRIG_INT)!=0 ){ +// // log_d("_IT_ type .... %d", p_sub_uart->reg ); +// // // *state = WK2114_WORK_STATE_EXTI_PROCESS_TFTRIG_INT; +// // continue; +// // } + +// continue; +// } + +// case WK2114_WORK_STATE_EXTI_PROCESS_RXOVT_INT: +// { +// log_w(" Rcv Fifo Byte Overtime Int .... "); +// wk2114->send_buf[0] = (WK2114_CMD_READ_REG<<6) +// + (wk2114->it_sub_uart_index<<4) +// + WK2114_S_REG_RFCNT ; +// wk2114->send_buf[1] = 0x00; +// // // 开启接收中断 +// __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE ); +// HAL_UART_Receive_DMA(pWK2114Uart, wk2xxx_rcvbuf, 1024); +// // HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, wk2xxx_rcvbuf, 1024); + +// // wk2114_read_reg( wk2114, WK2114_BUILD_SUB_REG( wk2114->it_sub_uart_index, WK2114_S_REG_RFCNT) ); +// wk2114->send_fun( wk2114->send_class, wk2114->send_buf , 2 ); +// *state = WK2114_WORK_STATE_EXTI_PROCESS_GET_FIFO_COUNT; +// continue; +// } + + +// case WK2114_WORK_STATE_EXTI_PROCESS_RFTRIG_INT: +// log_i("Rcv Fifo Trigger .... read rcv fifo count "); +// // // 开启接收中断 +// __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE ); +// HAL_UART_Receive_DMA(pWK2114Uart, wk2xxx_rcvbuf, 1024); +// // HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, wk2xxx_rcvbuf, 1024); +// wk2114_read_fifo( wk2114, wk2114->it_sub_uart_index, 128-1 ); +// *state = WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT; +// continue; + +// case WK2114_WORK_STATE_EXTI_PROCESS_TFEMPTY_INT: +// log_w("TF Fifo Empty Int.... "); +// if((p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFEMPTY_INT)!=0 && p_sub_uart->send_buf_p==0xffffffff){ +// log_w(" send fifo trigger == 0"); +// p_sub_uart->send_buf_p=0; +// uint8_t queue_count = osMessageQueueGetCount(p_sub_uart->send_queue); +// // 判断 子串口的 发送队列是否为空 +// // p_de=queue_get_de_index(&p_sub_uart->send_queue); +// // if(p_de>=0){ +// if (osMessageQueueGetCount(p_sub_uart->send_queue) >= 0){ +// if(p_sub_uart->send_record[queue_count-1].size-p_sub_uart->send_buf_p <= 256){ +// struct wk2114_send_record record; +// osMessageQueueGet(p_sub_uart->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); +// wk2114_write_fifo(wk2114,sub_uart_index,record.p_data[p_sub_uart->send_buf_p],record.size-p_sub_uart->send_buf_p-1); +// // wk2114_write_fifo(wk2114,i,&p_sub_uart->send_record[p_de].p_data[p_sub_uart->send_buf_p],p_sub_uart->send_record[p_de].size-p_sub_uart->send_buf_p-1); +// p_sub_uart->send_buf_p=0xffffffff; +// // queue_dequeue(&p_sub_uart->send_queue,NULL); +// } +// else{ // buff 大于256， 发送 256, 记录发送位置 p_sub_uart->send_buf_p +// wk2114_write_fifo(wk2114,sub_uart_index,&p_sub_uart->send_record[queue_count-1].p_data[p_sub_uart->send_buf_p],255); +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFTRIG_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// p_sub_uart->send_buf_p+=256; +// } +// } +// else{ +// // 子串口队列无发送任务，取消发送出点为空中断 +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// *state = WK2114_WORK_STATE_STOP; +// } +// } +// continue; +// case WK2114_WORK_STATE_EXTI_PROCESS_TFTRIG_INT: +// log_w("Trans Fifo Trigger Int.... "); +// subuart_sendqueue_count = osMessageQueueGetCount(p_sub_uart->send_queue); +// if (subuart_sendqueue_count >= 0){ +// if(p_sub_uart->send_buf_p >= p_sub_uart->send_record[subuart_sendqueue_count-1].size){ +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// p_sub_uart->send_buf_p=0xffffffff; +// return; +// } +// if(p_sub_uart->send_record[subuart_sendqueue_count-1].size-p_sub_uart->send_buf_p <= 128){ +// struct wk2114_send_record record; +// osMessageQueueGet(p_sub_uart->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); +// wk2114_write_fifo(wk2114,sub_uart_index,record.p_data[p_sub_uart->send_buf_p],record.size-p_sub_uart->send_buf_p-1); + +// // wk2114_write_fifo(wk2114,i,&p_sub_uart->send_record[p_de].p_data[p_sub_uart->send_buf_p],p_sub_uart->send_record[p_de].size-p_sub_uart->send_buf_p-1); +// p_sub_uart->send_buf_p=0xffffffff; +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// // queue_dequeue(&p_sub_uart->send_queue,NULL); +// } +// else{ +// wk2114_write_fifo(wk2114,sub_uart_index,&p_sub_uart->send_record[subuart_sendqueue_count-1].p_data[p_sub_uart->send_buf_p],127); +// p_sub_uart->send_buf_p+=128; +// } +// } +// else{ +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// *state = WK2114_WORK_STATE_STOP; +// } + +// break; +// case WK2114_WORK_STATE_EXTI_PROCESS_FERR_INT: +// log_e("Fifo Error .... "); +// __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE ); +// HAL_UART_Receive_DMA(pWK2114Uart, &wk2114->reg_readout, 1 ); +// // HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, wk2xxx_rcvbuf, 1024); +// wk2114_read_subuart_reg( wk2114, wk2114->it_sub_uart_index, WK2114_S_REG_LSR ); +// *state = WK2114_WORK_STATE_STOP; +// break; + +// case WK2114_WORK_STATE_EXTI_PROCESS_GET_FIFO_COUNT: +// { +// log_e("Read Fifo BUF .... "); +// evt_flag = osEventFlagsWait(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_COUNT_RECEIVED,0, 0x200); +// if ( (evt_flag & MODULE_WK2114_EVENT_EXTI_IT_TYPE_RECEIVED) == 0) { +// log_i( " GET _FIFO_COUNT ..... TimeOut " ); +// *state = WK2114_WORK_STATE_ERROR; +// continue; +// } + +// log_e(" _FIFO_COUNT .... %d ", wk2xxx_rcvbuf[0] ); + +// cmd = wk2114->send_buf[0]; // 上次发送内容第一位 send_buf[0] +// wk2114->send_buf[0] = 0; +// if( wk2114->size_received == 1 ){ +// HAL_UART_DMAStop(pWK2114Uart); +// } + +// if( !WK2114_CMD_IS_READ(cmd) ){ +// *state=WK2114_WORK_STATE_ERROR; +// } + +// if ( !WK2114_CMD_IS_REG(cmd)) { +// *state=WK2114_WORK_STATE_ERROR; +// } + +// if(WK2114_REG_IS_GLOBAL(cmd)){ +// *state=WK2114_WORK_STATE_ERROR; +// } + +// if(wk2114->cmd!=0xff){ +// *state=WK2114_WORK_STATE_ERROR; +// } +// wk2114->it_sub_uart->cmd = cmd; +// wk2114->it_sub_uart->reg = wk2xxx_rcvbuf[0]; +// fifo_readout_count = wk2114->it_sub_uart->reg; +// memset( wk2xxx_rcvbuf, 0, 1024 ); +// osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_COUNT_RECEIVED); + +// *state = WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT; +// continue; +// } +// case WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT: +// log_e( "Read Fifo BUF _BY_COUNT .... " ); + +// wk2114->send_buf[1] = 0x00; +// // memset( wk2xxx_rcvbuf, 0, 1024 ); +// __HAL_UART_ENABLE_IT(pWK2114Uart, UART_IT_IDLE ); +// HAL_UART_Receive_DMA(pWK2114Uart, wk2xxx_rcvbuf, 1024); + +// if (fifo_readout_count > 16 ) { +// wk2114->send_buf[0] = (WK2114_CMD_READ_FIFO<<6) +// + (wk2114->it_sub_uart_index<<4) +// + (16-1) ; +// fifo_readout_count -= 16; +// log_w( "Fifo read out %d", fifo_readout_count ); +// } else{ +// wk2114->send_buf[0] = (WK2114_CMD_READ_FIFO<<6) +// + (wk2114->it_sub_uart_index<<4) +// + (fifo_readout_count-1) ; +// fifo_readout_count = 0; +// log_w( "Fifo read out send last byte" ); +// } + +// // wk2114_read_fifo( wk2114, wk2114->it_sub_uart_index, wk2114->reg_readout ); +// wk2114->send_fun( wk2114->send_class, wk2114->send_buf , 2 ); + +// case WK2114_WORK_STATE_EXTI_READ_FIFO_DEAL: +// { +// log_e( "Read Fifo BUF ... Deal FIFO BUF " ); +// evt_flag = osEventFlagsWait(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_BUF_RECEIVED,0, 0x200); +// if ( (evt_flag & MODULE_WK2114_EVENT_EXTI_RCV_FIFO_BUF_RECEIVED) == 0) { +// log_i( " GET _FIFO _BUF _RECEIVED ... TimeOut ... " ); +// *state = WK2114_WORK_STATE_ERROR; +// continue; +// } + +// // TODO deal buf, 数量大于约定， 没有数据了，回调 +// log_i(" deal buf : %d " , wk2114->size_received); +// log_i(" deal buf : %02X %02X %02X %02X %02X %02X %02X %02X" , +// wk2xxx_rcvbuf[0], wk2xxx_rcvbuf[1], wk2xxx_rcvbuf[2], wk2xxx_rcvbuf[3], wk2xxx_rcvbuf[4], wk2xxx_rcvbuf[5], wk2xxx_rcvbuf[6], wk2xxx_rcvbuf[7] ); + +// if (fifo_readout_count == 0 ) { +// *state = WK2114_WORK_STATE_STOP; +// } +// else{ +// *state = WK2114_WORK_STATE_EXTI_READ_FIFO_BY_COUNT; +// } +// osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_BUF_RECEIVED ); + +// continue; +// } + +// case WK2114_WORK_STATE_ERROR: +// log_e("WK2114_WORK STATE ERROR .... "); +// HAL_UART_DMAStop(pWK2114Uart); +// *state = WK2114_WORK_STATE_WAIT; +// break; + +// case WK2114_WORK_STATE_STOP: +// log_e("WK2114_WORK STATE STOP ... "); +// HAL_UART_DMAStop(pWK2114Uart); +// *state = WK2114_WORK_STATE_OK; +// continue; + +// default: +// break; +// } +// osDelay(1); +// } + +// } + + +// /** +// * @brief wk2114中断回调 +// * @note 不要将此函数放入中断中或比其他回调函数优先级更高的任务中 +// * @param wk2114 WK2114_TypeDef 结构指针 +// * 外部中断, +// */ +// void wk2114_inter_callback(WK2114_TypeDef *wk2114) +// { +// // if( (osEventFlagsGet(wk2114EventHandle) & MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING) !=0){ +// // return; +// // } +// osEventFlagsSet(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING); +// // log_i( " exti ..... %d ",osKernelGetTickCount() ); + +// } + +// void wk2114_idle_callback(WK2114_TypeDef *wk2114, uint8_t *buf, uint32_t size) +// { +// // log_w( " wk2114_idle_callback .... %d ", wk2114->state ); +// wk2114->size_received = size; +// switch (wk2114->state) +// { +// // case WK2114_WORK_STATE_EXTI_IT_SOURCE_GETTING: +// case WK2114_WORK_STATE_EXTI_IT_SOURCE_RECEIVE: +// osEventFlagsSet( wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_RECEIVED ); +// return; +// // case WK2114_WORK_STATE_EXTI_IT_TYPE_GETTING: +// case WK2114_WORK_STATE_EXTI_IT_TYPE_RECEIVE: +// osEventFlagsSet( wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_TYPE_RECEIVED ); +// log_i( " it type idle ... " ); +// return; +// case WK2114_WORK_STATE_EXTI_PROCESS_GET_FIFO_COUNT: +// osEventFlagsSet( wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_COUNT_RECEIVED ); +// return; +// case WK2114_WORK_STATE_EXTI_READ_FIFO_DEAL: +// osEventFlagsSet( wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_BUF_RECEIVED ); +// return; +// default: +// break; +// } +// return; +// } + +// void wk2114_get_it_type_by_it_source(WK2114_TypeDef *wk2114 ) +// { +// // TODO 中断源同时为多个 ？？ 先依序发送出去 +// // log_i("get_it_type_by_it_source....it_source -> %d", wk2114->it_source ); + +// // if(WK2114_CMD_GET_ADDR(wk2114->cmd)==WK2114_G_REG_GIFR){ // 去读子串口中断类型 +// // wk2114->cmd=0; +// // if((wk2114->it_source&WK2114_G_REG_GIFR_MASK_UT1INT)!=0 && wk2114->sub_uart[WK2114_S_UART_1]!=NULL){ +// // wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_1,WK2114_S_REG_SIFR)); +// // } +// // if((wk2114->it_source&WK2114_G_REG_GIFR_MASK_UT2INT)!=0 && wk2114->sub_uart[WK2114_S_UART_2]!=NULL){ +// // wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_2,WK2114_S_REG_SIFR)); +// // } +// // if((wk2114->it_source&WK2114_G_REG_GIFR_MASK_UT3INT)!=0 && wk2114->sub_uart[WK2114_S_UART_3]!=NULL){ +// // wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_3,WK2114_S_REG_SIFR)); +// // } +// // if((wk2114->it_source&WK2114_G_REG_GIFR_MASK_UT4INT)!=0 && wk2114->sub_uart[WK2114_S_UART_4]!=NULL){ +// // wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(WK2114_S_UART_4,WK2114_S_REG_SIFR)); +// // } +// // } + +// // while (osMessageQueueGetCount(wk2114->cmd_queue) > 0) +// // { +// // wk2114_send(wk2114); +// // } + +// // return; + +// } + + +// void wk2114_process_by_it_type(WK2114_TypeDef *wk2114, uint8_t it_type) +// { +// int sub_uart_index ; +// int p_de; +// log_i( " wk2114_process_by_it_type .... "); + +// WK2114_Sub_Uart_TypeDef *p_sub_uart; +// sub_uart_index = WK2114_CMD_GET_SUB_UART(wk2114->cmd); +// p_sub_uart = wk2114->sub_uart[WK2114_CMD_GET_SUB_UART(wk2114->cmd)]; +// // 判断中断类型 + +// if (p_sub_uart!=NULL ) return ; +// if ((p_sub_uart->flag&WK2114_S_UART_FLAG_MASK_PAGE_D)==0) return ; + +// // WK2114_S_REG_SIFR 子串口中断标志寄存器 +// if(WK2114_CMD_GET_ADDR(p_sub_uart->cmd)==WK2114_BUILD_SUB_REG(sub_uart_index,WK2114_S_REG_SIFR)){ +// p_sub_uart->cmd=0; + +// // 接收超时 +// if( (p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_RXOVT_INT)!=0 ){ +// log_i(" 接收FIFO overtime it ... "); +// p_sub_uart->flag|=WK2114_S_UART_FLAG_MASK_IDLE; +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(sub_uart_index,WK2114_S_REG_RFCNT)); +// } + +// // 接收FIFO触点中断 +// if((p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_RFTRIG_INT)!=0){ +// log_i(" 接收FIFO触点中断 ... "); +// wk2114_read_fifo(wk2114, wk2114->cmd, 126 ); +// } + +// // 发送FIFO空中断 , 判断子串口发送队列，将子串口send_buf 发送出去 +// if((p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFEMPTY_INT)!=0 && p_sub_uart->send_buf_p==0xffffffff){ +// log_w(" send fifo trigger == 0"); +// p_sub_uart->send_buf_p=0; +// // 判断 子串口的 发送队列是否为空 +// // p_de=queue_get_de_index(&p_sub_uart->send_queue); +// // if(p_de>=0){ +// if (osMessageQueueGetCount(p_sub_uart->send_queue) >= 0){ +// if(p_sub_uart->send_record[p_de].size-p_sub_uart->send_buf_p <= 256){ +// struct wk2114_send_record record; +// osMessageQueueGet(p_sub_uart->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); +// wk2114_write_fifo(wk2114,sub_uart_index,record.p_data[p_sub_uart->send_buf_p],record.size-p_sub_uart->send_buf_p-1); +// // wk2114_write_fifo(wk2114,i,&p_sub_uart->send_record[p_de].p_data[p_sub_uart->send_buf_p],p_sub_uart->send_record[p_de].size-p_sub_uart->send_buf_p-1); +// p_sub_uart->send_buf_p=0xffffffff; +// // queue_dequeue(&p_sub_uart->send_queue,NULL); +// } +// else{ // buff 大于256， 发送 256, 记录发送位置 p_sub_uart->send_buf_p +// wk2114_write_fifo(wk2114,sub_uart_index,&p_sub_uart->send_record[p_de].p_data[p_sub_uart->send_buf_p],255); +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFTRIG_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); + +// p_sub_uart->send_buf_p+=256; +// } +// } +// else{ +// // 子串口队列无发送任务，取消发送出点为空中断 +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// } +// } + +// // 发送FIFO触点中断, 装载子串口发送队列 send_buf +// if((p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_TFTRIG_INT)!=0){ +// log_w(" send fifo trigger == 1"); +// // p_de=queue_get_de_index(&p_sub_uart->send_queue); +// // if(p_de>=0){ +// if (osMessageQueueGetCount(p_sub_uart->send_queue) >= 0){ +// if(p_sub_uart->send_buf_p >= p_sub_uart->send_record[p_de].size){ +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// p_sub_uart->send_buf_p=0xffffffff; +// return; +// } +// if(p_sub_uart->send_record[p_de].size-p_sub_uart->send_buf_p <= 128){ +// struct wk2114_send_record record; +// osMessageQueueGet(p_sub_uart->send_queue,(void*) &record,sizeof(record),portMAX_DELAY); +// wk2114_write_fifo(wk2114,sub_uart_index,record.p_data[p_sub_uart->send_buf_p],record.size-p_sub_uart->send_buf_p-1); + +// // wk2114_write_fifo(wk2114,i,&p_sub_uart->send_record[p_de].p_data[p_sub_uart->send_buf_p],p_sub_uart->send_record[p_de].size-p_sub_uart->send_buf_p-1); +// p_sub_uart->send_buf_p=0xffffffff; +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_TFEMPTY_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// // queue_dequeue(&p_sub_uart->send_queue,NULL); +// } +// else{ +// wk2114_write_fifo(wk2114,sub_uart_index,&p_sub_uart->send_record[p_de].p_data[p_sub_uart->send_buf_p],127); +// p_sub_uart->send_buf_p+=128; +// } +// } +// else{ +// wk2114_sub_uart_set_inter(p_sub_uart,WK2114_S_REG_SIFR_MASK_RFTRIG_INT|WK2114_S_REG_SIFR_MASK_RXOVT_INT|WK2114_S_REG_SIFR_MASK_FERR_INT); +// } +// } +// // 接收错误中断 +// if( (p_sub_uart->reg&WK2114_S_REG_SIFR_MASK_FERR_INT)!=0 ){ +// wk2114_read_reg( wk2114,WK2114_BUILD_SUB_REG(sub_uart_index,WK2114_S_REG_LSR) ); +// } +// } + +// //子串口接收FIFO计数寄存器 +// if(WK2114_CMD_GET_ADDR(p_sub_uart->cmd)==WK2114_BUILD_SUB_REG(sub_uart_index,WK2114_S_REG_RFCNT)){ +// p_sub_uart->cmd=0; +// wk2114_read_fifo(wk2114,sub_uart_index,p_sub_uart->reg-1); +// } +// //子串口接收状态寄存器 +// if(WK2114_CMD_GET_ADDR(p_sub_uart->cmd)==WK2114_BUILD_SUB_REG(sub_uart_index,WK2114_S_REG_LSR)){ +// p_sub_uart->cmd=0; +// wk2114_read_reg(wk2114,WK2114_BUILD_SUB_REG(sub_uart_index,WK2114_S_REG_FSR)); +// } +// //子串口FIFO状态寄存器 +// if(WK2114_CMD_GET_ADDR(p_sub_uart->cmd)==WK2114_BUILD_SUB_REG(sub_uart_index,WK2114_S_REG_FSR)){ +// p_sub_uart->cmd=0; +// } + +// return; +// } + + + + + + + + + + + + + + + + + + + // case WK2114_WORK_STATE_EXTI_READ_IT_TYPE: + // // Timeout + // HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, wk2xxx_rcvbuf, 1024); + + // wk2114->send_buf[0] = (WK2114_CMD_READ_REG<<6) + WK2114_BUILD_SUB_REG(sub_uart, WK2114_S_REG_SIFR); + // wk2114->send_buf[1] = 0x00; + // wk2114->send_fun(wk2114->send_class, wk2114->send_buf , 2); + + // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_GET_IT_SOURCE); + // *state = WK2114_WORK_STATE_EXTI_READ_IT_TYPE_OK; + // continue; + + // case WK2114_WORK_STATE_EXTI_READ_IT_TYPE_OK: + // log_i( "WK2114_WORK_STATE_EXTI_READ_IT_ TYPE_OK .... " ); + // // uint8_t cmd; + // cmd = wk2114->send_buf[0]; // 上次发送内容第一位 send_buf[0] + // wk2114->send_buf[0] = 0; + // sub_uart = WK2114_CMD_GET_SUB_UART(cmd); + // p_sub_uart=wk2114->sub_uart[sub_uart]; + + // if(wk2114->size_received ==1){ + // wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; + // } + + // if( !WK2114_CMD_IS_READ(cmd) ){ + // *state=WK2114_WORK_STATE_ERROR; + // } + + // if ( !WK2114_CMD_IS_REG(cmd)) { + // *state=WK2114_WORK_STATE_ERROR; + // } + + // if(WK2114_REG_IS_GLOBAL(cmd)){ + // *state=WK2114_WORK_STATE_ERROR; + // } + + // if(p_sub_uart==NULL || wk2114->sub_uart[sub_uart]->cmd!=0xff){ + // *state=WK2114_WORK_STATE_ERROR; + // } + + // p_sub_uart->cmd=cmd; + // p_sub_uart->reg=wk2xxx_rcvbuf[0]; + + // // 开启接收中断 + // wk2114->size_received=0; + // if (HAL_DMA_GetState(pWK2114Uart->hdmarx) == HAL_DMA_STATE_BUSY) + // { + // HAL_UART_DMAStop(pWK2114Uart); + // } + // HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, wk2xxx_rcvbuf, 1024); + // // 依据中断 中断的类型， 进行数据处理 + // wk2114_process_by_it_type(wk2114); + // // *state = WK2114_WORK_STATE_EXTI_PROCESS_DATA; + // continue; + + // case WK2114_WORK_STATE_EXTI_PROCESS_DATA: + // // Timeout + // if ( (osKernelGetTickCount() - wk2114->timebase) > wk2114->timeout_ms ) + // { + // log_w( "wk2114 EXTI PROCESS_DATA Failed %d, Retrying...", err_con ); + // err_con++; + // wk2114->timebase = osKernelGetTickCount(); + // if(err_con>10){ + // log_e("EXTI PROCESS_DATA Error"); + // *state=WK2114_WORK_STATE_ERROR; + // break; + // } + // } + // // *state = WK2114_WORK_STATE_EXTI_READ_IT_SOURCE_OK; + // osDelay(2); + // *state = WK2114_WORK_STATE_EXTI_PROCESS_DATA_OK; + // continue; + // case WK2114_WORK_STATE_EXTI_PROCESS_DATA_OK: + // log_e("WK2114_WORK_STATE_EXTI PROCESS_DATA_OK .. "); + // // uint8_t cmd; + // uint8_t cmd_size; + // cmd = wk2114->send_buf[0]; // 上次发送内容第一位 send_buf[0] + // wk2114->send_buf[0] = 0; + // cmd_size=WK2114_CMD_GET_SIZE(cmd); // 命令要读取的数量 + // sub_uart = WK2114_CMD_GET_SUB_UART(cmd); + // p_sub_uart=wk2114->sub_uart[sub_uart]; + + // if(wk2114->size_received >=1){ + // wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; + // } + // // 读数据回调 + // if( wk2114->size_received!=cmd_size ){ // 命令读取数量和实际读取数量不一致 + // *state=WK2114_WORK_STATE_ERROR; + // } + + // // 拷贝数据 + // if(p_sub_uart->recv_buf_size-p_sub_uart->recv_buf_p < wk2114->size_received){ // subuart buf甚于空间不足 + // cmd_size=p_sub_uart->recv_buf_size-p_sub_uart->recv_buf_p; + // } + // // memcpy(&p_sub_uart->recv_buf[p_sub_uart->recv_buf_p],buf,cmd_size); + // p_sub_uart->recv_buf_p+=cmd_size; + + // // 数据向上回调 （判断 发送队列是否为空 且空闲 ） + // if ( osMessageQueueGetCount(wk2114->cmd_queue) == 0 && (p_sub_uart->flag&WK2114_S_UART_FLAG_MASK_IDLE)==1 ) + // { + // p_sub_uart->flag&=~WK2114_S_UART_FLAG_MASK_IDLE; + // p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); + // p_sub_uart->recv_buf_p=0; + // } + // // 数据向上回调 （判断 缓冲区满，） + // if( p_sub_uart->recv_buf_p==p_sub_uart->recv_buf_size ) // 缓冲区满 + // { + // p_sub_uart->recv_fun(p_sub_uart->recv_class,p_sub_uart->recv_buf,p_sub_uart->recv_buf_p); + // p_sub_uart->recv_buf_p = wk2114->size_received -cmd_size; + // // memcpy(p_sub_uart->recv_buf,&buf[cmd_size],p_sub_uart->recv_buf_p); + // } + // wk2114->flag&=~WK2114_G_FLAG_MASK_BUSY_RCV; + // break; + + + // case WK2114_WORK_STATE_SET_BAUD_OK: + // { + // log_i( "WK2114_WORK_STATE_SET_BAUD .... " ); + // if (wk2114->setbaud_ok) + // { + // HAL_UART_DMAStop(pWK2114Uart); + // *state = WK2114_WORK_STATE_OK; + // break; + // } + // if ( wk2114->timebase-osKernelGetTickCount() >200) + // { + // err_con++; + // log_i( " set Baud, retry %d times ", err_con ); + // if (err_con>10) + // { + // *state = WK2114_WORK_STATE_ERROR; + // break; + // } + // HAL_UART_DMAStop(pWK2114Uart); + // *state = WK2114_WORK_STATE_SET_BAUD; + // break; + // } + // osDelay(20); + // continue; + // } + + // case WK2114_WORK_STATE_READ_GREG_0: + // { + // log_i( "WK2114_WORK_STATE_READ_GREG_0 .... " ); + // wk2114->timebase = osKernelGetTickCount(); + // wk2114_mainport_rcv( wk2114); + // // wk2114_read_global_reg(wk2114,WK2114_G_REG_GENA ); + // uint8_t reg_0 = 0x40; + // wk2114->send_fun(wk2114->send_class,®_0,1); + // *state = WK2114_WORK_STATE_READ_GREG_0_OK; + // continue; + // } + // case WK2114_WORK_STATE_READ_GREG_0_OK: + // { + // log_i( "WK2114_WORK_STATE_READ_GREG_0 OK .... " ); + // if (wk2114->read_greg0_ok) + // { + // HAL_UART_DMAStop(pWK2114Uart); + // *state = WK2114_WORK_STATE_OK; + // break; + // } + // if ( wk2114->timebase-osKernelGetTickCount() >2000) + // { + // err_con++; + // log_i( " READ_GREG_0, retry %d times ", err_con ); + // if (err_con>10) + // { + // *state = WK2114_WORK_STATE_ERROR; + // break; + // } + // HAL_UART_DMAStop(pWK2114Uart); + // *state = WK2114_WORK_STATE_SET_BAUD; + // break; + // } + // osDelay(20); + // continue; + // } + +// #define WK2114_Uart_IRQHandler USART3_IRQHandler +// UART_HandleTypeDef *pWK2114Uart = &huart3; + +// // WK2114_Sub_Uart_TypeDef *sub_uart1 = NULL; +// // uint8_t sub_uart1_receive_buf[1024]; + +// int Sub_rcv_callback(void * obj, uint8_t * buf, uint16_t len) +// { +// return 0; +// } + +// void WK2XXX_IRQ_HANDLER(void) +// { +// if( __HAL_GPIO_EXTI_GET_IT( GPIO_PIN_7 ) ) +// { +// log_i("EXTI9_5_IRQHandler...."); + +// wk2114_inter_callback( wk2114); +// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_7); +// } +// // HAL_GPIO_EXTI_IRQHandler(WK2114_IRQ_Pin); + +// } + +// // TODO 何时开启接收， 在 wk2114_read_reg 的时候 +// void WK2114_Uart_IRQHandler(void) +// { +// uint16_t count = 0; +// uint16_t data_length = 0; +// // uint32_t sending_flag = 0; +// // uint32_t ret = 0; + +// if (__HAL_UART_GET_FLAG(pWK2114Uart, UART_FLAG_TC) != RESET) +// { + +// log_i("WK2114 ..huart TC callback .. " ); +// // wk2114_send_completed_callback( wk2114); +// wk2114->flag&=~WK2114_G_FLAG_MASK_SENDING; + +// pWK2114Uart->gState = HAL_UART_STATE_READY; +// __HAL_UART_CLEAR_FLAG(pWK2114Uart, UART_FLAG_TC); +// } + +// if (__HAL_UART_GET_FLAG(pWK2114Uart, UART_FLAG_IDLE) != RESET) +// { +// count = __HAL_DMA_GET_COUNTER( pWK2114Uart->hdmarx ); +// log_i("WK2114 ..huart IDLE ... %d", 1024 - count); +// data_length = 1024 - count; +// if ( data_length > 0 ) +// { +// // wk2114_idle_callback(wk2114, wk2xxx_rcvbuf, data_length); +// // wk2114_reg_recv_callback(wk2114); +// // wk2114_recv_callback(wk2114, wk2xxx_rcvbuf, data_length ); +// // log_i("WK2114_ IDLE.. data_length %d %02X", data_length, wk2xxx_rcvbuf[0]); +// } +// __HAL_UART_CLEAR_IDLEFLAG( pWK2114Uart ); +// } +// } + +// int WK2114_Add_Sub_Uart(WK2114_TypeDef *wk2114 ) +// { +// sub_uart1 = (WK2114_Sub_Uart_TypeDef *)malloc(sizeof(WK2114_Sub_Uart_TypeDef)); +// if (0!=wk2114_sub_uart_register(wk2114, sub_uart1,WK2114_S_UART_1,sub_uart1_receive_buf,sizeof(sub_uart1_receive_buf), &huart2, Sub_rcv_callback)) +// { +// log_e("sub-uart 1 register Failure ! "); +// }; + +// if (0!=wk2114_sub_uart_init( sub_uart1,115200,WK2114_SUB_UART_MODE_MASK_TX|WK2114_SUB_UART_MODE_MASK_RX,WK2114_SUB_UART_FIFO_MODE_MASK_TX|WK2114_SUB_UART_FIFO_MODE_MASK_RX,WK2114_UART_PARITY_NONE,WK2114_UART_STOP_BITS_1)) +// { +// log_e("sub-uart 1 init Failure ! "); +// } +// return 0; +// } + +// int WK2114_Init( ) +// { +// GPIO_InitTypeDef GPIO_InitStruct = {0}; +// WK2XXX_RST_GPIO_CLK_ENABLE(); +// WK2XXX_IRQ_GPIO_CLK_ENABLE(); +// // wk2XXX rst +// GPIO_InitStruct.Pin = WK2XXX_RST_PIN; +// GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; +// GPIO_InitStruct.Pull = GPIO_PULLUP; +// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; +// HAL_GPIO_Init(WK2XXX_RST_GPIO_PORT, &GPIO_InitStruct); + +// // wk2XXX irq +// GPIO_InitStruct.Pin = WK2XXX_IRQ_PIN; +// GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING; +// GPIO_InitStruct.Pull = GPIO_PULLDOWN; +// HAL_GPIO_Init(WK2XXX_IRQ_GPIO_PORT, &GPIO_InitStruct); + +// HAL_NVIC_SetPriority(WK2XXX_IRQ_EXTI_IRQ, 5, 0); +// HAL_NVIC_EnableIRQ(WK2XXX_IRQ_EXTI_IRQ); + +// wk2114 = (WK2114_TypeDef *)malloc(sizeof(WK2114_TypeDef)); +// wk2114->send_class = pWK2114Uart; +// wk2114->send_fun = HAL_UART_Transmit_DMA; + +// // 命令队列 uint8_t cmd_buf[64][2] , 消息类型 2个uint8_t +// wk2114->cmd_queue = osMessageQueueNew( 64, sizeof(wk2114->cmd_queue_msg_put), NULL); +// if (wk2114->cmd_queue ==NULL) return -1; + +// wk2114->cmd = 0; +// wk2114->flag = 0; +// wk2114->dev_clock_hz = WK2114_CLOCK_HZ; + +// for(size_t i=0;i<4;i++){ +// wk2114->sub_uart[i] = NULL; +// } + +// // HAL_GPIO_WritePin(WK2XXX_IRQ_GPIO_PORT, WK2XXX_RST_PIN,GPIO_PIN_RESET); +// // HAL_Delay(2); + +// // HAL_GPIO_WritePin(WK2XXX_IRQ_GPIO_PORT, WK2XXX_RST_PIN,GPIO_PIN_SET); +// wk2114_set_baud(wk2114); +// HAL_Delay(2); +// wk2114_set_baud(wk2114); +// HAL_Delay(2); +// wk2114_set_baud(wk2114); +// HAL_Delay(2); + +// osSemaphoreRelease(wk2xxx_lockHandle); + +// wk2114->size_received = 0; +// // wk2114->timebase = osKernelGetTickCount(); +// // wk2114->timeout_ms = 500; +// // wk2114->state = WK2114_WORK_STATE_WAIT; + +// // wk2114EventHandle = osEventFlagsNew ( &wk2114Event_attributes ); +// // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_SENDING ); +// // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_SOURCE_RECEIVED ); +// // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_TYPE_SENDING ); +// // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_IT_TYPE_RECEIVED ); +// // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_COUNT_RECEIVED ); +// // osEventFlagsClear(wk2114EventHandle, MODULE_WK2114_EVENT_EXTI_RCV_FIFO_BUF_RECEIVED ); +// return 0; +// } \ No newline at end of file