wk2114 modified

DOC/21_crc.md

@@ -0,0 +1,6 @@
+#### CRC
+
+uint32_t HAL_CRC_Calculate(CRC_HandleTypeDef *hcrc, uint32_t pBuffer[], uint32_t BufferLength);
+
+
+32位置的

DOC/22_rtc.md

@@ -0,0 +1,31 @@
+####  RTC
+
+ HAL_StatusTypeDef HAL_RTC_SetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format);
+HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format);
+HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format);
+HAL_StatusTypeDef HAL_RTC_GetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format);
+
+
+typedef struct
+{
+  uint8_t Hours;      
+  uint8_t Minutes;     
+  uint8_t Seconds;         
+  uint8_t TimeFormat;      
+  uint32_t SubSeconds;     
+
+  uint32_t SecondFraction;   
+
+  uint32_t DayLightSaving;  
+
+  uint32_t StoreOperation;  
+} RTC_TimeTypeDef;
+ 
+
+typedef struct
+{
+  uint8_t WeekDay;  
+  uint8_t Month;    
+  uint8_t Date;    
+  uint8_t Year;    
+} RTC_DateTypeDef;

base/Src/delay_port.c

@@ -0,0 +1,136 @@
+#include "FreeRTOS.h"
+#include "task.h"
+#include "main.h"
+#include "cmsis_os.h"
+#include "tim.h"
+
+extern void delay_us(uint16_t nus);
+
+// HAL_RCC_GetSysClockFreq(void)
+
+typedef enum{
+    DELAY_DEFAULT,
+    DELAY_SYSTICK,
+    DELAY_SYSTICK_COMPLEX,
+    DELAY_TIMER,   
+
+}DELAY_US_TypeDef;
+// SystemCoreClock
+ 
+TIM_HandleTypeDef *Delay_TIM_hanle = NULL;
+
+#define  DELAY_US_TYPE DELAY_DEFAULT
+
+
+void delay_us(uint16_t nus)
+{ 
+#if DELAY_US_TYPE == DELAY_DEFAULT
+    uint32_t  cnt = nus * (SystemCoreClock/8000000);
+    while(cnt--);
+#endif
+
+#if DELAY_US_TYPE == DELAY_TIMER
+ 
+    __HAL_TIM_SET_COUNTER(&htim10, 0);  // set the counter value a 0
+    __HAL_TIM_ENABLE(&htim10);          // start the counter
+    // wait for the counter to reach the us input in the parameter
+    while (__HAL_TIM_GET_COUNTER(&htim10) < nus);
+    __HAL_TIM_DISABLE(&htim10);         // stop the counter
+ 
+#endif
+
+#if DELAY_US_TYPE == DELAY_SYSTICK
+    SysTick->LOAD = (nus * (SystemCoreClock/8000000))-1; 
+    SysTick->VAL = 0;
+    SysTick->CTRL = 0;
+    SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
+    while (!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk));
+    SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk; 
+
+#endif
+
+#if DELAY_US_TYPE == DELAY_SYSTICK_COMPLEX
+ 
+    // 暂停系统，实现微秒延时
+	// 保存sysTick的状态 
+	uint32_t val_temp=SysTick->VAL;
+	uint32_t load_temp=SysTick->LOAD;
+	uint16_t ctrl_temp=SysTick->CTRL;
+
+	/*SysTick状态重新设置，用于延时（系统暂停）*/
+	// SysTick->LOAD = 9 * us;		// 设置定时器重装值,72MHz 8分频后9HMz，即一微秒记9个数
+	SysTick->LOAD = (nus * HAL_RCC_GetSysClockFreq()/1000000)   - 1;		// 设置定时器重装值,168MHz 8分频后21HMz，即一微秒记21个数
+	SysTick->VAL = 0x00;		// 清空当前计数值,清空后会自动装入重载值
+	SysTick->CTRL = 0x00000001; // 位2设置为0，8分频，启动定时器
+	while (!(SysTick->CTRL & 0x00010000));// 等待计数到0
+	
+	/*延时结束后恢复之前的状态，系统继续运行*/
+	SysTick->LOAD = load_temp;
+	SysTick->VAL = val_temp;
+	SysTick->CTRL = ctrl_temp;
+	//SysTick->CTRL = 0x00000000; // 关闭定时器
+#endif
+
+}
+
+ 
+// #if DELAY_US_TYPE == DELAY_TIMER
+// void delay_us(uint16_t nus)
+// { 
+//     __HAL_TIM_SET_COUNTER(&htim10, 0);  // set the counter value a 0
+//     __HAL_TIM_ENABLE(&htim10);          // start the counter
+//     // wait for the counter to reach the us input in the parameter
+//     while (__HAL_TIM_GET_COUNTER(&htim10) < nus);
+//     __HAL_TIM_DISABLE(&htim10);         // stop the counter
+// }
+// #endif
+
+// #if DELAY_US_TYPE == DELAY_SYSTICK_COMPLEX
+// void delay_us(uint16_t nus)
+// { 
+//     // // 暂停系统，实现微秒延时
+// 	// // 保存sysTick的状态 
+// 	// uint32_t val_temp=SysTick->VAL;
+// 	// uint32_t load_temp=SysTick->LOAD;
+// 	// uint16_t ctrl_temp=SysTick->CTRL;
+
+// 	// /*SysTick状态重新设置，用于延时（系统暂停）*/
+// 	// SysTick->LOAD = 9 * us;		// 设置定时器重装值,72MHz 8分频后9HMz，即一微秒记9个数
+// 	// SysTick->VAL = 0x00;		// 清空当前计数值,清空后会自动装入重载值
+// 	// SysTick->CTRL = 0x00000001; // 位2设置为0，8分频，启动定时器
+// 	// while (!(SysTick->CTRL & 0x00010000));// 等待计数到0
+	
+// 	// /*延时结束后恢复之前的状态，系统继续运行*/
+// 	// SysTick->LOAD = load_temp;
+// 	// SysTick->VAL = val_temp;
+// 	// SysTick->CTRL = ctrl_temp;
+// 	// //SysTick->CTRL = 0x00000000; // 关闭定时器
+// }
+
+
+// #endif
+
+// #if DELAY_US_TYPE == DELAY_TIMER
+// void delay_us(uint16_t nus)
+// { 
+//     // // 暂停系统，实现微秒延时
+// 	// // 保存sysTick的状态 
+// 	// uint32_t val_temp=SysTick->VAL;
+// 	// uint32_t load_temp=SysTick->LOAD;
+// 	// uint16_t ctrl_temp=SysTick->CTRL;
+
+// 	// /*SysTick状态重新设置，用于延时（系统暂停）*/
+// 	// SysTick->LOAD = 9 * us;		// 设置定时器重装值,72MHz 8分频后9HMz，即一微秒记9个数
+// 	// SysTick->VAL = 0x00;		// 清空当前计数值,清空后会自动装入重载值
+// 	// SysTick->CTRL = 0x00000001; // 位2设置为0，8分频，启动定时器
+// 	// while (!(SysTick->CTRL & 0x00010000));// 等待计数到0
+	
+// 	// /*延时结束后恢复之前的状态，系统继续运行*/
+// 	// SysTick->LOAD = load_temp;
+// 	// SysTick->VAL = val_temp;
+// 	// SysTick->CTRL = ctrl_temp;
+// 	// //SysTick->CTRL = 0x00000000; // 关闭定时器
+// }
+
+
+// #endif

base/Src/interrupt_port.c

@@ -0,0 +1,176 @@
+ 
+#include "main.h"
+#include "cmsis_os.h"
+#include "usart.h"
+#include "tim.h"
+#include "bsp_uart.h"
+#include "bsp_i2c.h"
+
+#include "elog.h"
+
+#include "base.h"
+
+// #include "PH.h"
+// #include "temperature.h"
+
+#if 1
+
+// #define   huart3_helper  ph_uart_helper
+#define   huart3_helper temp_uart_helper
+#define   hi2c1_helper ads1115_i2c_helper
+
+extern osSemaphoreId_t elog_dma_lockHandle;
+
+
+void USART1_IRQHandler(void)
+{
+    if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TC) != RESET)
+    {
+        osSemaphoreRelease(elog_dma_lockHandle);
+        huart1.gState = HAL_UART_STATE_READY;
+        __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_TC);
+    }
+    HAL_UART_IRQHandler(&huart1);
+}
+
+void USART3_IRQHandler(void)
+{
+
+    if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) != RESET)
+    {
+        log_i(" usart 3 it tc ... ");
+        huart3.gState = HAL_UART_STATE_READY;
+        // max3160_485_receive_mode();
+        //  TODO 回调函数，带obj
+        UART_HELPER_Trans_TxCplt_Callback( huart3_helper  );
+
+        __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_TC);
+    }
+
+    // if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_RXNE) != RESET)
+    // {
+    //     log_i( " usart3 it rxne....");
+    //     __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_TC);
+    // }
+
+    if (__HAL_UART_GET_FLAG( &huart3, UART_FLAG_IDLE ) != RESET){
+        log_i(" usart 3 it idle ... ");
+        uint16_t count = __HAL_DMA_GET_COUNTER( huart3.hdmarx );
+        // //  判断是否有数据  count 为剩余未接收的字节数
+        if (huart3_helper->rcv_size != count) 
+        {
+            UART_HELPER_RCV_IDLE_Callback( huart3_helper , (huart3_helper->rcv_size-count));
+        }
+        __HAL_UART_CLEAR_IDLEFLAG( &huart3 );
+    }
+
+
+    HAL_UART_IRQHandler(&huart3);
+}
+
+void USART6_IRQHandler(void)
+{
+    if (__HAL_UART_GET_FLAG(&huart6, UART_FLAG_TC) != RESET)
+    {
+        huart6.gState = HAL_UART_STATE_READY;
+ 
+        log_i(" usart 6 it ... ");
+        __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_TC);
+    }
+    if (__HAL_UART_GET_FLAG(&huart6, UART_FLAG_RXNE) != RESET)
+    {
+        log_i( " huart6 it....");
+        __HAL_UART_CLEAR_FLAG(&huart6, UART_FLAG_TC);
+    }
+    HAL_UART_IRQHandler(&huart6);
+}
+
+void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
+{
+
+    if (huart->Instance == huart3.Instance)
+    {
+        log_i("....huart3 rx callback....  " );
+        UART_HELPER_RCV_Cplt_Callback( huart3_helper );
+        __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_RXNE);
+    }
+}
+
+// void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
+// {
+
+//   if (huart->Instance == huart3.Instance)
+//   {
+//     /* 拷贝数据 到菜单 */
+//     log_i("huart3   idle -> ****** HAL_UARTEx_RxEventCallback ");
+//     __HAL_UART_CLEAR_IDLEFLAG(&huart3);
+//   }
+// }
+
+// void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
+// {
+//     //   if (huart->Instance == huart3.Instance)
+//     //   {
+//     //     // max3160_485_receive_mode();
+//     //     // huart3.gState = HAL_UART_STATE_READY;
+//     //     __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_TC);
+//     //   }
+// }
+
+
+/*******************************  I2C  CallBack  *********************************/
+void I2C1_EV_IRQHandler(void)
+{
+    HAL_I2C_EV_IRQHandler(&hi2c1);
+}
+void I2C1_ER_IRQHandler(void)
+{
+  HAL_I2C_ER_IRQHandler(&hi2c1);
+}
+
+void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef *hi2c)
+{
+    log_i( " HAL_I2C_Mem  TxCpltCallback  ------------------- ");
+    if (hi2c  == &hi2c1)
+    {
+       log_i( " HAL_I2C_Mem  TxCpltCallback  --- hi2c1 ---------------- ");
+        I2C_HELPER_Trans_TxCplt_Callback(hi2c1_helper);
+    }
+}   
+
+void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef *hi2c)
+{
+    log_i( " HAL_I2C_Mem  RxCpltCallback  ------------------- ");
+    {
+       log_i( " HAL_I2C_Mem  RxCpltCallback  --- hi2c1 ---------------- ");
+        I2C_HELPER_Trans_TxCplt_Callback(hi2c1_helper);
+    }
+}
+
+void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c)
+{
+    log_i( " i2c master send cplt  ------------------- ");
+}
+ 
+void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c)
+{
+    log_i( " i2c master rx cplt  ------------------- ");
+}
+ 
+void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c)
+{
+    log_i( " HAL_I2C_ErrorCallback  ------------------- ");
+}
+#endif
+ 
+
+void TIM1_UP_TIM10_IRQHandler(void)
+{
+  /* USER CODE BEGIN TIM1_UP_TIM10_IRQn 0 */
+
+  /* USER CODE END TIM1_UP_TIM10_IRQn 0 */
+  HAL_TIM_IRQHandler(&htim10);
+  /* USER CODE BEGIN TIM1_UP_TIM10_IRQn 1 */
+
+  /* USER CODE END TIM1_UP_TIM10_IRQn 1 */
+}

bsp/Inc/bsp_i2c.h

@@ -0,0 +1,193 @@
+#ifndef __BSP_I2C_H
+#define __BSP_I2C_H
+
+#include "stm32f4xx.h"
+
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+#include <stdlib.h>
+#include "main.h"
+#include "stm32f4xx.h"
+#include "i2c.h"
+
+typedef enum 
+{
+  I2C_Trans_Polling       	= 0x00U,
+  I2C_Trans_IT   	= 0x01U,
+  I2C_Trans_DMA     = 0x02U,
+} I2C_Transmode_TypeDef;
+ 
+
+/* -----------------------    variables     ---------------------------------*/
+// extern UART_HandleTypeDef huart3;
+// UART_HandleTypeDef *pi2chelper = &huart3;
+
+
+typedef  int ( *i2c_callback_fun)  (void *obj, void *buf, uint16_t size);
+
+typedef struct 
+{
+	I2C_HandleTypeDef *hi2c;
+
+    volatile uint8_t flag_busy;
+    volatile uint8_t flag_send_or_rcv;
+
+    uint8_t dev_addr;
+    uint16_t mem_addr_size;  // I2C_MEMADD_SIZE_8BIT  I2C_MEMADD_SIZE_16BIT
+    uint16_t write_delay_ms;
+    // uint8_t mem_addr[2];
+    uint16_t mem_addr ;
+ 
+	// trans buf size, mem 方法不含地址
+    uint32_t size;
+    uint8_t *buf;
+
+
+	I2C_Transmode_TypeDef trans_mode; /* 0 :polling, 1: IT  2: DMA*/
+	I2C_Transmode_TypeDef rcv_mode;
+
+	// volatile uint8_t transferring;
+	// uint32_t timebase;
+
+	// enable_func_gpio enable_trans_gpio;
+	// enable_func_gpio enable_trans_cplt_gpio;
+
+	void * obj;
+	i2c_callback_fun callback;
+
+	//  这个是供外部调用的； 中断是统一管理的， 中断会找到这里的接收回调，然后返回回去
+ 
+}I2C_HELPER_TypeDef;
+
+// extern I2C_HELPER_TypeDef *i2chelper;
+
+I2C_HELPER_TypeDef * I2C_HELPER_Init( );
+void I2C_HELPER_Set_Hi2c(I2C_HELPER_TypeDef * i2chelper, I2C_HandleTypeDef *hi2c);
+void I2C_HELPER_Set_dev_addr(I2C_HELPER_TypeDef * i2chelper, uint8_t dev_addr);
+void I2C_HELPER_Set_mem_addr_size(I2C_HELPER_TypeDef * i2chelper, uint16_t mem_addr_size);
+void I2C_HELPER_Set_mem_addr(I2C_HELPER_TypeDef * i2chelper, uint16_t mem_addr);
+
+
+int I2C_HELPER_Setup_Trans_mode( I2C_HELPER_TypeDef * i2chelper, uint8_t trans_mode );
+int I2C_HELPER_Setup_Rcv_mode( I2C_HELPER_TypeDef * i2chelper, uint8_t rcv_mode );
+
+ 
+
+int I2C_HELPER_Set_Callback( I2C_HELPER_TypeDef * i2chelper, void *obj, i2c_callback_fun func);
+
+//Trans
+int I2C_HELPER_Trans(I2C_HELPER_TypeDef * i2chelper, uint8_t *buf, uint16_t size);
+// int __I2C_HELPER_Trans(I2C_HELPER_TypeDef * i2chelper , uint8_t *buf, uint16_t size);
+int I2C_HELPER_Trans_TxCplt_Callback( I2C_HELPER_TypeDef * i2chelper );
+
+/* 接收方式 也有三种类型 */
+int I2C_HELPER_Start_Rcv(I2C_HELPER_TypeDef * i2chelper, uint8_t *buf, uint16_t size);
+int I2C_HELPER_RCV_Cplt_Callback( I2C_HELPER_TypeDef * i2chelper );
+int I2C_HELPER_RCV_IDLE_Callback( I2C_HELPER_TypeDef * i2chelper, uint16_t size );
+
+int I2C_HELPER_read_bytes(I2C_HELPER_TypeDef * i2chelper,uint8_t dev_addr,uint8_t *buf,uint32_t size);
+int I2C_HELPER_write_bytes(I2C_HELPER_TypeDef * i2chelper,uint8_t dev_addr,uint8_t *buf,uint32_t size);
+
+int I2C_HELPER_read_memory(I2C_HELPER_TypeDef * i2chelper,uint8_t dev_addr,uint16_t mem_addr,uint8_t mem_addr_size,uint8_t *buf,uint32_t size);
+int I2C_HELPER_write_memory(I2C_HELPER_TypeDef * i2chelper,uint8_t dev_addr,uint16_t mem_addr,uint8_t mem_addr_size,uint8_t *buf,uint32_t size);
+
+// struct i2c_buff
+// {
+//     volatile uint8_t flag_busy;
+//     volatile uint8_t flag_send_or_rcve;
+//     uint8_t memory_addr_size;
+//     uint8_t dev_addr;
+//     I2C_TypeDef *i2c;
+//     DMA_Stream_TypeDef *dma_rx_stream;
+//     DMA_Stream_TypeDef *dma_tx_stream;
+//     uint32_t size;
+//     uint8_t *buf;
+//     uint8_t mem_addr[2];
+// };
+// int i2c_init(struct i2c_buff *i2c_buf,I2C_TypeDef *i2c,DMA_Stream_TypeDef *dma_rx_stream,DMA_Stream_TypeDef *dma_tx_stream);
+// int i2c_read_memory(struct i2c_buff *i2c_buf,uint8_t dev_addr,uint16_t mem_addr,uint8_t mem_addr_size,uint8_t *buf,uint32_t size);
+// int i2c_write_memory(struct i2c_buff *i2c_buf,uint8_t dev_addr,uint16_t mem_addr,uint8_t mem_addr_size,uint8_t *buf,uint32_t size);
+// void i2c_dma_tx_it_tc_callback(struct i2c_buff *i2c_buf);
+// void i2c_dma_rx_it_tc_callback(struct i2c_buff *i2c_buf);
+// int i2c_clear_state(struct i2c_buff *i2c_buf);
+// int i2c_get_state(struct i2c_buff *i2c_buf);
+// void i2c_it_af_callback(struct i2c_buff *i2c_buf);
+// void i2c_it_btf_callback(struct i2c_buff *i2c_buf);
+// void i2c_it_addr_callback(struct i2c_buff *i2c_buf);
+// void i2c_it_sb_callback(struct i2c_buff *i2c_buf);
+// int i2c_read_bytes(struct i2c_buff *i2c_buf,uint8_t dev_addr,uint8_t *buf,uint32_t size);
+// int i2c_write_bytes(struct i2c_buff *i2c_buf,uint8_t dev_addr,uint8_t *buf,uint32_t size);
+// void i2c_stop(struct i2c_buff *i2c_buf);
+
+
+// // int I2C_HELPER_Set_Interface_Type(I2C_HELPER_TypeDef * i2chelper, uint8_t interface_type);
+
+// int I2C_HELPER_Setup_Trans_mode( I2C_HELPER_TypeDef * i2chelper, uint8_t trans_mode );
+// int I2C_HELPER_Setup_Rcv_mode( I2C_HELPER_TypeDef * i2chelper, uint8_t rcv_mode );
+
+// int I2C_HELPER_Set_trans_GPIO( I2C_HELPER_TypeDef * i2chelper, enable_func_gpio trans_gpio_func );
+// int I2C_HELPER_Set_trans_cplt_GPIO( I2C_HELPER_TypeDef * i2chelper, enable_func_gpio trans_cplt_gpio_func );
+ 
+// int I2C_HELPER_Set_enable_idle( I2C_HELPER_TypeDef * i2chelper, uint8_t enable_idle);
+
+// int I2C_HELPER_Set_Rcv_Buf( I2C_HELPER_TypeDef * i2chelper, uint8_t * buf, uint16_t size);
+// int I2C_HELPER_Set_Trans_Buf( I2C_HELPER_TypeDef * i2chelper, uint8_t * buf, uint16_t size);
+
+
+
+#endif
+
+/*
+
+HAL 原型函数
+    // st = HAL_I2C_Mem_Write(ads1115_i2c_helper->hi2c, ADS1115_WRITE_ADDRESS, 
+    //             my_ads1115.reg_data[0],ads1115_i2c_helper->mem_addr_size ,  reg_data,2,0xFFFF);
+    // st = HAL_I2C_Mem_Read(ads1115_i2c_helper->hi2c, ADS1115_WRITE_ADDRESS, 
+    //         0x00,ads1115_i2c_helper->mem_addr_size ,  rx_data,2,0xFFFF);
+
+
+485 
+enable rcv
+HAL_GPIO_WritePin(i2chelper->de485_gpio, i2chelper->de485_pin, 0); 
+enable send 
+HAL_GPIO_WritePin(i2chelper->de485_gpio, i2chelper->de485_pin, 1); 
+
+3160 485   --高    (232 - 低)
+enable rcv
+        HAL_GPIO_WritePin(i2chelper->dplx_gpio, i2chelper->dplx_gpio ,  1);
+        HAL_GPIO_WritePin(i2chelper->de485_gpio, i2chelper->de485_pin, 0); 
+enable send 
+        HAL_GPIO_WritePin(i2chelper->dplx_gpio, i2chelper->dplx_gpio ,  0);
+        HAL_GPIO_WritePin(i2chelper->de485_gpio, i2chelper->de485_pin, 1); 
+
+
+i2chelper = I2C_HELPER_Init();
+
+I2C_HELPER_Set_Huart(  i2chelper, phuart),
+I2C_HELPER_Setup_Transmod(  i2chelper, 2 );
+ I2C_HELPER_Set_enable_snd_func(   i2chelper, NULL );
+ I2C_HELPER_Set_enable_rcv_func(   i2chelper, NULL);
+ I2C_HELPER_Set_enable_idle(   i2chelper,  enable_idle);
+ I2C_HELPER_Set_enable_rcv_func(   i2chelper,  obj, (callback_fun) func);
+
+
+// #if MAX3160_ENABLE
+// #define     DUPLEX_HALF  	1
+// #define     DUPLEX_FULL  	0
+// #define    SEL_485 			1
+// #define    SEL_232 			0
+
+// #define    ENABLE_485_Trans      1
+// #define    DISABLE_485_Trans     0
+// # endif
+
+// #if MAX485_ENABLE
+// #define    ENABLE_485_Trans      1
+// #define    DISABLE_485_Trans     0
+// # endif
+
+
+*/

bsp/Inc/bsp_spi.h

@@ -0,0 +1,95 @@
+#ifndef __BSP_SPI_H
+#define __BSP_SPI_H
+
+#include "stm32f4xx_hal.h"
+#include "main.h"
+// #include "sys.h"
+
+typedef enum 
+{
+  SPI_Trans_Polling       	= 0x00U,
+  SPI_Trans_IT   	= 0x01U,
+  SPI_Trans_DMA     = 0x02U,
+} SPI_Transmode_TypeDef;
+ 
+typedef enum 
+{
+  SPI_WORKMODE_RX_TX       	= 0x00U,
+  SPI_WORKMODE_TX   	= 0x01U,
+  SPI_WORKMODE_RX   	= 0x02U,
+} SPI_WORKMODE_RX_TX_TypeDef;
+ 
+
+typedef  void ( *enable_func_gpio)  (void);
+typedef  int ( *callback_fun)  (void *obj, void *buf, uint16_t size);
+
+typedef struct 
+{
+	SPI_HandleTypeDef *hspi;
+ 
+	volatile SPI_WORKMODE_RX_TX_TypeDef rx_tx;
+
+	SPI_Transmode_TypeDef trans_mode; /* 0 :polling, 1: IT  2: DMA*/
+	SPI_Transmode_TypeDef rcv_mode;   /* 0 :polling, 1: IT  2: DMA*/
+
+	// Record_Trans_Rcv_TypeDef *trans_record;
+	// Record_Trans_Rcv_TypeDef *rcv_record;
+
+	uint8_t *trans_buf;
+	uint16_t trans_size;
+	uint8_t *rcv_buf;
+	uint16_t rcv_size;
+
+	volatile uint8_t transferring;
+	uint32_t timebase;
+
+	// enable_func_gpio enable_trans_gpio;
+	// enable_func_gpio enable_trans_cplt_gpio;
+
+	void * obj;
+	callback_fun callback;
+
+ 
+}SPI_HELPER_TypeDef;
+
+extern SPI_HELPER_TypeDef *spihelper;
+
+SPI_HELPER_TypeDef * SPI_HELPER_Init( );
+void SPI_HELPER_Set_Huart(SPI_HELPER_TypeDef * spihelper, SPI_HELPER_TypeDef *hspi);
+ 
+
+int SPI_HELPER_Setup_Trans_mode( SPI_HELPER_TypeDef * spihelper, uint8_t trans_mode );
+int SPI_HELPER_Setup_Rcv_mode( SPI_HELPER_TypeDef * spihelper, uint8_t rcv_mode );
+
+int SPI_HELPER_Set_Rcv_Buf( SPI_HELPER_TypeDef * spihelper, uint8_t * buf, uint16_t size);
+int SPI_HELPER_Set_Trans_Buf( SPI_HELPER_TypeDef * spihelper, uint8_t * buf, uint16_t size);
+
+int SPI_HELPER_Setup_WokMode_RX_TX( SPI_HELPER_TypeDef * spihelper, uint8_t rx_tx );
+
+int SPI_HELPER_Set_Callback( SPI_HELPER_TypeDef * spihelper, void *obj, callback_fun func);
+
+int SPI_HELPER_Trans(SPI_HELPER_TypeDef * spihelper, uint8_t *buf, uint16_t size);
+int SPI_HELPER_Trans_TxCplt_Callback( SPI_HELPER_TypeDef * spihelper );
+
+int SPI_HELPER_Start_Rcv(SPI_HELPER_TypeDef * spihelper, uint8_t *buf, uint16_t size);
+int SPI_HELPER_RCV_Cplt_Callback( SPI_HELPER_TypeDef * spihelper );
+
+int SPI_HELPER_Start_Trans_Rcv(SPI_HELPER_TypeDef * spihelper, uint8_t *txbuf ,uint8_t *rxbuf, uint16_t size);
+int SPI_HELPER_Trans_RCV_Cplt_Callback( SPI_HELPER_TypeDef * spihelper );
+
+void SPI_HELPER_Test(void) ;
+void SPI_HELPER_TransmitReceive(uint8_t* txData, uint8_t* rxData, uint16_t size) ;
+
+#endif
+
+/*
+void HAL_SPI_IRQHandler(SPI_HandleTypeDef *hspi);
+void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi);
+void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi);
+void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi);
+void HAL_SPI_TxHalfCpltCallback(SPI_HandleTypeDef *hspi);
+void HAL_SPI_RxHalfCpltCallback(SPI_HandleTypeDef *hspi);
+void HAL_SPI_TxRxHalfCpltCallback(SPI_HandleTypeDef *hspi);
+void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi);
+void HAL_SPI_AbortCpltCallback(SPI_HandleTypeDef *hspi);
+*/

bsp/Inc/bsp_spi_soft.h

@@ -0,0 +1,144 @@
+#ifndef __BSP_SPI_SOFT_H
+#define __BSP_SPI_SOFT_H
+#include "stm32f4xx_hal.h"
+#include "main.h"
+// #include "sys.h"
+
+#define CS_GPIO_PORT GPIOF
+#define CS_PIN	 GPIO_PIN_6
+#define SCK_GPIO_PORT GPIOF
+#define SCK_PIN	 GPIO_PIN_7
+#define MISO_GPIO_PORT GPIOF
+#define MISO_PIN	 GPIO_PIN_8
+#define MOSI_GPIO_PORT GPIOF
+#define MOSI_PIN	 GPIO_PIN_9
+
+
+// FPF6    ------> SPI5_CS
+// PF7     ------> SPI5_SCK
+// PF8     ------> SPI5_MISO
+// PF9     ------> SPI5_MOSI
+
+
+typedef enum  {
+  SPI_OK           = 0x00,    //IIC工作正常
+  SPI_WAIT_ACK_ERR = 0x01,    //slave设备返回ACK错误
+  SPI_WRITE_ERR    = 0x02,    //向slave设备写入错误
+  SPI_READ_ERR     = 0x04     //从slave设备读取错误
+} SPI_STATUS;
+
+typedef struct
+{
+    GPIO_TypeDef	*cs_port;   	
+    uint16_t			cs_pin;	
+    GPIO_TypeDef	*sclk_port;		 
+    uint16_t			sclk_pin;			
+    GPIO_TypeDef	*miso_port;   	
+    uint16_t			miso_pin;	
+    GPIO_TypeDef	*mosi_port;   	
+    uint16_t			mosi_pin;			 
+
+
+    uint8_t			  sda_pin_num;   	//定义延时，以适应不同器件对速率的不同要求,具体值要在调试中确定
+    uint8_t				addr;        	//器件地址
+    uint32_t			delaytick;   	//定义延时，以适应不同器件对速率的不同要求,具体值要在调试中确定
+    uint8_t  CPOL;    //时钟极性，为0：空闲状态时，SCK保持低电平；  1： 表示在空闲状态时，SCK保持高电平。
+    uint8_t  CPHA;    // 时钟相位， 0：从第一个时钟边沿开始； 1：第二个时钟边沿开始。
+  uint16_t period ;   //确定速度为大于0K小于等于400K的整数，默认为100K,>period=500/speed speed时钟频率
+}SPI_SOFT_TypeDef;
+
+ 
+
+#define CS_H HAL_GPIO_WritePin(GPIOC, GPIO_PIN_5, GPIO_PIN_SET)
+#define CS_L HAL_GPIO_WritePin(GPIOC, GPIO_PIN_5, GPIO_PIN_RESET)
+#define SCLK_H HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_SET)
+#define SCLK_L HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_RESET)
+#define SDI_H HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_SET)
+#define SDI_L HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_RESET)
+#define SDO_R HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_1)
+
+#define SUCCESS 0
+#define FAILURE 1
+
+void SPI_Init(const SPI_SOFT_TypeDef *pSoftSPI);  
+uint8_t WriteReg(const SPI_SOFT_TypeDef *pSoftSPI, uint32_t d);
+uint8_t ReadReg(const SPI_SOFT_TypeDef *pSoftSPI, uint32_t d);  
+void SPI_Write_OneByte(const SPI_SOFT_TypeDef *pSoftSPI, uint8_t u8_writedata);
+uint8_t SPI_Read_OneByte(const SPI_SOFT_TypeDef *pSoftSPI);
+uint8_t SPI_ReadWriteByte(const SPI_SOFT_TypeDef *pSoftSPI, uint8_t TxData);
+
+uint32_t SPI_FLASH_ReadDeviceID( const SPI_SOFT_TypeDef *pSoftSPI);
+#endif
+
+
+/*
+时序
+CPOL  CPHA
+ 0      0    00    第一个  上升沿
+ 0      1    01   第一个  下降沿
+ 1      0    10   第二个  下降沿
+ 1      1    11   第二个  上升沿
+
+00 常用， 前置SCL拉低， 过程  SDA 输出， SCLK 拉高 延时  拉低
+
+00 ：
+//                 T____
+//           ______/    \______
+
+01
+//                  ____T
+//           ______/    \______
+
+
+10 ：
+//      *    ____T        _____
+//               \_______/
+
+11
+//      *    ____        T_____
+//               \_______/
+
+
+00
+空闲状态：片选信号SS为高，SCK输出低电平。
+开始信号：片选信号SS变低，SCK输出低电平。
+结束信号：片选信号SS变高，SCK输出低电平。
+读取：SCK由低变高之后，读取MISO引脚信号。
+写入：SCK输出低电平，MOSI引脚输出相应的电平，然后SCK输出高电平。
+
+MISO：Master input slave output 主机输入，从机输出（数据来自从机）；
+
+MOSI：Master output slave input 主机输出，从机输入（数据来自主机）；
+
+MISO也可以是SIMO，DOUT，DO，SDO或SO（在主机端）;
+
+MOSI也可以是SOMI，DIN，DI，SDI或SI（在主机端）;
+
+
+SPI_SOFT_TypeDef sSPI ={
+    GPIOF, GPIO_PIN_6,GPIOF, GPIO_PIN_7,GPIOF, GPIO_PIN_8,GPIOF, GPIO_PIN_9,
+    6,0,1,
+} ;       
+SPI_Init(&sSPI);
+
+  uint8_t txData[4] = {0x9F, 0x00, 0x00, 0x00}; 
+  uint32_t hhhh =2667577344;
+  uint8_t rxData[4] = {0};   //  
+  uint8_t  rrr;
+
+//   rrr = SPI_ReadWriteByte(&sSPI, txData[0]);
+//     log_i("rrrr: 0x%02X\n", rrr);     // 19
+//     delay_us(1);
+//   rrr = SPI_ReadWriteByte(&sSPI, 0xFF);
+//     log_i("rrrr: 0x%02X\n", rrr);     // 19
+//     delay_us(1);
+//   rrr = SPI_ReadWriteByte(&sSPI, 0xFF);
+//     log_i("rrrr: 0x%02X\n", rrr);     // 19
+//     delay_us(1);
+//   rrr = SPI_ReadWriteByte(&sSPI, 0xFF);
+//     log_i("rrrr: 0x%02X\n", rrr);     // 19
+//     delay_us(1);
+hhhh = SPI_FLASH_ReadDeviceID(&sSPI);
+
+*/
+

bsp/Inc/bsp_uart.h

@@ -19,33 +19,71 @@
 #include <stdlib.h>
 #include "main.h"
 
-// #if MAX3160_ENABLE
-// #define     DUPLEX_HALF  	1
-// #define     DUPLEX_FULL  	0
-// #define    SEL_485 			1
-// #define    SEL_232 			0
+typedef enum 
+{
+  Uart_Interface_Default       	= 0x00U,
+  Uart_Interface_485   			= 0x01U,
+  Uart_Interface_Max3160_232     = 0x02U,
+  Uart_Interface_Max3160_485     = 0x03U,
+} Uart_Interface_Type_Typedef; 
 
-// #define    ENABLE_485_Trans      1
-// #define    DISABLE_485_Trans     0
-// # endif
 
-// #if MAX485_ENABLE
-// #define    ENABLE_485_Trans      1
-// #define    DISABLE_485_Trans     0
-// # endif
+typedef enum 
+{
+  Uart_Trans_Polling       	= 0x00U,
+  Uart_Trans_IT   	= 0x01U,
+  Uart_Trans_DMA     = 0x02U,
+} Uart_Transmode_TypeDef;
+ 
+typedef enum 
+{
+  Uart_IDLE_IT_DISABLE       	= 0x00U,
+  Uart_IDLE_IT_ENABLE   	= 0x01U,
+} Uart_IDLE_Enable_TypeDef;
+ 
+typedef struct
+{
+    uint32_t size;
+    uint8_t *buf;
+}Record_Trans_Rcv_TypeDef;
 
 /* -----------------------    variables     ---------------------------------*/
-extern UART_HandleTypeDef huart3;
-UART_HandleTypeDef *pMyUart = &huart3;
+// extern UART_HandleTypeDef huart3;
+// UART_HandleTypeDef *puarthelper = &huart3;
 
-typedef  void ( *enable_func)  (void);
+typedef  void ( *enable_func_gpio)  (void);
 typedef  int ( *callback_fun)  (void *obj, void *buf, uint16_t size);
 
 typedef struct 
 {
 	UART_HandleTypeDef *huart;
-	uint8_t  interface_type; /* 0: common, 1: 485 ,2:3160*/
-	uint8_t enable_idle_it;
+	Uart_Interface_Type_Typedef  interface_type; /* 0: default(TTL 232), 1: 485 ,2:3160-232  3: 3160-485*/
+	Uart_IDLE_Enable_TypeDef enable_idle_it;
+
+	Uart_Transmode_TypeDef trans_mode; /* 0 :polling, 1: IT  2: DMA*/
+	Uart_Transmode_TypeDef rcv_mode;
+
+	Record_Trans_Rcv_TypeDef *trans_record;
+	// Record_Trans_Rcv_TypeDef *rcv_record;
+
+	// uint8_t *trans_buf;
+	// uint16_t trans_size;
+	uint8_t *rcv_buf;
+	uint16_t rcv_size;
+
+	volatile uint8_t send_flag;
+	volatile uint8_t send_tc_flag;  /* 0 开始发送， 1 发送完成*/
+	volatile uint8_t transferring;
+	// uint32_t timebase;
+
+	enable_func_gpio enable_trans_gpio;
+	enable_func_gpio enable_trans_cplt_gpio;
+
+	void * obj;
+	callback_fun callback;
+
+	//  这个是供外部调用的； 中断是统一管理的， 中断会找到这里的接收回调，然后返回回去
+
 
 // #if MAX485_ENABLE
 // 	GPIO_TypeDef *de485_gpio;
@@ -67,77 +105,87 @@ typedef struct
     // uint8_t dplx;
     // uint8_t sel;
     // uint8_t de485;
+}UART_HELPER_TypeDef;
 
-	uint8_t trans_mode; /* 0 :polling, 1: IT  2: DMA*/
-	// uint8_t *send_buf;
-	// uint16_t size_send;
-	// uint8_t *rcv_buf;
-	// uint16_t size_rcv;
+extern UART_HELPER_TypeDef *uarthelper;
 
-	volatile uint8_t send_flag;
-	volatile uint8_t send_tc_flag;  /* 0 开始发送， 1 发送完成*/
-	// uint32_t timebase;
+UART_HELPER_TypeDef * UART_HELPER_Init( );
+void UART_HELPER_Set_Huart(UART_HELPER_TypeDef * uarthelper, UART_HandleTypeDef *huart);
+int UART_HELPER_Set_Interface_Type(UART_HELPER_TypeDef * uarthelper, uint8_t interface_type);
 
-	void (*enable_snd)(void);
-	void (*enable_rcv)(void);
+int UART_HELPER_Setup_Trans_mode( UART_HELPER_TypeDef * uarthelper, uint8_t trans_mode );
+int UART_HELPER_Setup_Rcv_mode( UART_HELPER_TypeDef * uarthelper, uint8_t rcv_mode );
 
-	void * obj;
-	callback_fun callback;
+int UART_HELPER_Set_trans_GPIO( UART_HELPER_TypeDef * uarthelper, enable_func_gpio trans_gpio_func );
+int UART_HELPER_Set_trans_cplt_GPIO( UART_HELPER_TypeDef * uarthelper, enable_func_gpio trans_cplt_gpio_func );
+ 
+int UART_HELPER_Set_enable_idle( UART_HELPER_TypeDef * uarthelper, uint8_t enable_idle);
 
-	//  这个是供外部调用的； 中断是统一管理的， 中断会找到这里的接收回调，然后返回回去
+int UART_HELPER_Set_Rcv_Buf( UART_HELPER_TypeDef * uarthelper, uint8_t * buf, uint16_t size);
+int UART_HELPER_Set_Trans_Buf( UART_HELPER_TypeDef * uarthelper, uint8_t * buf, uint16_t size);
 
-}MYUART_TypeDef;
+int UART_HELPER_Set_Callback( UART_HELPER_TypeDef * uarthelper, void *obj, callback_fun func);
 
-extern MYUART_TypeDef *myuart;
 
-MYUART_TypeDef * Myuart_Init( );
-void Myuart_Set_Huart(MYUART_TypeDef * myuart, UART_HandleTypeDef *huart);
-int Myuart_Setup_Transmod( MYUART_TypeDef * myuart, uint8_t trans_mode );
-int Myuart_Set_enable_snd_func( MYUART_TypeDef * myuart, enable_func enable_snd_func );
-int Myuart_Set_enable_rcv_func( MYUART_TypeDef * myuart, enable_func enable_rcv_func);
-int Myuart_Set_enable_idle( MYUART_TypeDef * myuart, uint8_t enable_idle);
+int UART_HELPER_Trans(UART_HELPER_TypeDef * uarthelper, uint8_t *buf, uint16_t size);
+// int __UART_HELPER_Trans(UART_HELPER_TypeDef * uarthelper , uint8_t *buf, uint16_t size);
+int UART_HELPER_Trans_TxCplt_Callback( UART_HELPER_TypeDef * uarthelper );
+/* 接收方式 也有三种类型 */
+int UART_HELPER_Start_Rcv(UART_HELPER_TypeDef * uarthelper, uint8_t *buf, uint16_t size);
 
-int Myuart_Set_Callback( MYUART_TypeDef * myuart, void *obj, callback_fun func);
+int UART_HELPER_RCV_Cplt_Callback( UART_HELPER_TypeDef * uarthelper );
+int UART_HELPER_RCV_IDLE_Callback( UART_HELPER_TypeDef * uarthelper, uint16_t size );
 
-// void Myuart_Set_Sel_GPIO_Pin(MYUART_TypeDef * myuart, GPIO_TypeDef *gpio, uint16_t pin);
-// void Myuart_Set_Dplx_GPIO_Pin(MYUART_TypeDef * myuart, GPIO_TypeDef *gpio, uint16_t pin);
-// void Myuart_Set_DE485_GPIO_Pin(MYUART_TypeDef * myuart, GPIO_TypeDef *gpio, uint16_t pin);
+#endif
 
-// void Myuart_Set_232(MYUART_TypeDef * myuart);
-// void Myuart_Set_485(MYUART_TypeDef * myuart);
+/*
 
+发送回调函数，通过函数指针注册引入，操作GPIO
+接收回调函数通过 通过函数指针注册引入 ，操作GPIO
 
-int Myuart_Trans(MYUART_TypeDef * myuart, uint8_t *buf, uint16_t size);
-// int __Myuart_Trans(MYUART_TypeDef * myuart , uint8_t *buf, uint16_t size);
-int Myuart_Trans_TxCplt_Callback( MYUART_TypeDef * myuart );
-/* 接收方式 也有三种类型 */
-int Myuart_Start_Rcv(MYUART_TypeDef * myuart, uint8_t *buf, uint16_t size);
+IDLE RXCplt 都可以产生中断，
 
-#endif
 
-/*
 
 485 
 enable rcv
-HAL_GPIO_WritePin(myuart->de485_gpio, myuart->de485_pin, 0); 
+HAL_GPIO_WritePin(uarthelper->de485_gpio, uarthelper->de485_pin, 0); 
 enable send 
-HAL_GPIO_WritePin(myuart->de485_gpio, myuart->de485_pin, 1); 
+HAL_GPIO_WritePin(uarthelper->de485_gpio, uarthelper->de485_pin, 1); 
 
 3160 485   --高    (232 - 低)
 enable rcv
-        HAL_GPIO_WritePin(myuart->dplx_gpio, myuart->dplx_gpio ,  1);
-        HAL_GPIO_WritePin(myuart->de485_gpio, myuart->de485_pin, 0); 
+        HAL_GPIO_WritePin(uarthelper->dplx_gpio, uarthelper->dplx_gpio ,  1);
+        HAL_GPIO_WritePin(uarthelper->de485_gpio, uarthelper->de485_pin, 0); 
 enable send 
-        HAL_GPIO_WritePin(myuart->dplx_gpio, myuart->dplx_gpio ,  0);
-        HAL_GPIO_WritePin(myuart->de485_gpio, myuart->de485_pin, 1); 
+        HAL_GPIO_WritePin(uarthelper->dplx_gpio, uarthelper->dplx_gpio ,  0);
+        HAL_GPIO_WritePin(uarthelper->de485_gpio, uarthelper->de485_pin, 1); 
+
+
+uarthelper = UART_HELPER_Init();
+
+UART_HELPER_Set_Huart(  uarthelper, phuart),
+UART_HELPER_Setup_Transmod(  uarthelper, 2 );
+ UART_HELPER_Set_enable_snd_func(   uarthelper, NULL );
+ UART_HELPER_Set_enable_rcv_func(   uarthelper, NULL);
+ UART_HELPER_Set_enable_idle(   uarthelper,  enable_idle);
+ UART_HELPER_Set_enable_rcv_func(   uarthelper,  obj, (callback_fun) func);
 
 
-myuart = Myuart_Init();
+// #if MAX3160_ENABLE
+// #define     DUPLEX_HALF  	1
+// #define     DUPLEX_FULL  	0
+// #define    SEL_485 			1
+// #define    SEL_232 			0
+
+// #define    ENABLE_485_Trans      1
+// #define    DISABLE_485_Trans     0
+// # endif
+
+// #if MAX485_ENABLE
+// #define    ENABLE_485_Trans      1
+// #define    DISABLE_485_Trans     0
+// # endif
+
 
-Myuart_Set_Huart(  myuart, phuart),
-Myuart_Setup_Transmod(  myuart, 2 );
- Myuart_Set_enable_snd_func(   myuart, NULL );
- Myuart_Set_enable_rcv_func(   myuart, NULL);
- Myuart_Set_enable_idle(   myuart,  enable_idle);
- Myuart_Set_enable_rcv_func(   myuart,  obj, (callback_fun) func);
 */

bsp/Src/bsp_i2c.c

@@ -0,0 +1,178 @@
+#include "bsp_i2c.h"
+
+
+I2C_HELPER_TypeDef * I2C_HELPER_Init( )
+{
+        I2C_HELPER_TypeDef *Handle = (I2C_HELPER_TypeDef *)malloc(sizeof(I2C_HELPER_TypeDef));
+    if (Handle == NULL)
+    {
+        return NULL;
+    }
+	Handle->hi2c = NULL;
+	Handle->flag_busy = 0;
+	Handle->flag_send_or_rcv = 0;
+
+	Handle->mem_addr_size = I2C_MEMADD_SIZE_8BIT;
+	Handle->dev_addr = 0;
+
+	Handle->size = 0;
+	Handle->write_delay_ms = 0;
+	Handle->buf = NULL;
+
+	Handle->trans_mode = I2C_Trans_Polling;
+	Handle->rcv_mode = I2C_Trans_Polling;
+ 
+	Handle->obj =NULL;
+	Handle->callback =NULL;
+    return Handle;
+}
+
+void I2C_HELPER_Set_Hi2c(I2C_HELPER_TypeDef * i2chelper, I2C_HandleTypeDef *hi2c)
+{
+    i2chelper->hi2c = hi2c;
+}
+
+void I2C_HELPER_Set_dev_addr(I2C_HELPER_TypeDef * i2chelper, uint8_t dev_addr)
+{
+    i2chelper->dev_addr = dev_addr;
+
+}
+void I2C_HELPER_Set_mem_addr_size(I2C_HELPER_TypeDef * i2chelper, uint16_t mem_addr_size)
+{
+    i2chelper->mem_addr_size = mem_addr_size;
+
+}
+void I2C_HELPER_Set_mem_addr(I2C_HELPER_TypeDef * i2chelper, uint16_t mem_addr)
+{
+    // i2chelper->mem_addr[0] = mem_addr>>8;
+    // i2chelper->mem_addr[1] = mem_addr&0xFF;
+    
+    i2chelper->mem_addr =mem_addr;
+    if (i2chelper->mem_addr_size == I2C_MEMADD_SIZE_16BIT)
+    {
+        i2chelper->mem_addr =mem_addr;
+    }
+}
+
+int I2C_HELPER_Setup_Trans_mode( I2C_HELPER_TypeDef * i2chelper, uint8_t trans_mode )
+{
+    i2chelper->trans_mode = trans_mode;
+    i2chelper->rcv_mode = trans_mode;
+}
+int I2C_HELPER_Setup_Rcv_mode( I2C_HELPER_TypeDef * i2chelper, uint8_t rcv_mode )
+{
+    i2chelper->rcv_mode = rcv_mode;
+}
+
+int I2C_HELPER_Set_Callback( I2C_HELPER_TypeDef * i2chelper,  void *obj, i2c_callback_fun func)
+{
+	i2chelper->obj = obj;
+	i2chelper->callback = func;
+	return 0;
+}
+
+//   TODO  添加地址 
+int I2C_HELPER_Trans(I2C_HELPER_TypeDef * i2chelper, uint8_t *buf, uint16_t size)
+{
+	int st;
+    i2chelper->flag_busy = 1;
+ 
+
+    switch ( i2chelper->trans_mode)
+    {
+        case 0:
+            // st = HAL_UART_Transmit(i2chelper->huart,  buf,  size  , 0xFFFF);
+            st = HAL_I2C_Mem_Write(i2chelper->hi2c, i2chelper->dev_addr, 
+                i2chelper->mem_addr,i2chelper->mem_addr_size ,
+                 buf,size,0xFFFF);
+            return st;
+            break;
+        case 1:
+            st = HAL_I2C_Mem_Write_IT(i2chelper->hi2c, i2chelper->dev_addr, 
+                i2chelper->mem_addr,i2chelper->mem_addr_size ,
+                 buf,size );
+            return st;
+            break;
+        case 2:
+            /* 会出现 st ==2  huart->gState != HAL_UART_STATE_READY */
+             st = HAL_I2C_Mem_Write_DMA(i2chelper->hi2c, i2chelper->dev_addr, 
+                i2chelper->mem_addr,i2chelper->mem_addr_size ,
+                 buf,size );
+            return st;
+            break;    
+        default:
+            break;
+    }
+    return st;
+
+}
+
+int I2C_HELPER_Start_Rcv(I2C_HELPER_TypeDef * i2chelper, uint8_t *buf, uint16_t size)
+{
+	int st;
+    switch ( i2chelper->rcv_mode)
+    {
+        case 0:
+            // st = HAL_UART_Receive(uarthelper->huart,  buf,  size  , 0xFFFF);
+            st =HAL_I2C_Mem_Read(i2chelper->hi2c, i2chelper->dev_addr, 
+                i2chelper->mem_addr,i2chelper->mem_addr_size ,
+                 buf,size,0xFFFF);
+
+            return st;
+            break;
+        case 1:
+            st =HAL_I2C_Mem_Read_IT(i2chelper->hi2c, i2chelper->dev_addr, 
+                i2chelper->mem_addr,i2chelper->mem_addr_size ,
+                 buf,size );
+            return st;
+            break;
+        case 2:
+            /* 会出现 st ==2  huart->gState != HAL_UART_STATE_READY */
+			// if (uarthelper->enable_idle_it == 1) 
+			// {
+            // // log_i("dma rcv idle en... ");
+			// 	__HAL_UART_ENABLE_IT(uarthelper->huart, UART_IT_IDLE);
+			// }
+            // st = HAL_UART_Receive_DMA(uarthelper->huart,  buf,  size);
+            // log_i("dma rcv ... ");
+            st =HAL_I2C_Mem_Read_DMA(i2chelper->hi2c, i2chelper->dev_addr, 
+                i2chelper->mem_addr,i2chelper->mem_addr_size ,
+                 buf,size );
+            return st;
+            break;    
+        default:
+            break;
+    }
+    return st;
+}
+
+
+int I2C_HELPER_Trans_TxCplt_Callback( I2C_HELPER_TypeDef * i2chelper )
+{
+    // log_i( "I2C_HELPER_Trans_TxCplt_Callback  ... ");
+    i2chelper->callback( i2chelper->obj, NULL, 0);
+}
+
+
+
+// int I2C_HELPER_read_bytes(I2C_HELPER_TypeDef * i2chelper,uint8_t dev_addr,uint8_t *buf,uint32_t size)
+// {
+// 	return 0;
+
+// }
+// int I2C_HELPER_write_bytes(I2C_HELPER_TypeDef * i2chelper,uint8_t dev_addr,uint8_t *buf,uint32_t size)
+// {
+// 	return 0;
+
+// }
+
+// int I2C_HELPER_read_memory(I2C_HELPER_TypeDef * i2chelper,uint8_t dev_addr,uint16_t mem_addr,uint8_t mem_addr_size,uint8_t *buf,uint32_t size)
+// {
+// 	return 0;
+
+// }
+// int I2C_HELPER_write_memory(I2C_HELPER_TypeDef * i2chelper,uint8_t dev_addr,uint16_t mem_addr,uint8_t mem_addr_size,uint8_t *buf,uint32_t size)
+// {
+// 	return 0;
+
+// }

bsp/Src/bsp_spi.c

@@ -0,0 +1,151 @@
+#include "bsp_spi.h"
+#include "elog.h"
+// #include "delay.h"
+ 
+extern SPI_HandleTypeDef hspi5;
+SPI_HandleTypeDef *testSPIHandle = &hspi5;
+
+
+SPI_HELPER_TypeDef * SPI_HELPER_Init( )
+{
+    SPI_HELPER_TypeDef *Handle = (SPI_HELPER_TypeDef *)malloc(sizeof(SPI_HELPER_TypeDef));
+    if (Handle == NULL)
+    {
+        return NULL;
+    }
+ 
+	Handle->hspi = NULL;
+	Handle->rx_tx = SPI_WORKMODE_RX_TX;
+	Handle->trans_mode = SPI_Trans_Polling;
+	Handle->rcv_mode = SPI_Trans_Polling;
+ 
+	Handle->transferring = 0;
+ 
+
+	Handle->obj =NULL;
+	Handle->callback =NULL;
+    return Handle;
+}
+
+
+int SPI_HELPER_Setup_Trans_mode( SPI_HELPER_TypeDef * spihelper, uint8_t trans_mode )
+{
+  spihelper->trans_mode =trans_mode;
+  spihelper->rcv_mode =trans_mode;
+  return 0;
+}
+int SPI_HELPER_Setup_Rcv_mode( SPI_HELPER_TypeDef * spihelper, uint8_t rcv_mode )
+{
+  spihelper->rcv_mode =rcv_mode;
+  return 0;
+}
+
+int SPI_HELPER_Setup_WokMode_RX_TX( SPI_HELPER_TypeDef * spihelper, uint8_t rx_tx )
+{
+  spihelper->rx_tx =rx_tx;
+  return 0;
+}
+
+int SPI_HELPER_Set_Rcv_Buf( SPI_HELPER_TypeDef * spihelper, uint8_t * buf, uint16_t size)
+{
+	spihelper->rcv_buf = buf;
+	spihelper->rcv_size = size;
+  return 0;
+}
+int SPI_HELPER_Set_Trans_Buf( SPI_HELPER_TypeDef * spihelper, uint8_t * buf, uint16_t size)
+{
+  	spihelper->trans_buf = buf;
+	spihelper->trans_size = size;
+	return 0;
+}
+
+int SPI_HELPER_Set_Callback( SPI_HELPER_TypeDef * spihelper, void *obj, callback_fun func)
+{
+  	spihelper->obj = obj;
+	spihelper->callback = func;
+	return 0;
+}
+
+void SPI_Test(void) 
+{ 
+  uint8_t txData[4] = {0x9F, 0x00, 0x00, 0x00}; 
+  uint8_t rxData[4] = {0};   //   
+  SPI_TransmitReceive(txData, rxData, 4); 
+  log_i("Manufacturer ID: 0x%02X\n", rxData[1]);  // EF
+  log_i("Memory Type: 0x%02X\n", rxData[2]);   // 40 
+  log_i("Capacity: 0x%02X\n", rxData[3]);     // 19
+}  
+
+
+void SPI_TransmitReceive(uint8_t* txData, uint8_t* rxData, uint16_t size) 
+{ 
+  HAL_GPIO_WritePin(SPI5_CS_GPIO_Port, SPI5_CS_Pin, GPIO_PIN_RESET); 
+  HAL_SPI_TransmitReceive(testSPIHandle, txData, rxData, size, HAL_MAX_DELAY); 
+  HAL_GPIO_WritePin(SPI5_CS_GPIO_Port, SPI5_CS_Pin, GPIO_PIN_SET); 
+} 
+
+// void SPI_Init(const SPI_SOFT_TypeDef *pSoftSPI)
+// {
+// 	GPIO_InitTypeDef GPIO_InitStructure;
+//     __HAL_RCC_GPIOB_CLK_ENABLE();   		// 使能GPIOB时钟
+
+//     // //PB6  SCL PB7初始化设置
+//     // GPIO_Initure.Pin	= pSoftIIC->scl_pin ;
+//     // GPIO_Initure.Mode	= GPIO_MODE_OUTPUT_PP;  // 推挽输出
+//     // GPIO_Initure.Pull	= GPIO_PULLUP;          // 上拉
+//     // GPIO_Initure.Speed	= GPIO_SPEED_FAST;     // 快速
+//     // HAL_GPIO_Init( pSoftIIC->scl_port, &GPIO_Initure );
+
+//     // //  SDA PB7 初始化设置
+//     // GPIO_Initure.Pin	= pSoftIIC->sda_pin;
+//     // HAL_GPIO_Init( pSoftIIC->sda_port, &GPIO_Initure ); 
+    
+//     // GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);
+//     // GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); 
+
+
+// 	// 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	
+// 	// GPIO_InitTypeDef GPIO_InitStructure;
+// 	// GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //457引脚配置为推挽输出
+// 	// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5| GPIO_Pin_7;//457引脚配置为推挽输出
+// 	// GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+// 	// GPIO_Init(GPIOA, &GPIO_InitStructure);
+
+// 	// GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//pin6是MISO，对于STM32来说是输入，配置为上拉输入
+// 	// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;//pin6是MISO，对于STM32来说是输入，配置为上拉输入
+// 	// GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+// 	// GPIO_Init(GPIOA, &GPIO_InitStructure);
+
+//     // //CS引脚初始化
+//     GPIO_InitStructure.Pin = pSoftSPI->cs_pin;
+//     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP ;           //推挽输出
+//     GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;
+//     HAL_GPIO_Init(pSoftSPI->cs_port, &GPIO_InitStructure);
+
+//     //SCK和MOSI引脚初始化
+//     GPIO_InitStructure.Pin = pSoftSPI->sclk_pin ;
+//     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP ;           //推挽输出
+//     GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
+//     HAL_GPIO_Init(pSoftSPI->sclk_port, &GPIO_InitStructure);
+
+
+//     //MISO引脚初始化
+//     GPIO_InitStructure.Pin = pSoftSPI->miso_pin;
+//     // GPIO_InitStructure.Mode = GPIO_Mode_IPU ;               //浮空输入
+//     GPIO_InitStructure.Mode = GPIO_MODE_INPUT ;               //浮空输入
+// 	GPIO_InitStructure.Pull = GPIO_PULLUP;
+//     HAL_GPIO_Init(pSoftSPI->miso_pin, &GPIO_InitStructure);
+
+//    // MOSI引脚初始化
+//     GPIO_InitStructure.Pin =  pSoftSPI->mosi_pin;
+//     GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP ;           //推挽输出
+//     GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
+//     HAL_GPIO_Init(pSoftSPI->mosi_port, &GPIO_InitStructure);
+
+// 	//  初始化
+// 	HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_RESET);
+// 	HAL_GPIO_WritePin(pSoftSPI->cs_port, pSoftSPI->cs_pin, GPIO_PIN_SET);
+// 	HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_SET);
+// }
+
+ 

bsp/Src/bsp_spi_soft.c

@@ -0,0 +1,260 @@
+#include "bsp_spi_soft.h"
+#include "elog.h"
+// #include "delay.h"
+
+#define DELAY_TIME 1 // 10微秒
+
+void SPI_Init(const SPI_SOFT_TypeDef *pSoftSPI)
+{
+	GPIO_InitTypeDef GPIO_InitStructure;
+
+	__HAL_RCC_GPIOF_CLK_ENABLE(); // 使能GPIO F 时钟
+
+	// //CS引脚初始化
+	GPIO_InitStructure.Pin = pSoftSPI->cs_pin;
+	GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出
+	GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;
+	HAL_GPIO_Init(pSoftSPI->cs_port, &GPIO_InitStructure);
+
+	// SCK和MOSI引脚初始化
+	GPIO_InitStructure.Pin = pSoftSPI->sclk_pin;
+	GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出
+	GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
+	HAL_GPIO_Init(pSoftSPI->sclk_port, &GPIO_InitStructure);
+
+	// MISO引脚初始化
+	GPIO_InitStructure.Pin = pSoftSPI->miso_pin;
+	// GPIO_InitStructure.Mode = GPIO_Mode_IPU ;               //浮空输入
+	GPIO_InitStructure.Mode = GPIO_MODE_INPUT; // 浮空输入
+	GPIO_InitStructure.Pull = GPIO_PULLUP;
+	HAL_GPIO_Init(pSoftSPI->miso_pin, &GPIO_InitStructure);
+
+	// MOSI引脚初始化
+	GPIO_InitStructure.Pin = pSoftSPI->mosi_pin;
+	GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出
+	GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
+	HAL_GPIO_Init(pSoftSPI->mosi_port, &GPIO_InitStructure);
+
+	//  初始化  0   0
+	HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_SET); // 极性0 初始化需要拉高
+	HAL_GPIO_WritePin(pSoftSPI->cs_port, pSoftSPI->cs_pin, GPIO_PIN_SET);
+	// HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_SET);
+}
+
+/**
+ * @brief Set SDIO as the input mode
+ */
+void SDO_IN(const SPI_SOFT_TypeDef *pSoftSPI)
+{
+	GPIO_InitTypeDef GPIO_InitStruct = {0};
+	GPIO_InitStruct.Pin = pSoftSPI->miso_pin;
+	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+	GPIO_InitStruct.Pull = GPIO_PULLUP;
+	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+	HAL_GPIO_Init(pSoftSPI->miso_pin, &GPIO_InitStruct);
+}
+/**
+ * @brief Set SDIO as the output mode
+ */
+void SDO_OUT(const SPI_SOFT_TypeDef *pSoftSPI)
+{
+	GPIO_InitTypeDef GPIO_InitStruct;
+	GPIO_InitStruct.Pin = pSoftSPI->miso_pin;
+	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
+	GPIO_InitStruct.Pull = GPIO_PULLUP;
+	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+	HAL_GPIO_Init(pSoftSPI->miso_pin, &GPIO_InitStruct);
+}
+/**
+ * @brief Send one byte by SPI bus
+ * @def  先拉低，然后发送，在拉高有个跳变沿（从机检测到跳变），然后可以进入接收
+ * @param u8_writedata
+ */
+void SPI_Write_OneByte(const SPI_SOFT_TypeDef *pSoftSPI, uint8_t u8_writedata)
+{
+	uint8_t i;
+	for (i = 0; i < 8; i++)
+	{
+		HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_RESET); // SCK Low
+ 		__NOP();
+		if (u8_writedata & 0x80)
+			// SDI_H;
+			HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_SET);
+		else
+			// SDI_L;
+			HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_RESET);
+		// SCLK_H;
+		HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_SET);
+		__NOP();
+		u8_writedata <<= 1;
+		// SCLK_L;
+		// HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_RESET);
+	}
+}
+/**
+ * @brief Read one byte by SPI bus
+ *
+ * @return temp
+ */
+uint8_t SPI_Read_OneByte(const SPI_SOFT_TypeDef *pSoftSPI)
+{
+	uint8_t i;
+	uint8_t temp = 0;
+	for (i = 0; i < 8; i++)
+	{
+		temp <<= 1;
+		// SCLK_H;
+		HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_SET);  // SCK  High
+ 		__NOP();
+		// if (SDO_R)
+		if (HAL_GPIO_ReadPin(pSoftSPI->miso_port, pSoftSPI->miso_pin) == GPIO_PIN_SET)  // miso read
+			temp |= 0x01;
+		// SCLK_L;
+ 		__NOP();
+		HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_RESET);  
+		HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_SET);  // SCK  High
+	}
+	return temp;
+}
+
+// 同步传输数据，比如在时钟的上升沿是写数据，那么在时钟的下降沿就是读数据
+uint8_t SPI_ReadWriteByte(const SPI_SOFT_TypeDef *pSoftSPI, uint8_t TxData)
+{
+	int i = 0;
+	uint8_t RxData = 0;
+
+	HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_RESET); // sclk low
+	for (i = 7; i >= 0; i--)
+	{
+		// W25QXX_SCK_L();     // 时钟拉低 ，发送1bit
+		HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_RESET); // SCK Low
+ 		__NOP();
+		// 数据发送
+		if (TxData & (1 << i))
+		{
+			HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_SET); // MOSI H
+		}
+		else
+		{
+			HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_RESET); // MOSI L
+		}
+ 		__NOP(); 
+
+		// W25QXX_SCK_H();   // 拉高时钟读 1bit
+		HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_SET);
+ 		__NOP();
+
+		// 数据接收
+		RxData <<= 1;
+		if (HAL_GPIO_ReadPin(pSoftSPI->miso_port, pSoftSPI->miso_pin) == GPIO_PIN_SET)
+			RxData |= 0x01;
+
+ 		__NOP();
+	}
+
+	HAL_GPIO_WritePin(pSoftSPI->sclk_port, pSoftSPI->sclk_pin, GPIO_PIN_RESET); // SCK LOw
+	return RxData;
+}
+
+void SPI_Read_Write_buf(const SPI_SOFT_TypeDef *pSoftSPI, uint8_t* txBuf,uint8_t* rxBuf,uint16_t len)
+{
+	int i = 0;
+	uint8_t RxData = 0;
+
+	for ( size_t i = 0; i < len; i++ )
+	{
+		if (i==0) {
+			SPI_Write_OneByte(pSoftSPI, *txBuf);
+			txBuf++;
+		}
+		else{
+			*rxBuf = SPI_ReadWriteByte(pSoftSPI, *txBuf);
+			txBuf++;
+			rxBuf++;
+		}
+	}
+	//  TODO TimeOut
+	return  ;
+}
+
+/**
+ * @brief 	Write a register
+ *
+ * @param  d: {D2, D1, D0}  addr uint32_T
+ * @return SUCCESS
+ */
+uint8_t WriteReg(const SPI_SOFT_TypeDef *pSoftSPI, uint32_t d)
+{
+	uint8_t tx[3] = {(d >> 16) & 0xff, (d >> 8) & 0xff, d & 0xff};
+	SDO_OUT(pSoftSPI);
+	// CS_L;
+	HAL_GPIO_WritePin(pSoftSPI->cs_port, pSoftSPI->cs_pin, GPIO_PIN_RESET);
+	SPI_Write_OneByte(pSoftSPI, tx[0]);
+	SPI_Write_OneByte(pSoftSPI, tx[1]);
+	SPI_Write_OneByte(pSoftSPI, tx[2]);
+	// CS_H;
+	HAL_GPIO_WritePin(pSoftSPI->cs_port, pSoftSPI->cs_pin, GPIO_PIN_SET);
+	// SDI_L;
+	HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_RESET);
+	return SUCCESS;
+}
+
+/**
+ * @brief 	Read a register
+ * @param  d: {D2, D1, D0}  addr uint32_t
+ * @return data: The data be read in a register
+ */
+uint8_t ReadReg(const SPI_SOFT_TypeDef *pSoftSPI, uint32_t d)
+{
+	uint8_t tx[3] = {(d >> 16) & 0xff, (d >> 8) & 0xff, d & 0xff};
+	uint8_t data;
+	// tx[0] = tx[0] | RF_DATA_READ_BIT;
+	SDO_OUT(pSoftSPI);
+	// CS_L;
+	HAL_GPIO_WritePin(pSoftSPI->cs_port, pSoftSPI->cs_pin, GPIO_PIN_RESET);
+	SPI_Write_OneByte(pSoftSPI, tx[0]);
+	SPI_Write_OneByte(pSoftSPI, tx[1]);
+
+	data = SPI_Read_OneByte(pSoftSPI);
+	// CS_H;
+	HAL_GPIO_WritePin(pSoftSPI->cs_port, pSoftSPI->cs_pin, GPIO_PIN_SET);
+	SDO_OUT(pSoftSPI);
+	// SDI_L;
+	HAL_GPIO_WritePin(pSoftSPI->mosi_port, pSoftSPI->mosi_pin, GPIO_PIN_RESET);
+
+	log_i(" ReadReg ... %02X   ", data);
+	return data;
+}
+
+// test  ok
+uint32_t SPI_FLASH_ReadDeviceID(const SPI_SOFT_TypeDef *pSoftSPI)
+{
+	uint32_t Temp = 0;
+	uint8_t readout = 0;
+	// CS_L;
+	HAL_GPIO_WritePin(pSoftSPI->cs_port, pSoftSPI->cs_pin, GPIO_PIN_RESET);
+
+	log_i(" SPI_FLASH_ReadDeviceID ...  ");
+	// 发送4字节指令
+	//   readout = SPI_ReadWriteByte(pSoftSPI,0x9F);
+	SPI_Write_OneByte(pSoftSPI, 0x9F);
+	Temp |= (readout << 24);
+
+	readout = SPI_ReadWriteByte(pSoftSPI, 0xFF);
+
+	//   readout = SPI_ReadWriteByte(pSoftSPI,0xFF);
+	Temp |= (readout << 16);
+	readout = SPI_ReadWriteByte(pSoftSPI, 0xFF);
+	//   readout = SPI_ReadWriteByte(pSoftSPI,0xFF);
+	Temp |= (readout << 8);
+	readout = SPI_ReadWriteByte(pSoftSPI, 0xFF);
+	//   readout = SPI_ReadWriteByte(pSoftSPI,0xFF);
+	Temp |= (readout);
+
+	log_i("rrrr: 0x%08X\n", Temp); // 0X00EF4019
+								   // CS_H;
+	HAL_GPIO_WritePin(pSoftSPI->cs_port, pSoftSPI->cs_pin, GPIO_PIN_SET);
+
+	return Temp;
+}
+

bsp/Src/bsp_uart.c

@@ -1,205 +1,213 @@
 #include "bsp_uart.h"
+#include "elog.h"
 
-MYUART_TypeDef * Myuart_Init( )
+UART_HELPER_TypeDef * UART_HELPER_Init( )
 {
-    MYUART_TypeDef *Handle = (MYUART_TypeDef *)malloc(sizeof(MYUART_TypeDef));
+    UART_HELPER_TypeDef *Handle = (UART_HELPER_TypeDef *)malloc(sizeof(UART_HELPER_TypeDef));
     if (Handle == NULL)
     {
         return NULL;
     }
+	Handle->interface_type = Uart_Interface_Default;
+	Handle->enable_idle_it = Uart_IDLE_IT_DISABLE;
+	Handle->trans_mode = Uart_Trans_Polling;
+	Handle->rcv_mode = Uart_Trans_Polling;
+
+	Handle->trans_record = (Record_Trans_Rcv_TypeDef *)malloc(sizeof(Record_Trans_Rcv_TypeDef));
+	// Handle->rcv_record = (Record_Trans_Rcv_TypeDef *)malloc(sizeof(Record_Trans_Rcv_TypeDef));
+
 	Handle->send_flag = 0;
 	Handle->send_tc_flag = 0;
-	Handle->interface_type = 0;
-	Handle->enable_idle_it = 0;
-	Handle->enable_rcv =NULL;
-	Handle->enable_snd =NULL;
- 
-// #if MAX485_ENABLE
-// 	Handle->de485_gpio = NULL;
-// 	Handle->interface_type = 1;
-// #endif
-
-// #if MAX3160_ENABLE
-//     Handle->de485_gpio = NULL;
-// 	Handle->sel_gpio = NULL;
-// 	Handle->dplx_gpio = NULL;
-// 	Handle->interface_type = 2;
-// #endif
+	Handle->transferring = 0;
+
+	Handle->enable_trans_gpio =NULL;
+	Handle->enable_trans_cplt_gpio =NULL;
 
+	Handle->obj =NULL;
+	Handle->callback =NULL;
     return Handle;
 }
 
-void Myuart_Set_Huart(MYUART_TypeDef * myuart, UART_HandleTypeDef *huart)
+void UART_HELPER_Set_Huart(UART_HELPER_TypeDef * uarthelper, UART_HandleTypeDef *huart)
+{
+    uarthelper->huart = huart;
+}
+
+int UART_HELPER_Set_Interface_Type(UART_HELPER_TypeDef * uarthelper, uint8_t interface_type)
 {
-    myuart->huart = huart;
+	uarthelper->interface_type = interface_type;
+	return 0;
+}
+
+int UART_HELPER_Setup_Trans_mode( UART_HELPER_TypeDef * uarthelper, uint8_t trans_mode )
+{
+    /* 0 :polling, 1: IT  2: DMA*/
+	uarthelper->trans_mode = trans_mode;
+	uarthelper->rcv_mode = trans_mode;
+	return 0;
 }
 
-int Myuart_Setup_Transmod( MYUART_TypeDef * myuart, uint8_t trans_mode )
+int UART_HELPER_Setup_Rcv_mode( UART_HELPER_TypeDef * uarthelper, uint8_t rcv_mode )
 {
     /* 0 :polling, 1: IT  2: DMA*/
-	myuart->trans_mode = trans_mode;
+	uarthelper->rcv_mode = rcv_mode;
+	return 0;    
+}
+
+int UART_HELPER_Set_trans_GPIO( UART_HELPER_TypeDef * uarthelper, enable_func_gpio trans_gpio_func )
+{
+	uarthelper->enable_trans_gpio = trans_gpio_func;
 	return 0;
 }
 
-int Myuart_Set_enable_snd_func( MYUART_TypeDef * myuart, enable_func enable_snd_func )
+int UART_HELPER_Set_trans_cplt_GPIO( UART_HELPER_TypeDef * uarthelper, enable_func_gpio trans_cplt_gpio_func )
 {
-	if (enable_snd_func != NULL)  myuart->enable_snd = enable_snd_func;
+    // enable rcv
+    uarthelper->enable_trans_cplt_gpio = trans_cplt_gpio_func;
 	return 0;
 }
-int Myuart_Set_enable_rcv_func( MYUART_TypeDef * myuart, enable_func enable_rcv_func)
+
+
+
+int UART_HELPER_Set_enable_idle( UART_HELPER_TypeDef * uarthelper, uint8_t enable_idle)
 {
-	if (enable_rcv_func != NULL)  myuart->enable_rcv = enable_rcv_func;
+	uarthelper->enable_idle_it = enable_idle;
 	return 0;
 }
 
-int Myuart_Set_enable_idle( MYUART_TypeDef * myuart, uint8_t enable_idle)
+
+int UART_HELPER_Set_Rcv_Buf( UART_HELPER_TypeDef * uarthelper, uint8_t * buf, uint16_t size)
+{
+	uarthelper->rcv_buf = buf;
+	uarthelper->rcv_size = size;
+
+	// uarthelper->rcv_record->buf = buf;
+	// uarthelper->rcv_record->size = size;
+
+	return 0;
+
+}
+int UART_HELPER_Set_Trans_Buf( UART_HELPER_TypeDef * uarthelper, uint8_t * buf, uint16_t size)
 {
-	myuart->enable_idle_it = enable_idle;
+	// uarthelper->trans_buf = buf;
+	// uarthelper->trans_size = size;
+
+	uarthelper->trans_record->buf = buf;
+	uarthelper->trans_record->size = size;
+
+	return 0;
+
 }
 
-int Myuart_Set_Callback( MYUART_TypeDef * myuart, void *obj, callback_fun func)
+int UART_HELPER_Set_Callback( UART_HELPER_TypeDef * uarthelper, void *obj, callback_fun func)
 {
-	myuart->obj = obj;
-	myuart->callback = func;
+	uarthelper->obj = obj;
+	uarthelper->callback = func;
+	return 0;
 }
 
-int Myuart_Start_Rcv(MYUART_TypeDef * myuart, uint8_t *buf, uint16_t size)
+int UART_HELPER_Start_Rcv(UART_HELPER_TypeDef * uarthelper, uint8_t *buf, uint16_t size)
 {
 	int st;
-    switch ( myuart->trans_mode)
+    switch ( uarthelper->rcv_mode)
     {
         case 0:
-            st = HAL_UART_Transmit(myuart->huart,  buf,  size  , 0xFFFF);
+            st = HAL_UART_Receive(uarthelper->huart,  buf,  size  , 0xFFFF);
             return st;
             break;
         case 1:
-            st = HAL_UART_Transmit_IT(myuart->huart,  buf,  size);
+            st = HAL_UART_Receive_IT(uarthelper->huart,  buf,  size);
             return st;
             break;
         case 2:
             /* 会出现 st ==2  huart->gState != HAL_UART_STATE_READY */
-			if (myuart->enable_idle_it == 1) 
+			if (uarthelper->enable_idle_it == 1) 
 			{
-				__HAL_USART_ENABLE_IT(myuart->huart, UART_IT_IDLE);
+            // log_d("dma rcv idle en... ");
+				__HAL_UART_ENABLE_IT(uarthelper->huart, UART_IT_IDLE);
 			}
-            st = HAL_UART_Transmit_DMA(myuart->huart,  buf,  size);
+            st = HAL_UART_Receive_DMA(uarthelper->huart,  buf,  size);
+            // log_i("dma rcv ... ");
             return st;
             break;    
         default:
             break;
     }
+    return st;
 }
 
-int Myuart_Trans(MYUART_TypeDef * myuart, uint8_t *buf, uint16_t size)
+int UART_HELPER_Trans(UART_HELPER_TypeDef * uarthelper, uint8_t *buf, uint16_t size )
 {
 	int st;
-	if (myuart->enable_snd != NULL)
+    uarthelper->transferring = 1;
+	if (uarthelper->enable_trans_gpio != NULL)
 	{
-		myuart->enable_snd;
+		uarthelper->enable_trans_gpio();
 	}
 
-    switch ( myuart->trans_mode)
+    switch ( uarthelper->trans_mode)
     {
         case 0:
-            st = HAL_UART_Transmit(myuart->huart,  buf,  size  , 0xFFFF);
+            st = HAL_UART_Transmit(uarthelper->huart,  buf,  size  , 0xFFFF);
             return st;
             break;
         case 1:
-            st = HAL_UART_Transmit_IT(myuart->huart,  buf,  size);
+            st = HAL_UART_Transmit_IT(uarthelper->huart,  buf,  size);
             return st;
             break;
         case 2:
             /* 会出现 st ==2  huart->gState != HAL_UART_STATE_READY */
-            st = HAL_UART_Transmit_DMA(myuart->huart,  buf,  size);
+            st = HAL_UART_Transmit_DMA(uarthelper->huart,  buf,  size);
             return st;
             break;    
         default:
             break;
     }
-    return 0;
+    return st;
 }
 
 
-int Myuart_Trans_TxCplt_Callback( MYUART_TypeDef * myuart )
+int UART_HELPER_Trans_TxCplt_Callback( UART_HELPER_TypeDef * uarthelper )
 {
-
-	if (myuart->enable_rcv != NULL)
+    // log_d( " uarthelper tc callback...........");
+    uarthelper->transferring = 0;
+	if (uarthelper->enable_trans_cplt_gpio != NULL)
 	{
-		myuart->enable_rcv;
+        // log_i( " uarthelper tc callback... not null........");
+		uarthelper->enable_trans_cplt_gpio();
 	}
     return 0;
 }
 
-// void Myuart_Set_Sel_GPIO_Pin(MYUART_TypeDef * myuart, GPIO_TypeDef *gpio, uint16_t pin)
-// {
-// #if MAX3160_ENABLE
-//     myuart->sel_gpio = gpio;
-//     myuart->sel_pin = pin;
-// #endif
- 
-// }
-
-// void Myuart_Set_Dplx_GPIO_Pin(MYUART_TypeDef * myuart, GPIO_TypeDef *gpio, uint16_t pin)
-// {
-// #if MAX3160_ENABLE
-//     myuart->dplx_gpio = gpio;
-//     myuart->dplx_pin = pin;
-// #endif
-// }
-
-// void Myuart_Set_DE485_GPIO_Pin(MYUART_TypeDef * myuart, GPIO_TypeDef *gpio, uint16_t pin)
-// {
-// #if MAX3160_ENABLE
-//     myuart->de485_gpio = gpio;
-//     myuart->de485_pin = pin;
-// #endif
-
-// #if MAX485_ENABLE
-//     myuart->de485_gpio = gpio;
-//     myuart->de485_pin = pin;
-// #endif
-// }
-
-// void Myuart_Set_232(MYUART_TypeDef * myuart)
-// {
-// #if MAX3160_ENABLE
-//     myuart->sel = SEL_232;
-//     HAL_GPIO_WritePin( myuart->sel_gpio, myuart->sel_pin, myuart->sel );
-//     HAL_GPIO_WritePin( myuart->dplx_gpio, myuart->dplx_pin, DUPLEX_FULL );
-// #endif
-// }
-
-// void Myuart_Set_485(MYUART_TypeDef * myuart)
-// {
-// #if MAX3160_ENABLE
-//     myuart->sel = SEL_485;
-//     HAL_GPIO_WritePin( myuart->sel_gpio, myuart->sel_pin, myuart->sel );
-//     HAL_GPIO_WritePin( myuart->dplx_gpio, myuart->dplx_pin, DUPLEX_HALF );
-//     HAL_GPIO_WritePin( myuart->de485_gpio, myuart->de485_pin, DISABLE_485_Trans );
-// #endif
-// }
-
-
-// int __Myuart_Send(MYUART_TypeDef * myuart , uint8_t *buf, uint16_t size)
-// {
-//     uint8_t st;
-//     switch ( myuart->trans_mode)
-//     {
-//         case 0:
-//             st = HAL_UART_Transmit(myuart->huart,  buf,  size  , 0xFFFF);
-//             return st;
-//             break;
-//         case 1:
-//             st = HAL_UART_Transmit_IT(myuart->huart,  buf,  size);
-//             return st;
-//             break;
-//         case 2:
-//             /* 会出现 st ==2  huart->gState != HAL_UART_STATE_READY */
-//             st = HAL_UART_Transmit_DMA(myuart->huart,  buf,  size);
-//             return st;
-//             break;    
-//         default:
-//             break;
-//     }
-//     return 0;
-// }
+int UART_HELPER_RCV_Cplt_Callback( UART_HELPER_TypeDef * uarthelper )
+{
+    log_i( " UART_HELPER_RCV_Cplt_Callback  ........");
+
+    // TODO
+    
+    if (uarthelper->enable_idle_it == 0)
+    {
+        uarthelper->callback( uarthelper->obj, uarthelper->rcv_buf,uarthelper->rcv_size);
+    }
+    if (uarthelper->enable_idle_it == 1)
+    {
+        // idle 中断处理， do nothing
+    }
+    return 0;
+}
+
+
+int UART_HELPER_RCV_IDLE_Callback( UART_HELPER_TypeDef * uarthelper, uint16_t size )
+{
+    // TODO
+    // if (uarthelper->rcv_mode == 0)
+    // {
+    //     HAL_UART_DMAStop( uarthelper->huart );
+    // }
+
+    // 包含停止DMA 开始新的接收
+    HAL_UART_DMAStop( uarthelper->huart );
+    uarthelper->callback( uarthelper->obj, uarthelper->rcv_buf, size);
+    UART_HELPER_Start_Rcv(uarthelper, uarthelper->rcv_buf, uarthelper->rcv_size);
+    return 0;
+}

device/Inc/Ramses.h

@@ -1,20 +1,31 @@
-/**
- * @file Ramses.h
- * @author Esea (info@eseaoptics.com)
- * @brief Ramses 光谱仪驱动
- * @version 1.0
- * @date 2023-08-27
- * 
- * @copyright ESEA (c) 2020
- * 
- */
-#ifndef TRIOS_REMSES_H_
-#define TRIOS_REMSES_H_
-#include <stddef.h>
-#include <stdint.h>
+/*
+加入队列 处理
+*/
+#ifndef __RAMSES__H
+#define __RAMSES__H
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "main.h"
+#include "cmsis_os.h"
+#include "usart.h"
+ 
+#include "elog.h"
+
+
 #include <string.h>
-#include "uart_helper.h"
-#include "uart_interface.h"
+#include "bsp_uart.h"
+ 
+
+static void Ramses_MAX3160_232(void) 
+{
+  HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, RESET);
+  HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET);
+}
 
 #define Ramses_CMD_SIZE (8)
 #define Ramses_DATA_SIZE (64+8)
@@ -34,15 +45,19 @@ typedef int (*Ramses_send_fun)(void *send_class,uint8_t *buf,uint32_t size);
 
 typedef enum 
 {
-    MODULE_RAMSESE_STATE_WAIT,
-    MODULE_RAMSESE_STATE_START,
-    MODULE_RAMSESE_STATE_SEND_CMD,
-    MODULE_RAMSESE_STATE_CHECK_SENSOR,
-    MODULE_RAMSESE_STATE_GET_DATA,
-    MODULE_RAMSESE_STATE_OK,
-    MODULE_RAMSESE_STATE_ERROR,
-    MODULE_RAMSESE_STATE_STOP
-} MODULE_RAMSESE_WORK_STATE;
+    MODULE_RAMSES_STATE_WAIT,
+    MODULE_RAMSES_STATE_TEST,
+    MODULE_RAMSES_STATE_TESTING,
+    MODULE_RAMSES_STATE_TEST_OK,
+    MODULE_RAMSES_STATE_READY,
+    MODULE_RAMSES_STATE_START,
+    MODULE_RAMSES_STATE_SEND_CMD,
+    MODULE_RAMSES_STATE_CHECK_SENSOR,
+    MODULE_RAMSES_STATE_GET_DATA,
+    MODULE_RAMSES_STATE_OK,
+    MODULE_RAMSES_STATE_ERROR,
+    MODULE_RAMSES_STATE_STOP
+} MODULE_RAMSES_WORK_STATE;
 
 enum trios_integration_time{
     TRIOS_INTEGRATION_TIME_AUTO,
@@ -59,7 +74,8 @@ enum trios_integration_time{
     TRIOS_INTEGRATION_TIME_4096MS,
     TRIOS_INTEGRATION_TIME_8192MS
 };
-struct Ramses_data
+
+typedef struct Ramses_data
 {
     uint16_t dev_id;
     uint8_t module_id;
@@ -67,8 +83,9 @@ struct Ramses_data
     uint8_t data_size;
     uint8_t *data;
     uint8_t raw[Ramses_DATA_SIZE];
-};
-struct Ramses_ip
+}RAMSES_Data_TypeDef;
+
+typedef struct Ramses_ip
 {
     uint16_t dev_id;
     uint8_t module_id;
@@ -76,188 +93,175 @@ struct Ramses_ip
     uint8_t data_size;
     uint8_t *data;
     uint8_t raw[Ramses_IP_SIZE];
-};
+}RAMSES_IP_TypeDef;
 
-struct Ramses_infomation
+typedef struct Ramses_infomation
 {
     uint16_t dev_id;
     uint8_t module_id;
     uint16_t serial_number;
     uint8_t firmware_number[2];
     uint8_t individual_information[Ramses_INFO_SIZE-8];
-};
+}RAMSES_Info_TypeDef;
 
-typedef struct trios_ramses
+typedef enum 
 {
-	// UartHelper_TypeDef *uarthelper;
-    volatile MODULE_RAMSESE_WORK_STATE state;
-    volatile uint8_t send_flag;  		/* 发送标志位 */
-    volatile Uart_Status_TypeDef send_status;  /* 发送状态 1：正在发送 busy，0：发送ok，*/
-    volatile Uart_Status_TypeDef status;  /* 发送状态 0: ready , 1：正在发送 busy，2：发送ok，*/
-    volatile uint8_t step;             /* 0 : normal , 1 : get wavelength ,  2 : get sn   3: 空*/
-    // volatile uint8_t command_seq ;      /* 命令序号 */
-
-    uint8_t flag;
-    uint8_t flag_ip;
-    uint8_t data_index;
-    uint8_t recv_buf_p;
-    uint8_t data_size;
-    uint8_t recv_flag_40;
-    uint8_t cmd_buf[Ramses_CMD_SIZE];
-
-    struct Ramses_infomation infomation;
-    struct Ramses_ip ip;
-    struct Ramses_data data[Ramses_DATA_NUM];
-    uint8_t recv_buf[Ramses_DATA_SIZE];
-    uint16_t sn; 
-    uint8_t error;
-
-    uint8_t data_ok;                 /* 接收数据完整可以处理 */
-    volatile uint16_t size_received;            
-    uint64_t timebase;
-    uint64_t timeout_ms;
-    uint64_t timeout_enable;
-
-    void *send_class;
-    Ramses_send_fun send_fun;
-
-}Ramses_TypeDef;
-extern Ramses_TypeDef *ramses ;
-
-
-
-
-
+  Ramses_Event_Ready ,
+  Ramses_Event_Test,
+  Ramses_Event_Test_OK  ,
+  Ramses_Event_Get_Data,
+  Ramses_Event_Check_Data  ,
+} Module_Ramses_Event_TypeDef;
+
+// typedef enum 
+// {
+//   Ramses_State_Waiting  ,
+//   Ramses_State_Test ,
+//   Ramses_State_Test_Start ,
+//   Ramses_State_SN_Getting ,
+//   Ramses_State_SN_OK ,
+//   Ramses_State_Ready  ,
+//   Ramses_State_Get_WAVELENGTH  ,
+// //   Ramses_State_Get_WAVELENGTH_Wait  ,
+// //   Ramses_State_Get_WAVELENGTH_OK,
+// //   Ramses_State_Get_WAVELENGTH_Check  ,
+//   Ramses_State_Get_DATA  ,
+//   Ramses_State_Get_DATA_Trans,
+//   Ramses_State_Get_DATA_Wait  ,
+//   Ramses_State_Get_DATA_OK,
+//   Ramses_State_Get_DATA_Check  ,
+//   Ramses_State_Get_Queue_MSG  ,
+//   Ramses_State_Stop ,
+//   Ramses_State_Timeout ,
+//   Ramses_State_Error   ,
+// } Module_Ramses_State_TypeDef;
 
-static inline void Ramses_clean_data_recved_flag(Ramses_TypeDef *ramses)
-{
-    ramses->flag&=~Ramses_FLAG_MASK_RECVED_DATA;
-}
-static inline void Ramses_clean_ip_recved_flag(Ramses_TypeDef *ramses)
-{
-    ramses->flag&=~Ramses_FLAG_MASK_RECVED_IP;
-}
-static inline void Ramses_clean_info_recved_flag(Ramses_TypeDef *ramses)
-{
-    ramses->flag&=~Ramses_FLAG_MASK_RECVED_INFO;
-}
 
-int Ramses_init( );
-int Ramses_send_cmd(Ramses_TypeDef *ramses,uint16_t dev_id,uint8_t module_id,uint8_t instruction,uint8_t parameter1,uint8_t parameter2);
-int Ramses_cmd_messung(Ramses_TypeDef *ramses,uint8_t module_id);
-int Ramses_cmd_set_integration_time(Ramses_TypeDef *ramses,enum trios_integration_time integration_time);
-int Ramses_cmd_get_infomation(Ramses_TypeDef *ramses,uint8_t module_id);
-uint32_t Ramses_get_ip_raw(Ramses_TypeDef *ramses,uint8_t *buf,uint32_t size);
-uint32_t Ramses_get_data_raw(Ramses_TypeDef *ramses,uint8_t *buf,uint32_t size);
-uint32_t Ramses_get_data(Ramses_TypeDef *ramses,int16_t *data,uint32_t num);
-double Ramses_get_x_inclination_angle(Ramses_TypeDef *ramses,double incl_xgain,double incl_xoffset);
-double Ramses_get_y_inclination_angle(Ramses_TypeDef *ramses,double incl_ygain,double incl_yoffset);
-double Ramses_get_inclination_angle(double x_inclination_angle,double y_inclination_angle);
-double Ramses_get_pressure(Ramses_TypeDef *ramses,double incl_kref,double incl_kbg,double press_gain,double press_surface_bar,double press_sens_mv_bar_1ma,double press_sens_mv_bar_4ma);
-double Ramses_get_depth_m(double pressure);
-uint16_t Ramses_get_serial_number(Ramses_TypeDef *ramses);
-void Ramses_receive_callback(Ramses_TypeDef *ramses,uint8_t *buf,uint32_t size);
-void Ramses_clean_flag(Ramses_TypeDef *ramses,uint8_t mask);
-uint8_t Ramses_get_flag(Ramses_TypeDef *ramses,uint8_t mask);
-
-void Ramses_Set_Timeout(Ramses_TypeDef *ramses,    uint16_t timeout_ms );
-int Ramses_Get_Timeout( Ramses_TypeDef *ramses );
-
-void Ramses_Set_Sendbuf( Ramses_TypeDef *ramses,  uint8_t * buf, uint16_t size );
-void Ramses_Set_Rcvbuf( Ramses_TypeDef *ramses,  uint8_t * buf, uint16_t size );
-
-void Ramses_Set_State (Ramses_TypeDef *ramses, MODULE_RAMSESE_WORK_STATE state);
-
-// void Ramses_Setup ();
-void Ramses_Port ();
-void Ramses_Task(void * argument);
-int Ramses_copy(Ramses_TypeDef *ramses ,uint16_t size);
-/* 再封装演示 */ 
 typedef struct 
 {
-	uint8_t (*init)( );			 
-	uint8_t (*port)(void);	
-
-    GPIO_TypeDef *sel_gpio;	 
-    GPIO_TypeDef *dplx_gpio;	 
-    GPIO_TypeDef *de_gpio;	 
-    uint16_t sel_pin;
-    uint16_t dplx_pin;
-    uint16_t de_pin;
-
-    Uart_Interface_Type_Typedef interface_type; /* 0: common, 1: 485 ,2:3160*/
-    Uart_RS_Mode_TypeDef mode_232_485;       /* 0 commome  1:485*/
-    Uart_Transmode_TypeDef trans_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_Transmode_TypeDef rcv_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_IDLE_Enable_TypeDef idle_enable_disable;     /* 0 :不启用空闲 , 1: 启用空闲/
- 
-    SC6_TypeDef *sample; /*不是常量  不能直接初始化*/
-
-}My_Ramses_TypeDef;
-extern My_Ramses_TypeDef myramses ;
-#endif
-
-
-
-
-
-
-
-
+    int (*init)(void);
+    void (*port)(void);
+    int (*test)(void);
+    void (*start)(void);
+    void (*stop)(void);
 
+    osMessageQueueId_t transQueue;  // 队列可选
 
+    volatile MODULE_RAMSES_WORK_STATE state; 
+    uint8_t data_ok;                 /* 接收数据完整可以处理 */
 
+    uint8_t result_buf[1024];
+    uint16_t size_received;
 
+    volatile uint8_t flag;
+    volatile uint8_t flag_ip;
+    volatile uint8_t data_index;
+    volatile uint8_t recv_buf_p;
+    volatile uint8_t data_size;
+    volatile uint8_t recv_flag_40;
+    uint8_t cmd_buf[Ramses_CMD_SIZE];
 
+    RAMSES_Info_TypeDef information;
+    RAMSES_IP_TypeDef ip;
+    RAMSES_Data_TypeDef data[Ramses_DATA_NUM];
+    uint8_t recv_buf[Ramses_DATA_SIZE];    // 每帧的数据
+    uint16_t sn; 
+    uint8_t error;
 
+    uint64_t  timebase_ticks;
+    uint64_t  timeout_ticks;
 
-// typedef struct 
-// {
-// 	UartHelper_TypeDef *uarthelper;
-//     UART_HandleTypeDef *huart;
-//     uint8_t interface_type; /* 0: common, 1: 485 ,2:3160*/
-// 	uint8_t mode_232_485; /* 0: common, 1: 485  */
-//     uint8_t trans_type;  /* 0 :polling, 1: IT  2: DMA*/
-//     uint8_t rcv_type;  /* 0 :polling, 1: IT  2: DMA*/
-//     uint8_t idle_enable_disable;    /* 0 不开启空闲中断 ， 1 开启空闲中断 */
-// 	uint8_t trans_mode;         /* 0 :polling, 1: IT  2: DMA*/
+}Ramses_TypeDef;
 
-// 	uint8_t *send_buf;
-// 	uint16_t size_send;
-// 	uint8_t *rcv_buf;
-// 	uint16_t size_rcv;
+extern UART_HELPER_TypeDef *Ramses_uart_helper;
+extern Ramses_TypeDef ramses ;
 
-// 	volatile uint8_t send_flag;  		/* 发送标志位 */
-// 	Uart_Status_TypeDef send_status;  /* 发送状态 1：正在发送 busy，0：发送ok，*/
-// 	Uart_Status_TypeDef status;  /* 发送状态 1：正在发送 busy，0：发送ok，*/
+int Ramses_Init( void );
+void Ramses_Port( void);
+void Ramses_Task( void *arg);
+ 
+int Ramses_Test(  );
+void Ramses_Start(  );
+void Ramses_Stop(  );
 
-//     uint8_t command_seq ;      /* 命令序号 */
-//     uint8_t mode;  /* 0 : normal , 1 : get wavelength ,  2 : get sn  */
+void Ramses_Set_Sendbuf(   uint8_t * buf, uint16_t size );
+void Ramses_Set_Rcvbuf(   uint8_t * buf, uint16_t size );
+void Ramses_Set_Timeout_ms(    uint64_t ms_ticks );
+int Ramses_Validate(  );
 
-//   uint8_t result_Buf[SC6_Rcv_Buf_Size];
-//   uint8_t SC6_Data_Buf[SC6_Rcv_Buf_Size*2];
-//   uint8_t SC6_Raw_Buf[SC6_Rcv_Buf_Size*3];
 
-//   uint8_t *data_start_tag;
-//   uint8_t *data_end_tag;
+int Ramses_Transmit();
+int Ramses_Receive();
 
-//   uint8_t start_cmd_valid ;
-//   uint8_t stop_cmd_valid ;
-//   uint8_t *start_cmd_buf;
-//   uint8_t *stop_cmd_buf;
+void Ramses_Trans_GPIO(void) ;
 
-//     uint8_t rcv_ok;                 /* 接收数据完整可以处理 */
-//     uint8_t data_begin_flag;                 /* 接收数据完整可以处理 */
-//     uint8_t data_ok;                 /* 接收数据完整可以处理 */
-//     uint16_t size_received;
+void Ramses_Trans_Cplt_GPIO(void) ;
 
+int Ramses_CallBack( Ramses_TypeDef *pRamses , uint8_t *buf, uint16_t size );
 
 
-// 	uint32_t timebase;
-// 	uint16_t timeout_ms;
+#ifdef __cplusplus
+	}
+#endif
+#endif
 
-// 	uint8_t (*Init)(void);			//初始化触摸屏控制器
-// 	// uint8_t (*Setup)( );				//扫描触摸屏.0,屏幕扫描;1,物理坐标;	 
-// 	uint8_t (*Port)( );				//扫描触摸屏.0,屏幕扫描;1,物理坐标;	 
 
-// }SC6_TypeDef;
+/*
+    temp.init();
+    temp.port();
+    temp.test();
+
+    uint64_t ticks = osKernelGetTickCount();
+
+    while ( temp.state != PH_State_Ready )
+    {
+        if ( ( osKernelGetTickCount() -ticks) > 3000 )
+        {
+            log_e(" pH test error.... ") ;
+            break;
+        }
+    }
+    log_w(" pH test ok.... ") ;
+
+
+// osMessageQueueId_t TestQQueueueueHandle;
+// 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,
+// void *  msg_ptr,       //储存读取结果的变量地址
+// uint8_t *  msg_prio,  // ==NULL
+// uint32_t  timeout    //阻塞超时时间
+// );
+// osStatus_t osMessageQueuePut ( osMessageQueueId_t  mq_id,
+// const void *  msg_ptr,     //储存写入内容的变量地址
+// uint8_t  msg_prio,        //==0U
+// uint32_t  timeout         //阻塞超时时间
+// );
+
+
+// uint8_t Ramses_SN_command[8] = {0x01, 0x03, 0x00, 0x0A, 0x00, 0x05, 0xA5, 0xCB};
+
+// uint8_t Ramses_Wavelength_sendbuf[3][8]   = {
+//         
+//         // 01 03 08 36 00 7A 26 47    (2102  122)
+//         // 01 03 08 B0 00 7A C7 AE    (2224  122)
+//         // 01 03 09 2A 00 7A E6 7D    (2346  122)
+//         
+//         { 0x01, 0x03, 0x08, 0x36, 0x00, 0x7A, 0x26, 0x47 },
+//         { 0x01, 0x03, 0x08, 0xB0, 0x00, 0x7A, 0xC7, 0xAE },
+//         { 0x01, 0x03, 0x09, 0x2A, 0x00, 0x7A, 0xE6, 0x7D }
+//     };
+// uint8_t Ramses_Data_sendbuf[3][8]   = {
+//         
+//         //01 03 0A 36 00 7A 27 FF    (2614  122)
+//         //01 03 0A B0 00 7A C6 16    (2736  122)
+//         //01 03 0B 2A 00 7A E7 C5    (2858  122)
+//         
+//         { 0x01, 0x03, 0x0A, 0x36, 0x00, 0x7A, 0x27, 0xFF },
+//         { 0x01, 0x03, 0x0A, 0xB0, 0x00, 0x7A, 0xC6, 0x16 },
+//         { 0x01, 0x03, 0x0B, 0x2A, 0x00, 0x7A, 0xE7, 0xC5 }
+//     };
+// uint8_t Ramses_sn_buf[15] = {0};
+
+
+*/

device/Inc/bsp_i2c_ads1115.h

@@ -5,7 +5,8 @@
 #include "task.h"
 #include "main.h"
 #include "cmsis_os.h"
-#include "i2c.h"
+// #include "i2c.h"
+#include "bsp_i2c.h"
 
 #define ADS1115_WRITE_ADDRESS        0x92
 #define ADS1115_READ_ADDRESS         0x93
@@ -15,27 +16,27 @@
 /*事件开始 set, 事件完成  clear */
 typedef enum
 {
-   ADS1115_Event_READY,                   /*!< Startup finished. */
-   ADS1115_Event_INIT,                  
-//    ADS1115_Event_INIT_SUCCESS,                  
+   ADS1115_Event_READY,                   /*!< Startup finished. */       
+   ADS1115_Event_TEST_SUCCESS,                  
    ADS1115_Event_Get_Data,                  
-   ADS1115_Event_Get_Data_Convert_Register,                  
-   ADS1115_Event_Get_Data_RCV,                  
-   ADS1115_Event_TRANS_ONLY,                  
-   ADS1115_Event_TRANS_FOR_DATA,                 
-   ADS1115_Event_DATA_RCV,                 
+   ADS1115_Event_Get_Data_Set_Reg01,                                
+   ADS1115_Event_DATA_RCV_OK,                 
 } ADS1115_Event_TypeDef;
 
 typedef enum {
    ADS1115_WORK_STATE_WAITING,
    ADS1115_WORK_STATE_START,
-   ADS1115_WORK_STATE_INIT,
+   ADS1115_WORK_STATE_TEST,
+   ADS1115_WORK_STATE_TESTING,
+   ADS1115_WORK_STATE_TEST_OK,
    ADS1115_WORK_STATE_GET_DATA_READY,
    ADS1115_WORK_STATE_GET_DATA_START,
-   ADS1115_WORK_STATE_GET_DATA,
-   ADS1115_WORK_STATE_GET_DATA_Convert_Register,
+   ADS1115_WORK_STATE_GET_DATA_SET_REG01,
+   ADS1115_WORK_STATE_GET_DATA_SET_REG01_Wait,
+   // ADS1115_WORK_STATE_GET_DATA_Convert_Register,
    ADS1115_WORK_STATE_GET_DATA_RCV,
-   ADS1115_WORK_STATE_GET_DATA_FLOAT,
+   ADS1115_WORK_STATE_GET_DATA_RCV_Wait,
+   // ADS1115_WORK_STATE_GET_DATA_FLOAT,
    ADS1115_WORK_STATE_GET_DATA_OK,
    ADS1115_WORK_STATE_ERROR,
    ADS1115_WORK_STATE_STOP
@@ -146,13 +147,15 @@ typedef enum
     ADS1115_REG_CONFIG_COMP_QUE_DIS=       (0x3U << 0)
 } ADS1115_REG_CONFIG_COMP_QUE_TypeDef;
 
-
+extern I2C_HELPER_TypeDef *ads1115_i2c_helper;
 
 typedef struct{
    int (*init)(void);
    void (*port)(void);
+   int (*test)(void);
    void (*start)(void);
-   I2C_HandleTypeDef *hi2c;
+   void (*stop)(void);
+   // I2C_HandleTypeDef *hi2c;
 
    uint8_t config_os;
    uint8_t config_mux;
@@ -169,19 +172,39 @@ typedef struct{
    uint8_t reg_data[3];
    ADS1115_OUTPUT_UNIT_TypeDef unit;
    uint16_t result_int16;   // 多组可用于
+   double coeff;   // 放大1000倍数
    double voltage_mv;
    volatile ADS1115_WORK_STATE_TypeDef state;
+   uint8_t event_flag;
 }ADS1115_TypeDef;
 
 extern ADS1115_TypeDef my_ads1115;
 
+static void ads1115_get_reg_data(void)
+{
+    my_ads1115.config_H = my_ads1115.config_os|my_ads1115.config_mux
+                |my_ads1115.config_PGA|my_ads1115.config_MODE;
+    my_ads1115.config_L = my_ads1115.config_DR|my_ads1115.config_COMP_MODE|my_ads1115.config_COMP_POL
+            |my_ads1115.config_COMP_LAT|my_ads1115.config_COMP_QUE ;
+
+    // my_ads1115.reg_data[0] = 0x01;                 //  point addr  8bit  配置寄存器
+    my_ads1115.reg_data[0] = my_ads1115.config_H;  //  config_reg 高位
+    my_ads1115.reg_data[1] = my_ads1115.config_L;  //  config_reg 低位
+}
+
 int ads1115_init(void);
 void ads1115_port(void);
+int ads1115_test(void);
+void ads1115_start(void);
+void ads1115_stop(void);
 int ads1115_setup(ADS1115_REG_CONFIG_MUX_Diff_TypeDef mux);
 // void ads1115_config_register(I2C_HandleTypeDef *ads1115_I2cHandle,uint8_t pointADD,uint8_t configH,uint8_t configL);
 int16_t ads1115_read_data( );
+double ads1115_get_coeff( );
 double ads1115_get_voltage_val( );
 void ads1115_get_data_start(void);
+
+void ads1115_callback(ADS1115_TypeDef *pAds1115, uint8_t *buf, uint16_t size);
 #endif
 
 /***************/

device/Inc/bsp_i2c_soft.h

@@ -0,0 +1,156 @@
+#ifndef __BSP_I2C_SOFT_H
+#define __BSP_I2C_SOFT_H
+#include "stm32f4xx_hal.h"
+#include "main.h"
+// #include "sys.h"
+
+// #define SCL_GPIO_PORT GPIOB
+// #define SCL_PIN	 GPIO_PIN_6
+// #define SDA_GPIO_PORT GPIOB
+// #define SDA_PIN	 GPIO_PIN_7 
+
+#define I2C_WRITE (0x00)
+#define I2C_READ  (0x01)
+
+typedef enum  {
+  IIC_OK           = 0x00,    //IIC工作正常
+  IIC_WAIT_ACK_ERR = 0x01,    //slave设备返回ACK错误
+  IIC_WRITE_ERR    = 0x02,    //向slave设备写入错误
+  IIC_READ_ERR     = 0x04     //从slave设备读取错误
+} IIC_STATUS;
+
+typedef enum
+{
+    I2C_SW_Standard_Mode = 100 * 1000,
+    I2C_SW_Fast_Mode = 400 * 1000,
+    I2C_SW_Fast_Mode_Plus = 1000 * 1000,
+} I2C_SW_Speed_Mode_TypeDef; //i2c速率 unit Hz
+
+typedef enum
+{
+    I2C_SW_One_Byte = 1,
+    I2C_SW_Two_Byte = 2,
+    I2C_SW_Four_Byte = 4
+} I2C_SW_Data_Width_TypeDef;//数据长度（寄存器地址或者值的数据长度）
+
+typedef enum
+{
+    I2C_SW_Slave_Address_7Bit,
+    I2C_SW_Slave_Address_10Bit,
+} I2C_SW_Slave_Address_Width_TypeDef;//i2c slave address的位宽
+
+typedef struct
+{
+  GPIO_TypeDef	*scl_port;		//定义IIC时钟使用的端口
+  uint16_t			scl_pin;			//定义IIC时钟使用的PIN脚
+  GPIO_TypeDef	*sda_port;   	//定义IIC数据使用的端口
+  uint16_t			sda_pin;			//定义IIC数据使用的PIN脚
+  uint8_t			sda_pin_num;   	//SDA Pin ，操作IO Mode
+  uint16_t				addr;        	//器件地址， 兼容16bit
+  uint32_t			delaytick;   	//定义延时，以适应不同器件对速率的不同要求,具体值要在调试中确定
+  I2C_SW_Slave_Address_Width_TypeDef slave_address_width;
+  I2C_SW_Data_Width_TypeDef slave_reg_addr_width;
+  I2C_SW_Data_Width_TypeDef slave_reg_value_width;
+}IIC_SOFT_TypeDef;
+
+//IO方向设置
+#define SDA_IN()  {SDA_GPIO_PORT->MODER&=~(3<<(7*2));SDA_GPIO_PORT->MODER|=0<<7*2;}	//PB7输入模式
+#define SDA_OUT() {SDA_GPIO_PORT->MODER&=~(3<<(7*2));SDA_GPIO_PORT->MODER|=1<<7*2;} //PB7输出模式
+
+
+#define		GPIO_WRITE_PIN(PORT,PIN,VALUE)	HAL_GPIO_WritePin(PORT,PIN,(VALUE)?GPIO_PIN_SET:GPIO_PIN_RESET)
+#define		GPIO_READ_PIN(PORT,PIN)					HAL_GPIO_ReadPin(PORT,PIN)
+
+
+//IIC所有操作函数
+// void IIC_Init(  );                //初始化IIC的IO口				 
+
+void IIC_Init(const IIC_SOFT_TypeDef *pSoftIIC);                //初始化IIC的IO口		
+
+int IIC_READ_SDA_Pin(const IIC_SOFT_TypeDef *pSoftIIC);
+int IIC_SDA_Mode_In(const IIC_SOFT_TypeDef *pSoftIIC);
+int IIC_SDA_Mode_Out(const IIC_SOFT_TypeDef *pSoftIIC);
+
+void IIC_Start(const IIC_SOFT_TypeDef *pSoftIIC);				//发送IIC开始信号
+void IIC_Stop(const IIC_SOFT_TypeDef *pSoftIIC);	  			//发送IIC停止信号
+
+int IIC_Send_Byte(const IIC_SOFT_TypeDef *pSoftIIC,uint8_t txd);			//IIC发送一个字节
+int IIC_Read_Byte( const IIC_SOFT_TypeDef *pSoftIIC);//IIC读取一个字节
+
+int IIC_Send_Slave_Addr(const IIC_SOFT_TypeDef *pSoftIIC,uint8_t r_w);
+int IIC_Send_Reg_Addr(const IIC_SOFT_TypeDef *pSoftIIC,uint32_t reg_addr );
+
+
+int IIC_Wait_Ack(const IIC_SOFT_TypeDef *pSoftIIC); 				//IIC等待ACK信号
+void IIC_Ack(const IIC_SOFT_TypeDef *pSoftIIC);					//IIC发送ACK信号
+void IIC_NAck(const IIC_SOFT_TypeDef *pSoftIIC);				//IIC不发送ACK信号
+
+
+int IIC_Read_Buf(const IIC_SOFT_TypeDef *pSoftIIC,  uint32_t reg_addr , uint8_t *buf, uint8_t len);
+int IIC_Write_Buf(const IIC_SOFT_TypeDef *pSoftIIC , uint32_t reg_addr, uint8_t *buf, uint8_t len);
+
+
+int IIC_Device_Check(const IIC_SOFT_TypeDef *pSoftIIC);
+#endif
+
+
+/*
+时序
+//  * @brief: I2C 开始,SCL为高电平的时候SDA产生一个下降沿信号
+ 
+//           _____
+//      *SDA      \_____________
+//      *    __________
+//      *SCL           \________
+//      
+
+
+//  * @brief: I2C 停止,SCL为高电平的时候SDA产生一个上升沿信号
+//                      _______
+//      *SDA __________/
+//      *          ____________
+//      *SCL _____/
+ 
+
+//  * @brief: I2C 响应
+//                  ____
+//      *SCL ______/    \______
+//      *    ____         _____
+//      *SDA     \_______/
+//       
+
+//  * @brief: I2C 不响应
+ 
+//                  ____
+//      *SCL ______/    \______
+//      *    __________________
+//      *SDA
+//        
+
+十位slave 先发  高位
+0xF00 | ((slave_addr>> 8 & 0x03)<<2) | r_w
+
+16bit 寄存器 addr ,先发  (addr>>8)&0xFF ,后发  addr&0xFF
+
+
+
+    IIC_SOFT_TypeDef sIIC = {
+         GPIOB, GPIO_PIN_6, GPIOB, GPIO_PIN_7,
+         7,0x50,1,
+         	    I2C_SW_Slave_Address_7Bit,
+        I2C_SW_One_Byte,
+        I2C_SW_One_Byte,
+    };
+    IIC_Init( &sIIC  );
+
+    if (!IIC_Device_Check(&sIIC))
+        log_i( "hello i2c_address= 0x%02X (7bit) is exist\r\n", sIIC.addr);
+ 
+    IIC_Write_Buf( &sIIC,  0, writein, 1 );
+    HAL_Delay( 200 );
+
+    IIC_Read_Buf(&sIIC,  0, readout, 1 );
+
+    log_i("iic test  %02X .... \r\n ", *readout);
+
+*/

device/Inc/eeprom.h

@@ -6,15 +6,17 @@
 * 一种设置size  send_buf 实现
 */
 #include "main.h"
-// #include "platform.h"
-#include "i2c.h"
-#include "i2c_helper.h"
-
-#include "FreeRTOSConfig.h"
-#include "cmsis_os2.h"
+ 
+#include "FreeRTOS.h"
+#include "task.h"
+#include "main.h"
+#include "cmsis_os.h"
+#include "bsp_i2c.h"
 #include "elog.h"
 
 #define EEPROM_BYTE_DELAY_ENABLE 1
+#define EEPROM_WRITE_ADDRESS 0xA0
+#define EEPROM_READ_ADDRESS 0xA1
 
 typedef enum {
     EEPROM_EVT_WRITE,
@@ -57,80 +59,74 @@ typedef enum {
 
 // typedef void (*read_callback)();
 // typedef void (*write_callback)();
-typedef struct
-{
-    I2C_HandleTypeDef *hi2c;
-    // I2CHelper_TypeDef *i2chelper;
-    EEPROM_MODEL_TypeDef    model;       //  AT24C01  AT24C02  AT24C256
-    EEPROM_MEM_ADDR_TypeDef     mem_addr_type;      //  1: 8bit  2: 16bit I2C_MEMADD_SIZE_8BIT  I2C_MEMADD_SIZE_16BIT
-    // EEPROM_MEM_ADDR_BIT_TypeDef mem_addr_bit;      //  1: 7bit  2: 10bit 
-    EEPROM_DEV_ADDR_TypeDef     dev_addr;       //   8bit 写地址
-    uint8_t     page_addr;
-
-    volatile EEPROM_STATE_TypeDef state;
-    uint8_t write_delay_ms; // 5-8ms
-    uint32_t    time_base;             // 从系统获得一个systick的毫秒数
-
-    uint8_t mode;      // polling 0 , it 1,  dma 2
-    uint8_t writeCplt;
-    uint8_t readCplt;
 
-    //  设置任务参数  发送一个 mem_addr++ send_buf++ size--
-    uint8_t *send_buf;       
-    uint16_t size;           
-    uint16_t mem_addr;       
-    uint8_t is_busy;
-    uint8_t error;
+extern I2C_HELPER_TypeDef *eeprom_helper;
 
-    HAL_I2C_StateTypeDef stat;
-}EEPROM_TypeDef;
-extern EEPROM_TypeDef *eeprom;
+typedef enum {
+   EEPROM_WORK_STATE_WAITING,
+   EEPROM_WORK_STATE_READY,
+   EEPROM_WORK_STATE_Writing,
+   EEPROM_WORK_STATE_WRITE_Waiting,
+   EEPROM_WORK_STATE_Reading,
+   EEPROM_WORK_STATE_ERROR,
+   EEPROM_WORK_STATE_STOP
+}EEPROM_WORK_STATE_TypeDef;
 
 typedef struct
 {
     void (*init)(void);
-    void (*deinit)(void);
     void (*port)(void) ;
+    int  (*test)(void);
+ 
     EEPROM_MODEL_TypeDef    model;       //  AT24C01  AT24C02  AT24C256
-    EEPROM_MEM_ADDR_TypeDef     mem_addr_type;     
-    // EEPROM_MEM_ADDR_BIT_TypeDef data_addr_bit;  
+    uint16_t     mem_addr_size;     
     EEPROM_DEV_ADDR_TypeDef     dev_addr;          
     uint8_t     page_addr;
+    uint8_t     write_delay_ms;
+        uint32_t size;
+    uint8_t *buf;
+    volatile EEPROM_WORK_STATE_TypeDef state;
 }My_EEPROM_TypeDef;
+
 extern My_EEPROM_TypeDef my_eeprom;
 
 void Eeprom_Init(  );
-void Eeprom_DeInit(  );
+
 void Eeprom_Port(  );
-int Eeprom_SET_I2CHelper( EEPROM_TypeDef *eeprom, I2CHelper_TypeDef *i2chelper );
-int Eeprom_SET_Device_Model( EEPROM_TypeDef *eeprom, EEPROM_MODEL_TypeDef model );
-int Eeprom_SET_Device_Addr( EEPROM_TypeDef *eeprom, uint8_t dev_addr );
-int Eeprom_SET_Mem_Addr ( EEPROM_TypeDef *eeprom, uint16_t mem_addr  );
-int Eeprom_SET_Mem_Addr_Type( EEPROM_TypeDef *eeprom, EEPROM_MEM_ADDR_TypeDef mem_addr_type );
-int Eeprom_SET_Mem_Addr_Bit_Type( EEPROM_TypeDef *eeprom, EEPROM_MEM_ADDR_BIT_TypeDef mem_addr_bit );
+void Eeprom_Task(  );
+int Eeprom_Test( void );
+
+int Eeprom_callback(My_EEPROM_TypeDef *pEeprom, uint8_t *buf, uint16_t size);
 
-int Eeprom_SET_WorkMode( EEPROM_TypeDef *eeprom, I2C_HELPER_MODE_TypeDef mem_addr_type);
-int Eeprom_SET_Write_Delay_ms( EEPROM_TypeDef *eeprom, uint8_t write_delay_ms);
+// int Eeprom_SET_WorkMode( uint16_t mem_addr_type);
+int Eeprom_SET_Device_Model(EEPROM_MODEL_TypeDef model);
+int Eeprom_SET_Write_Delay_ms(  uint8_t write_delay_ms);
 
 // int Eeprom_Transmit(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size);
 // int Eeprom_Begin_Rcv(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size);
 
-int Eeprom_Read(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size );
-// int Eeprom_Write(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size );
+int Eeprom_Read( uint8_t * buf, uint16_t size );
+int Eeprom_Write(  uint8_t * buf, uint16_t size );
 
-void Eeprom_Set_Sendbuf_Size(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size);
+// void Eeprom_Set_Sendbuf_Size(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size);
 
-int Eeprom_Test(  );
 
-#ifdef EEPROM_BYTE_DELAY_ENABLE
-int Eeprom_Write_By_Byte_Delay(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size);
-#endif
+// #ifdef EEPROM_BYTE_DELAY_ENABLE
+// int Eeprom_Write_By_Byte_Delay(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size);
+
+// int Eeprom_callback(My_EEPROM_TypeDef *pEeprom, uint8_t *buf, uint16_t size);
+
+// #endif
  
 #endif
 
  
 
+
+
+
 /**
+ * 
  * @brief 用非阻塞方法写 EEPROM  会写不进去--> 写数据到EEPROM,每个字节加5-8ms 延时
  * 还是用阻塞的方法区写， 读可以考虑非阻塞  -->  IT   DMA 
  * 不用 i2chelper  直接用hi2c,  
@@ -164,4 +160,17 @@ int Eeprom_Write_By_Byte_Delay(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t
 
     osDelay(10);
     log_i( "buf2  %d   %d ", buf2[0] , buf2[1]);
- */
+
+      uint8_t  buf1[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  buf2[24] ={0};
+    my_eeprom.buf =  buf1;
+    my_eeprom.size =  24;
+    my_eeprom.state =  EEPROM_WORK_STATE_Writing;
+
+    while(my_eeprom.size != 0) { osDelay(2);};
+    log_i("write ok....");
+
+    HAL_Delay(200);
+    my_eeprom.state =  EEPROM_WORK_STATE_Reading;     
+ */
+ 

device/Inc/i2c_helper.h

@@ -1,118 +0,0 @@
-#ifndef __I2C_HELPER_H
-#define __I2C_HELPER_H
-/**
-* 封装 Master模式  
-*/
-
-#ifdef __cplusplus
-	extern "C" {
-#endif
-
-#include "i2c.h"
-#include <stdlib.h>
-/*  回调函数，将数据返回上层 */
-typedef void (*it_callback)(void *obj,uint8_t *buf, uint32_t buf_size );
-
-/* 由于可能存在多个外设，考虑将 事件类型封装在helper, 事件定义初始化不必放这里*/
-typedef enum
-{
-   I2C_HELPER_Event_READY,                   /*!< Startup finished. */
-   I2C_HELPER_Event_INIT,                  
-   I2C_HELPER_Event_INIT_SUCCESS,                  
-   I2C_HELPER_Event_TRANS_ONLY,                  
-   I2C_HELPER_Event_TRANS_FOR_DATA,                 
-   I2C_HELPER_Event_DATA_RCV,                 
-} I2C_HELPER_Event_TypeDef;
-
-typedef enum 
-{
-	I2C_HELPER_TRANS_POLLING,
-	I2C_HELPER_TRANS_IT,
-	I2C_HELPER_TRANS_DMA
-}I2C_HELPER_TRANS_TypeDef;
-
-typedef enum 
-{
-	I2C_HELPER_RCV_POLLING,
-	I2C_HELPER_RCV_IT,
-	I2C_HELPER_RCV_DMA
-}I2C_HELPER_RCV_TypeDef;
-
-typedef enum 
-{
-	I2C_HELPER_MODE_MASTER,
-	I2C_HELPER_MODE_SLAVE
-}I2C_HELPER_MODE_TypeDef;
-
-typedef struct 
-{
-    I2C_HandleTypeDef *hi2c;
-	uint8_t i2c_write_address;
-	uint8_t i2c_read_address;
-	I2C_HELPER_TRANS_TypeDef trans_type;  /* 0 :polling, 1: IT  2: DMA*/
-    I2C_HELPER_RCV_TypeDef rcv_type;  /* 0 :polling, 1: IT  2: DMA*/
-	I2C_HELPER_MODE_TypeDef mode;   
-
-    uint8_t *trans_buf;
-    volatile uint32_t trans_size;
-    volatile uint32_t trans_data_con;
-
-    uint8_t *receive_buf;
-    volatile uint32_t receive_size;
-    volatile uint8_t receive_data_con;
- 
-    // volatile uint8_t receive_buf_con;
-    // uint32_t receive_buf_half_len;
-    // uint8_t half_flag;  /*0 : 未半满， 1：半满， 2： 半满已经处理*/
-
-    // volatile Uart_Status_TypeDef status;  /* 发送状态 0: ready , 1：正在发送 busy，2：发送ok，*/
-
-    void * obj;
-    it_callback callback;
-
-
-}I2CHelper_TypeDef;
-
-I2CHelper_TypeDef * I2CHelper_Init( );
-void I2CHelper_Set_Hi2c( I2CHelper_TypeDef *i2chelper,  I2C_HandleTypeDef * hi2c  );
-void I2CHelper_Set_Mode( I2CHelper_TypeDef *i2chelper,  I2C_HELPER_MODE_TypeDef mode  );
-void I2CHelper_Set_Trans_Type( I2CHelper_TypeDef *i2chelper,  I2C_HELPER_TRANS_TypeDef trans_type  );
-void I2CHelper_Set_Rcv_Type( I2CHelper_TypeDef *i2chelper,  I2C_HELPER_RCV_TypeDef rcv_type  );
- 
-// void I2CHelper_Set_timeout( I2CHelper_TypeDef *i2chelper,  uint32_t timeout_ms  );
-
-int I2CHelper_Set_callback_func_obj( I2CHelper_TypeDef *i2chelper,   void * obj,  it_callback callback );
-
-void I2CHelper_Set_rcv_buf( I2CHelper_TypeDef *i2chelper, uint8_t *buf, uint32_t buf_size );
-void I2CHelper_Set_Trans_Buf( I2CHelper_TypeDef *i2chelper, uint8_t *buf, uint32_t buf_size );
-
-int I2CHelper_Write( I2CHelper_TypeDef *i2chelper,  uint8_t * buf, uint16_t size);
-int I2CHelper_Read(I2CHelper_TypeDef *i2chelper,  uint8_t * buf, uint16_t size);
-
-void I2CHelper_Snd_Cplt_Callback(   );
-void I2CHelper_Rcv_Cplt_Callback(   );
-
-// int I2CHelper_Flags_Set(I2CHelper_TypeDef *i2chelper,  I2C_HELPER_Event_TypeDef evt_type );
-// int I2CHelper_Flags_Clear(I2CHelper_TypeDef *i2chelper,  I2C_HELPER_Event_TypeDef evt_type );
-// int I2CHelper_Flags_Wait(I2CHelper_TypeDef *i2chelper,  I2C_HELPER_Event_TypeDef evt_type );
-
-
-// void I2CHelper_Set_GPIO_For_Trans_Cplt(  I2CHelper_TypeDef *i2chelper );
-// void I2CHelper_Rcv_Cplt_Callback( I2CHelper_TypeDef *i2chelper  );
-// void I2CHelper_Rcv_Idle_Callback( I2CHelper_TypeDef *i2chelper  );
-// void I2CHelper_Rcv_DMA_Half_Callback( I2CHelper_TypeDef *i2chelper  );
-
-int I2CHelper_copy( I2CHelper_TypeDef *i2chelper, uint8_t *buf, uint32_t buf_size );
-int I2CHelper_isbusy( I2CHelper_TypeDef *i2chelper );
-void I2CHelper_error( I2CHelper_TypeDef *i2chelper );
- 
-
-// uint16_t Get_Crc16(const char *buf, uint16_t len);
-// uint8_t Check_Crc16(uint8_t *buf, uint16_t length); 
-#ifdef __cplusplus
-	}
-#endif
-
-#endif
-
- 

device/Inc/oscar.h

@@ -1,228 +1,190 @@
-#ifndef __Oscar_H
-#define __Oscar_H
+/*
+加入队列 处理
+*/
+#ifndef __OSCAR__H
+#define __OSCAR__H
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
 
-#include <string.h>
-#include "uart_helper.h"
-#include "uart_interface.h"
-// #include "config.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "main.h"
+#include "cmsis_os.h"
+#include "usart.h"
+ 
+#include "elog.h"
 
-#define  Oscar_DEMO           1  /*sn 读取位置不一样*/
-#define  Oscar_Rcv_Buf_Size   (3+244+2) 
-#define  Oscar_Command_Number       2
-
-#define Oscar_FLAG_MASK_BUSY ((uint32_t)1<<(uint32_t)0)
-#define Oscar_FLAG_MASK_RECVED_SN ((uint32_t)1<<(uint32_t)1)
-#define Oscar_FLAG_MASK_RECVED_WL ((uint32_t)1<<(uint32_t)2)
-#define Oscar_FLAG_MASK_RECVED_DATA ((uint32_t)1<<(uint32_t)3)
-// #define Oscar_FLAG_MASK_RECVED_WL_1 ((uint32_t)1<<(uint32_t)3)
-// #define Oscar_FLAG_MASK_RECVED_DATA_0 ((uint32_t)1<<(uint32_t)4)
-// #define Oscar_FLAG_MASK_RECVED_DATA_1 ((uint32_t)1<<(uint32_t)5)
+
+#include <string.h>
+#include "bsp_uart.h"
+ 
+#define Oscar_USE_MAX485 0
+#define Oscar_USE_MAX3160_232 0
+#define Oscar_USE_MAX3160_485 1
  
+#define  Oscar_Rcv_Buf_Size   (3+244+2) 
+// #define  Oscar_Command_Number       1
+
+static void Oscar_MAX3160_232(void) 
+{
+  HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, RESET);
+  HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET);
+}
 
 typedef enum 
 {
-    MODULE_Oscar_STATE_WAIT,
-    MODULE_Oscar_STATE_START,
-    MODULE_Oscar_STATE_GET_SN,
-    MODULE_Oscar_STATE_CHECK_SN,
-    MODULE_Oscar_STATE_GET_WL_0,
-    MODULE_Oscar_STATE_GET_WL_1,
-    MODULE_Oscar_STATE_CHECK_WL,
-    MODULE_Oscar_STATE_Ready_GET_DATA,
-    MODULE_Oscar_STATE_START_DATA,
-    MODULE_Oscar_STATE_GET_DATA_0,
-    MODULE_Oscar_STATE_GET_DATA_1,
-    MODULE_Oscar_STATE_CHECK_DATA,
-    MODULE_Oscar_STATE_OK,
-    MODULE_Oscar_STATE_ERROR,
-    MODULE_Oscar_STATE_STOP
-} MODULE_Oscar_WORK_STATE;
+  Oscar_Event_Ready ,
+  Oscar_Event_Test,
+  Oscar_Event_Test_OK  ,
+  Oscar_Event_Get_Data,
+  Oscar_Event_Check_Data  ,
+} Module_Oscar_Event_TypeDef;
 
+typedef enum 
+{
+  Oscar_State_Waiting  ,
+  Oscar_State_Test ,
+  Oscar_State_Test_Start ,
+  Oscar_State_SN_Getting ,
+  Oscar_State_SN_OK ,
+  Oscar_State_Ready  ,
+  Oscar_State_Get_WAVELENGTH  ,
+//   Oscar_State_Get_WAVELENGTH_Wait  ,
+//   Oscar_State_Get_WAVELENGTH_OK,
+//   Oscar_State_Get_WAVELENGTH_Check  ,
+  Oscar_State_Get_DATA  ,
+  Oscar_State_Get_DATA_Trans,
+  Oscar_State_Get_DATA_Wait  ,
+  Oscar_State_Get_DATA_OK,
+  Oscar_State_Get_DATA_Check  ,
+  Oscar_State_Get_Queue_MSG  ,
+  Oscar_State_Stop ,
+  Oscar_State_Timeout ,
+  Oscar_State_Error   ,
+} Module_Oscar_State_TypeDef;
+
+extern UART_HELPER_TypeDef *Oscar_uart_helper;
 typedef struct 
 {
-	  UartHelper_TypeDef *uarthelper;
-    volatile MODULE_Oscar_WORK_STATE state;
-
-    volatile uint8_t flag;     /* Oscar_FLAG_MASK_ SN WL1 WL2  DATA1  DATA2 ，*/
-    volatile uint8_t send_flag;  		/* 发送标志位 */
-    volatile Uart_Status_TypeDef send_status;  /* 发送状态 1：正在发送 busy，0：发送ok，*/
-    volatile Uart_Status_TypeDef status;  /* 发送状态 0: ready , 1：正在发送 busy，2：发送ok，*/
-
-    uint8_t interface_type; /* 0: common, 1: 485 ,2:3160*/
-    uint8_t *send_buf;
-    uint16_t size_send;
-    uint8_t *rcv_buf;
-    uint16_t size_rcv;
-
+    int (*init)(void);
+    void (*port)(void);
+    int (*test)(void);
+    void (*start)(void);
+    void (*stop)(void);
 
-	  uint8_t mode_232_485; /* 0: common, 1: 485  */
-    uint8_t trans_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t rcv_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t idle_enable_disable;    /* 0 不开启空闲中断 ， 1 开启空闲中断 */
-	  uint8_t trans_mode;         /* 0 :polling, 1: IT  2: DMA*/
+    osMessageQueueId_t transQueue;  // 队列可选
 
-    volatile uint8_t step;             /* 0 : normal , 1 : get wavelength ,  2 : get sn   3: 空*/
-    volatile uint8_t command_seq ;      /* 命令序号 */
-
-    uint16_t sn;
-
-    uint8_t sn_buf[15];
-    uint8_t Oscar_Wavelength_Buf[2][ Oscar_Rcv_Buf_Size ];
-    uint8_t Oscar_Data_Buf[2][ Oscar_Rcv_Buf_Size ];
-
-    // uint8_t rcv_ok;                 /* 接收数据完整可以处理 */
-    // uint8_t data_begin_flag;                 /* 接收数据完整可以处理 */
-    uint8_t error;                 /* 接收数据完整可以处理 */
+    volatile Module_Oscar_State_TypeDef state; 
     uint8_t data_ok;                 /* 接收数据完整可以处理 */
-    volatile uint16_t size_received;                  
 
-    uint64_t timebase;
-    uint64_t timeout_ms;
-    uint64_t timeout_enable;
-
-}Oscar_TypeDef;
+    uint8_t result_buf[1024];
+    uint16_t size_received;
 
-extern Oscar_TypeDef *oscar ;
-
-uint8_t Oscar_Init(   );
-
-void Oscar_Set_Uarthelper(Oscar_TypeDef *oscar, UartHelper_TypeDef *uarthelper);
-void Oscar_Set_Interface(Oscar_TypeDef *oscar, UartInterface_TypeDef *interface);
-
-void Oscar_Set_Huart( Oscar_TypeDef * oscar,  UART_HandleTypeDef * huart  );
-void Oscar_Set_RsMode_232_485( Oscar_TypeDef * oscar,  Uart_RS_Mode_TypeDef rs_232_485  );
-
-void Oscar_Set_Trans_Type( Oscar_TypeDef *oscar,  Uart_Transmode_TypeDef trans_type  );
-void Oscar_Set_Rcv_Type( Oscar_TypeDef *oscar,  Uart_Transmode_TypeDef rcv_type  );
-void Oscar_Set_Idle_Enable( Oscar_TypeDef *oscar,  Uart_IDLE_Enable_TypeDef idle_enable_disable  );
-void Oscar_Set_TransMode( Oscar_TypeDef *oscar,  Uart_Transmode_TypeDef trans_mode  );
- 
-void Oscar_Set_Timeout( Oscar_TypeDef *oscar,    uint16_t timeout_ms );
-void Oscar_Set_Sendbuf( Oscar_TypeDef *oscar,  uint8_t * buf, uint16_t size );
-void Oscar_Set_Rcvbuf( Oscar_TypeDef *oscar,  uint8_t * buf, uint16_t size );
+    uint64_t  timebase_ticks;
+    uint64_t  timeout_ticks;
 
+    uint8_t		event_flag;
+	uint8_t		wavelength_ok;
 
+    Record_Trans_Rcv_TypeDef transRecord[3];
 
+    uint8_t oscarsn_buf[15];
+    uint8_t Oscar_Wavelength_Buf[3][ Oscar_Rcv_Buf_Size ];
+    uint8_t Oscar_Data_Buf[3][ Oscar_Rcv_Buf_Size ];
 
+}Oscar_TypeDef;
 
-void Oscar_Set_Timeout( Oscar_TypeDef * oscar,    uint16_t timeout_ms );
+extern Oscar_TypeDef oscar ;
 
-// void Oscar_Set_Sendbuf( Oscar_TypeDef * oscar,  uint8_t * buf, uint16_t size );
-// void Oscar_Set_Rcvbuf( Oscar_TypeDef * oscar,  uint8_t * buf, uint16_t size );
+int Oscar_Init( void );
+void Oscar_Task( void);
+void Oscar_Port( void);
+int Oscar_Test( );
+void Oscar_Start( );
+void Oscar_Stop( );
 
-int Oscar_Get_Timeout( Oscar_TypeDef * oscar );
+void Oscar_Wavelength( );
 
-int Oscar_Transmit( Oscar_TypeDef * oscar,  uint8_t * buf, uint16_t size );
-int Oscar_Begin_Rcv( Oscar_TypeDef * oscar,  uint8_t * buf, uint16_t size );
+void Oscar_Set_Sendbuf(   uint8_t * buf, uint16_t size );
+void Oscar_Set_Rcvbuf(   uint8_t * buf, uint16_t size );
+void Oscar_Set_Timeout_ms(    uint64_t ms_ticks );
+int Oscar_Validate(   );
 
-int Oscar_Set_UartHelper_Status( Oscar_TypeDef * oscar  ,Uart_Status_TypeDef status);
-Uart_Status_TypeDef Oscar_Get_UartHelper_Status( Oscar_TypeDef * oscar  );
- 
 
-int  Oscar_Get_Data_OK(Oscar_TypeDef * oscar   );
-void Oscar_Set_Send_Flag(  Oscar_TypeDef * oscar );
+int Oscar_Transmit();
+int Oscar_Receive();
 
-void Oscar_callback( Oscar_TypeDef * oscar,  uint8_t * buf, uint16_t size );
-void Oscar_Set_GPIO_For_TC_Cplt( Oscar_TypeDef * oscar );
+void Oscar_Trans_GPIO(void) ;
 
-void Oscar_clean_flag(Oscar_TypeDef * oscar,uint8_t mask);
-uint8_t Oscar_get_flag(Oscar_TypeDef * oscar,uint8_t mask);
+void Oscar_Trans_Cplt_GPIO(void) ;
 
-uint16_t Oscar_get_serial_number(Oscar_TypeDef * oscar );
+int Oscar_CallBack( Oscar_TypeDef *pOscar , uint8_t *buf, uint16_t size );
 
-// int Oscar_copy(uint8_t *targer_buf, uint8_t *src_buf,uint32_t buf_size);
-int Oscar_copy(Oscar_TypeDef * oscar ,uint16_t size);
-void Oscar_Error( Oscar_TypeDef * oscar, char* str );
- 
-// MODULE_Oscar_WORK_STATE Set_State( MODULE_Oscar_WORK_STATE state );
-void Oscar_Set_State( MODULE_Oscar_WORK_STATE state  );
-int Oscar_Init_Ok();
- 
-
-// extern void Oscar_Setup(    );
-extern void Oscar_Port( );
-void Oscar_Task( void* argument);
- 
-/* 再封装演示 */ 
-typedef struct 
-{
-	uint8_t (*init)( );			 
-	void (*port)(void);	
-  void  (*Set_State)(MODULE_Oscar_WORK_STATE state );
-  // MODULE_Oscar_WORK_STATE  (*Set_State)( MODULE_Oscar_WORK_STATE state );
-
-    GPIO_TypeDef *sel_gpio;	 
-    GPIO_TypeDef *dplx_gpio;	 
-    GPIO_TypeDef *de_gpio;	 
-    uint16_t sel_pin;
-    uint16_t dplx_pin;
-    uint16_t de_pin;
-
-    Uart_Interface_Type_Typedef interface_type; /* 0: default(ttl 232), 1: 485 ,2:3160*/
-    Uart_RS_Mode_TypeDef mode_232_485;       /* 0 commome  1:485*/
-    Uart_Transmode_TypeDef trans_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_Transmode_TypeDef rcv_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_IDLE_Enable_TypeDef idle_enable_disable;     /* 0 :不启用空闲 , 1: 启用空闲*/
- 
-    Oscar_TypeDef *oscar; /*不是常量  不能直接初始化*/
-
-}My_Oscar_TypeDef;
-extern My_Oscar_TypeDef myoscar;
 
+#ifdef __cplusplus
+	}
+#endif
 #endif
 
-/**
- * 调用  
- * init:  Oscar_Setup( );  Oscar_SN( );  Oscar_Wavelength( );
- * call:  Oscar_Port( ); 
- * 
- * sn 波长部分，？？ 单独拉出来初始化，然后任务， 还是一起放任务里头？
- * 多个任务放一个统一开始的开关？ 用一个字节的多个位表示？
- * @register:  viper
-    DataBeginAddress: 2614
-    SNAddress: 2980,10
-    SNLen: 5
-    WLBeginAddress: 2102
-    count: 3
-    functioncode: 3
-    slaveaddress: 1
-    122   122*4+5  = 493
-
-  wl:
-    01 03 08 36 00 7A 26 47    (2102  122)
-    01 03 08 B0 00 7A C7 AE    (2224  122)
-    01 03 09 2A 00 7A E6 7D    (2346  122)
-
-  data: 
-    01 03 0A 36 00 7A 27 FF    (2614  122)
-    01 03 0A B0 00 7A C6 16    (2736  122)
-    01 03 0B 2A 00 7A E7 C5    (2758  122)
-
-  01 03 0B A4 00 05 C6 0E    (SN  2980 5  demo)
-  01 03 00 0A 00 05 A5 CB    (SN  10   5   实际)
- * 
- */
-
-/**
- * @register:   viper
-    DataBeginAddress: 2614
-    SNAddress: 2840
-    SNLen: 5
-    WLBeginAddress: 2102
-    count: 2
-    functioncode: 3
-    slaveaddress: 1
-    wl:
-    01 03 08 36 00 7A 26 47    (2102  122)
-    01 03 08 B0 00 7A C7 AE    (2224  122)
- 
-
-  data: 
-    01 03 0A 36 00 7A 27 FF    (2614  122)
-    01 03 0A B0 00 7A C6 16    (2736  122)
- 
 
-    01 03 0B 18 00 05 07 EA    (SN  2840 5  demo)
-    01 03 00 0A 00 05 A5 CB    (SN  10 5   实际)
- * 
- */
+/*
+    temp.init();
+    temp.port();
+    temp.test();
+
+    uint64_t ticks = osKernelGetTickCount();
+
+    while ( temp.state != PH_State_Ready )
+    {
+        if ( ( osKernelGetTickCount() -ticks) > 3000 )
+        {
+            log_e(" pH test error.... ") ;
+            break;
+        }
+    }
+    log_w(" pH test ok.... ") ;
+
+
+// osMessageQueueId_t TestQQueueueueHandle;
+// 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,
+// void *  msg_ptr,       //储存读取结果的变量地址
+// uint8_t *  msg_prio,  // ==NULL
+// uint32_t  timeout    //阻塞超时时间
+// );
+// osStatus_t osMessageQueuePut ( osMessageQueueId_t  mq_id,
+// const void *  msg_ptr,     //储存写入内容的变量地址
+// uint8_t  msg_prio,        //==0U
+// uint32_t  timeout         //阻塞超时时间
+// );
+
+
+// uint8_t Oscar_SN_command[8] = {0x01, 0x03, 0x00, 0x0A, 0x00, 0x05, 0xA5, 0xCB};
+
+// uint8_t Oscar_Wavelength_sendbuf[3][8]   = {
+//         
+//         // 01 03 08 36 00 7A 26 47    (2102  122)
+//         // 01 03 08 B0 00 7A C7 AE    (2224  122)
+//         // 01 03 09 2A 00 7A E6 7D    (2346  122)
+//         
+//         { 0x01, 0x03, 0x08, 0x36, 0x00, 0x7A, 0x26, 0x47 },
+//         { 0x01, 0x03, 0x08, 0xB0, 0x00, 0x7A, 0xC7, 0xAE },
+//         { 0x01, 0x03, 0x09, 0x2A, 0x00, 0x7A, 0xE6, 0x7D }
+//     };
+// uint8_t Oscar_Data_sendbuf[3][8]   = {
+//         
+//         //01 03 0A 36 00 7A 27 FF    (2614  122)
+//         //01 03 0A B0 00 7A C6 16    (2736  122)
+//         //01 03 0B 2A 00 7A E7 C5    (2858  122)
+//         
+//         { 0x01, 0x03, 0x0A, 0x36, 0x00, 0x7A, 0x27, 0xFF },
+//         { 0x01, 0x03, 0x0A, 0xB0, 0x00, 0x7A, 0xC6, 0x16 },
+//         { 0x01, 0x03, 0x0B, 0x2A, 0x00, 0x7A, 0xE7, 0xC5 }
+//     };
+// uint8_t Oscar_sn_buf[15] = {0};
+
+
+*/

device/Inc/pH.h

@@ -5,154 +5,135 @@
 	extern "C" {
 #endif
 
-
-
 #include "FreeRTOS.h"
 #include "task.h"
 #include "main.h"
 #include "cmsis_os.h"
 #include "usart.h"
- 
- 
-#include "elog.h"
 
-#ifdef __cplusplus
-	extern "C" {
-#endif
+#include "elog.h"
 
 #include <string.h>
-#include "uart_helper.h"
-#include "uart_interface.h"
-// #include "config.h"
+#include "bsp_uart.h"
+ 
+#define PH_USE_MAX485 0
+#define PH_USE_MAX3160_232 0
+#define PH_USE_MAX3160_485 1
  
 #define  PH_Rcv_Buf_Size   9
 #define  PH_Command_Number       1
 
+static void PH_MAX3160_232(void) 
+{
+    HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, RESET);
+    HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET);
+}
+
+
+
 typedef enum 
 {
-  PH_Status_Waiting  ,
-  PH_Status_Ready  ,
-  PH_Status_Sending ,
-  PH_Status_Send_Cplt  ,
-  PH_Status_RCV_OK  ,
-  PH_Status_DATA_OK  ,
-  PH_Status_Timeout ,
-  PH_Status_Error   ,
-} PH_Status_TypeDef;
+  PH_Event_Ready ,
+  PH_Event_Test,
+  PH_Event_Test_OK  ,
+  PH_Event_Get_Data,
+  PH_Event_Check_Data  ,
+} Module_PH_Event_TypeDef;
 
+typedef enum 
+{
+  PH_State_Waiting  ,
+  PH_State_Test ,
+  PH_State_Test_Start ,
+  PH_State_Testing ,
+  PH_State_Test_OK ,
+  PH_State_Ready  ,
+  PH_State_Get_DATA  ,
+  PH_State_Get_DATA_Wait  ,
+  PH_State_Get_DATA_OK,
+  PH_Statee_Get_DATA_Check  ,
+  PH_State_Stop ,
+  PH_State_Timeout ,
+  PH_State_Error   ,
+} Module_PH_State_TypeDef;
+
+extern UART_HELPER_TypeDef *ph_uart_helper;
 typedef struct 
 {
-	UartHelper_TypeDef *uarthelper;
-    // UART_HandleTypeDef *huart;
-    uint8_t interface_type; /* 0: common, 1: 485 ,2:3160*/
-	uint8_t *send_buf;
-	uint16_t size_send;
-	uint8_t *rcv_buf;
-	uint16_t size_rcv;
-
-           
-	uint8_t mode_232_485; /* 0: common, 1: 485  */
-    uint8_t trans_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t rcv_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t idle_enable_disable;    /* 0 不开启空闲中断 ， 1 开启空闲中断 */
-	uint8_t trans_mode;         /* 0 :polling, 1: IT  2: DMA*/
-
-	uint64_t timebase;
-	uint16_t timeout_ms;
-	volatile uint8_t send_flag;  		/* 发送标志位 */
-	Uart_Status_TypeDef send_status;  /* 发送状态 1：正在发送 busy，0：发送ok，*/
-	Uart_Status_TypeDef status;  /* 发送状态 1：正在发送 busy，0：发送ok，*/
-
-    uint8_t command_seq ;      /* 命令序号 */
-    uint8_t mode;  /* 0 : normal , 1 : get wavelength ,  2 : get sn  */
-
-    uint8_t vipersn_buf[15];
-    uint8_t PH_Wavelength_Buf[2][ PH_Rcv_Buf_Size ];
-    uint8_t PH_Data_Buf[2][ PH_Rcv_Buf_Size ];
-
-    uint8_t rcv_ok;                 /* 接收数据完整可以处理 */
-    uint8_t data_begin_flag;                 /* 接收数据完整可以处理 */
+    int (*init)(void);
+    void (*port)(void);
+    int (*test)(void);
+    void (*start)(void);
+    void (*stop)(void);
+    osMessageQueueId_t cmdQueue;  // 队列可选
+
+    volatile Module_PH_State_TypeDef state; 
     uint8_t data_ok;                 /* 接收数据完整可以处理 */
 
-    volatile PH_Status_TypeDef state;
+    uint8_t result_buf[1024];
+    uint8_t size_received;
+
+    uint64_t  timebase_ticks;
+    uint64_t  timeout_ticks;
+    uint8_t  event_flag;
 
-	// int (*Init)(void);			//初始化触摸屏控制器
-	// // uint8_t (*Setup)( );				//扫描触摸屏.0,屏幕扫描;1,物理坐标;	 
-	// uint8_t (*Port)( );				//扫描触摸屏.0,屏幕扫描;1,物理坐标;	 
+    // uint8_t command_seq ;      /* 命令序号 */
+    // uint8_t mode;  /* 0 : normal , 1 : get wavelength ,  2 : get sn  */
 
+    // uint8_t vipersn_buf[15];
+    // uint8_t PH_Wavelength_Buf[2][ PH_Rcv_Buf_Size ];
+    // uint8_t PH_Data_Buf[2][ PH_Rcv_Buf_Size ];
 
 }PH_TypeDef;
 
-extern PH_TypeDef *ph ;
+extern PH_TypeDef ph ;
 
-int PH_Init(   );
+int PH_Init( void );
+void PH_Task( void);
+void PH_Port( void);
 int PH_Test( );
 void PH_Start( );
 void PH_Stop( );
 
-void PH_Set_Uarthelper( PH_TypeDef *ph,  UartHelper_TypeDef * uarthelper );
-void PH_Set_Interface( PH_TypeDef *ph,  UartInterface_TypeDef * interface  );
-void PH_Set_Huart( PH_TypeDef *ph,  UART_HandleTypeDef * huart  );
-void PH_Set_Interface_Type( PH_TypeDef *ph,   Uart_Interface_Type_Typedef interface_type  );
-void PH_Set_Trans_Type( PH_TypeDef *ph,  Uart_Transmode_TypeDef trans_type  );
-void PH_Set_Rcv_Type( PH_TypeDef *ph,  Uart_Transmode_TypeDef rcv_type  );
-void PH_Set_Idle_Enable( PH_TypeDef *ph,  Uart_IDLE_Enable_TypeDef idle_enable_disable  );
-void PH_Set_TransMode( PH_TypeDef *ph,  Uart_Transmode_TypeDef trans_mode  );
-void PH_Set_RsMode_232_485( PH_TypeDef *ph,  Uart_RS_Mode_TypeDef rs_232_485  );
-void PH_Set_Timeout( PH_TypeDef *ph,    uint16_t timeout_ms );
-void PH_Set_Sendbuf( PH_TypeDef *ph,  uint8_t * buf, uint16_t size );
-void PH_Set_Rcvbuf( PH_TypeDef *ph,  uint8_t * buf, uint16_t size );
+void PH_Set_Sendbuf(   uint8_t * buf, uint16_t size );
+void PH_Set_Rcvbuf(   uint8_t * buf, uint16_t size );
+void PH_Set_Timeout_ms(    uint64_t ms_ticks );
+int PH_Validate(   );
 
-int PH_Transmit( PH_TypeDef *ph,  uint8_t * buf, uint16_t size);
 
+int PH_Transmit();
+int PH_Receive();
 
-void PH_Begin_Rcv(PH_TypeDef *ph,  uint8_t * buf, uint16_t size);
+void PH_Trans_GPIO(void) ;
 
-extern  void PH_Rcv_Cplt_Callback( PH_TypeDef *ph  );
-extern  void PH_Send_Cplt_Callback(  PH_TypeDef *ph );
+void PH_Trans_Cplt_GPIO(void) ;
 
-int  PH_Get_Data_OK(PH_TypeDef *ph   );
-void PH_Set_Send_Flag(  PH_TypeDef *ph );
+int PH_CallBack( PH_TypeDef *pPH, uint8_t *buf, uint16_t size );
 
-// extern void PH_Setup(    );
-extern void PH_Port( );
-// extern void PH_SN( );
-// extern void PH_Wavelength( );
-void PH_Task( );
  
-/* 再封装演示 */ 
-typedef struct 
-{
-	uint8_t (*init)( );			 
-	uint8_t (*port)(void);	
-	int (*test)(void);
-	void (*start)(void);
-	int (*stop)(void);
-    				//扫描触摸屏.0,屏幕扫描;1,物理坐标;	 
-    GPIO_TypeDef *sel_gpio;	 
-    GPIO_TypeDef *dplx_gpio;	 
-    GPIO_TypeDef *de_gpio;	 
-    uint16_t sel_pin;
-    uint16_t dplx_pin;
-    uint16_t de_pin;
-
-    Uart_Interface_Type_Typedef interface_type; /* 0: common, 1: 485 ,2:3160*/
-    Uart_RS_Mode_TypeDef mode_232_485;       /* 0 commome  1:485*/
-    Uart_Transmode_TypeDef trans_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_Transmode_TypeDef rcv_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_IDLE_Enable_TypeDef idle_enable_disable;     /* 0 :不启用空闲 , 1: 启用空闲*/
-
-    uint16_t ph_val;
-    uint16_t temp_val;
-    PH_TypeDef *ph; /*不是常量  不能直接初始化*/
-
-
-}My_PH_TypeDef;
-extern My_PH_TypeDef my_pH ;
-
  
 
 #ifdef __cplusplus
 	}
 #endif
 #endif
+
+
+/*
+    ph.init();
+    ph.port();
+    ph.test();
+
+    // uint64_t ticks = osKernelGetTickCount();
+
+    // while ( ph.state != PH_State_Ready )
+    // {
+    //     if ( ( osKernelGetTickCount() -ticks) > 5000   )
+    //     {
+    //         log_e(" pH test error.... %d", ph.state) ;
+    //         break;
+    //     }
+    // }
+    osDelay(1000);
+    log_w(" pH test ok.... %d", ph.state) ;
+*/

device/Inc/sc6.h

@@ -1,220 +1,138 @@
-#ifndef __SC6_H
-#define __SC6_H
+#ifndef __SC6__H
+#define __SC6__H
 
-#include <string.h>
-#include "uart_helper.h"
-#include "uart_interface.h"
-// #include "config.h"
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "main.h"
+#include "cmsis_os.h"
+#include "usart.h"
 
-#define  SC6_DEMO           1  /*sn 读取位置不一样*/
+#include "elog.h"
+
+#include <string.h>
+#include "bsp_uart.h"
+ 
+#define SC6_USE_MAX485 0
+#define SC6_USE_MAX3160_232 0
+#define SC6_USE_MAX3160_485 1
+ 
 #define  SC6_RESUMED_Buf_Size   (12) 
 #define  SC6_PAUSEED_Buf_Size   (11) 
-#define  SC6_Result_Buf_Size       (286 ) 
+#define  SC6_Result_Buf_Size    (286 ) 
 #define  SC6_Rcv_Buf_Size       (2*SC6_Result_Buf_Size +2*SC6_RESUMED_Buf_Size ) 
 #define  SC6_Command_Number       2
 
-#define SC6_FLAG_MASK_BUSY ((uint32_t)1<<(uint32_t)0)
-#define SC6_FLAG_MASK_RECVED_DATA ((uint32_t)1<<(uint32_t)1)
-// #define SC6_FLAG_MASK_RECVED_WL_1 ((uint32_t)1<<(uint32_t)3)
-// #define SC6_FLAG_MASK_RECVED_DATA_0 ((uint32_t)1<<(uint32_t)4)
-// #define SC6_FLAG_MASK_RECVED_DATA_1 ((uint32_t)1<<(uint32_t)5)
- 
+static void SC6_MAX3160_232(void) 
+{
+    HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, RESET);
+    HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET);
+}
 
 typedef enum 
 {
-    MODULE_SC6_STATE_WAIT,
-    MODULE_SC6_STATE_START,
-    MODULE_SC6_STATE_CHECK_DATA,
-    MODULE_SC6_STATE_OK,
-    MODULE_SC6_STATE_ERROR,
-    MODULE_SC6_STATE_STOP
-} MODULE_SC6_WORK_STATE;
+	SC6_Event_Ready ,
+	SC6_Event_Test,
+	SC6_Event_Test_OK  ,
+	SC6_Event_Get_Data,
+	SC6_Event_Check_Data  ,
+} Module_SC6_Event_TypeDef;
 
+typedef enum 
+{
+    SC6_State_Waiting,
+    SC6_State_Test,
+	SC6_State_Test_Data_Getting,
+	SC6_State_Test_OK,
+	SC6_State_Ready,
+    SC6_State_Start,
+    SC6_State_Start_Trans,
+    SC6_State_Data_Getting,
+    SC6_State_Check_Data,
+    SC6_State_OK,
+	SC6_State_Stop ,
+	SC6_State_Timeout ,
+	SC6_State_Error   ,
+} Module_SC6_State_TypeDef;
+
+extern UART_HELPER_TypeDef *SC6_uart_helper;
 typedef struct 
 {
-	  UartHelper_TypeDef *uarthelper;
-    volatile MODULE_SC6_WORK_STATE state;
-
-    volatile uint8_t flag;     /* SC6_FLAG_MASK_ SN WL1 WL2  DATA1  DATA2 ，*/
-    volatile uint8_t send_flag;  		/* 发送标志位 */
-    volatile Uart_Status_TypeDef send_status;  /* 发送状态 1：正在发送 busy，0：发送ok，*/
-    volatile Uart_Status_TypeDef status;  /* 发送状态 0: ready , 1：正在发送 busy，2：发送ok，*/
-
-    uint8_t interface_type; /* 0: common, 1: 485 ,2:3160*/
-    uint8_t *send_buf;
-    uint16_t size_send;
-    uint8_t *rcv_buf;
-    uint16_t size_rcv;
-
-
-	  uint8_t mode_232_485; /* 0: common, 1: 485  */
-    uint8_t trans_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t rcv_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t idle_enable_disable;    /* 0 不开启空闲中断 ， 1 开启空闲中断 */
-	  uint8_t trans_mode;         /* 0 :polling, 1: IT  2: DMA*/
+    int (*init)(void);
+    void (*port)(void);
+    int (*test)(void);
+    void (*start)(void);
+    void (*stop)(void);
+    osMessageQueueId_t cmdQueue;  // 队列可选
+
+    volatile Module_SC6_State_TypeDef state; 
+    uint8_t data_ok;                 /* 接收数据完整可以处理 */
 
-    volatile uint8_t step;             /* 0 : normal , 1 : get wavelength ,  2 : get sn   3: 空*/
-    volatile uint8_t command_seq ;      /* 命令序号 */
+    uint8_t result_buf[1024];
+    uint16_t size_received;
 
-    // uint16_t sn;
+    uint64_t  timebase_ticks;
+    uint64_t  timeout_ticks;
+    uint8_t  event_flag;
 
-    uint16_t sn_buf[4];
+    uint8_t	SC6_sn_buf[4];
     uint8_t SC6_Result_Buf[ SC6_Rcv_Buf_Size ];
     uint8_t SC6_Data_Buf[ SC6_Rcv_Buf_Size ];
-    // uint8_t rcv_ok;                 /* 接收数据完整可以处理 */
-    // uint8_t data_begin_flag;                 /* 接收数据完整可以处理 */
-    uint8_t error;                 /* 接收数据完整可以处理 */
-    uint16_t index_SC6_LPT;
-    uint8_t data_ok;                 /* 接收数据完整可以处理 */
-    volatile uint16_t size_received;                 
-
-    uint64_t timebase;
-    uint64_t timeout_ms;
-    uint64_t timeout_enable;
+	uint16_t index_SC6_LPT;  // 记录出现开始标记的位置
 
 }SC6_TypeDef;
 
-extern SC6_TypeDef *sc6 ;
-
-uint8_t SC6_Init(   );
-
-void SC6_Set_Uarthelper(SC6_TypeDef *sc6, UartHelper_TypeDef *uarthelper);
-void SC6_Set_Interface(SC6_TypeDef *sc6, UartInterface_TypeDef *interface);
+extern SC6_TypeDef sc6 ;
 
-void SC6_Set_Huart( SC6_TypeDef * sc6,  UART_HandleTypeDef * huart  );
-void SC6_Set_RsMode_232_485( SC6_TypeDef * sc6,  Uart_RS_Mode_TypeDef rs_232_485  );
+int SC6_Init( void );
+void SC6_Task( void);
+void SC6_Port( void);
+int SC6_Test( );
+void SC6_Start( );
+void SC6_Stop( );
 
-void SC6_Set_Trans_Type( SC6_TypeDef *sc6,  Uart_Transmode_TypeDef trans_type  );
-void SC6_Set_Rcv_Type( SC6_TypeDef *sc6,  Uart_Transmode_TypeDef rcv_type  );
-void SC6_Set_Idle_Enable( SC6_TypeDef *sc6,  Uart_IDLE_Enable_TypeDef idle_enable_disable  );
-void SC6_Set_TransMode( SC6_TypeDef *sc6,  Uart_Transmode_TypeDef trans_mode  );
- 
-void SC6_Set_Timeout( SC6_TypeDef *sc6,    uint16_t timeout_ms );
-void SC6_Set_Sendbuf( SC6_TypeDef *sc6,  uint8_t * buf, uint16_t size );
-void SC6_Set_Rcvbuf( SC6_TypeDef *sc6,  uint8_t * buf, uint16_t size );
-
-
-
-
-
-void SC6_Set_Timeout( SC6_TypeDef * sc6,    uint16_t timeout_ms );
-
-// void SC6_Set_Sendbuf( SC6_TypeDef * sc6,  uint8_t * buf, uint16_t size );
-// void SC6_Set_Rcvbuf( SC6_TypeDef * sc6,  uint8_t * buf, uint16_t size );
-
-int SC6_Get_Timeout( SC6_TypeDef * sc6 );
-
-int SC6_Transmit( SC6_TypeDef * sc6,  uint8_t * buf, uint16_t size );
-int SC6_Begin_Rcv( SC6_TypeDef * sc6,  uint8_t * buf, uint16_t size );
-
-int SC6_Set_UartHelper_Status( SC6_TypeDef * sc6  ,Uart_Status_TypeDef status);
-Uart_Status_TypeDef SC6_Get_UartHelper_Status( SC6_TypeDef * sc6  );
- 
+void SC6_Set_Sendbuf(   uint8_t * buf, uint16_t size );
+void SC6_Set_Rcvbuf(   uint8_t * buf, uint16_t size );
+void SC6_Set_Timeout_ms(    uint64_t ms_ticks );
+int SC6_Validate(   );
 
-int  SC6_Get_Data_OK(SC6_TypeDef * sc6   );
-void SC6_Set_Send_Flag(  SC6_TypeDef * sc6 );
 
-void SC6_callback( SC6_TypeDef * sc6,  uint8_t * buf, uint16_t size );
-void SC6_Set_GPIO_For_TC_Cplt( SC6_TypeDef * sc6 );
+int SC6_Transmit();
+int SC6_Receive();
 
-void SC6_clean_flag(SC6_TypeDef * sc6,uint8_t mask);
-uint8_t SC6_get_flag(SC6_TypeDef * sc6,uint8_t mask);
+void SC6_Trans_GPIO(void) ;
 
-uint16_t SC6_get_serial_number(SC6_TypeDef * sc6 );
+void SC6_Trans_Cplt_GPIO(void) ;
 
-// int SC6_copy(uint8_t *targer_buf, uint8_t *src_buf,uint32_t buf_size);
-int SC6_copy(SC6_TypeDef * sc6 ,uint16_t size);
-void SC6_Error( SC6_TypeDef * sc6, char* str );
- 
-// MODULE_SC6_WORK_STATE Set_State( MODULE_SC6_WORK_STATE state );
-void SC6_Set_State( MODULE_SC6_WORK_STATE state  );
-int SC6_Init_Ok();
- 
+int SC6_CallBack( SC6_TypeDef *pPH, uint8_t *buf, uint16_t size );
 
-// extern void SC6_Setup(    );
-extern void SC6_Port( );
-void SC6_Task( void* argument);
  
-/* 再封装演示 */ 
-typedef struct 
-{
-	uint8_t (*init)( );			 
-	void (*port)(void);	
-  void  (*Set_State)(MODULE_SC6_WORK_STATE state );
-  // MODULE_SC6_WORK_STATE  (*Set_State)( MODULE_SC6_WORK_STATE state );
-
-    GPIO_TypeDef *sel_gpio;	 
-    GPIO_TypeDef *dplx_gpio;	 
-    GPIO_TypeDef *de_gpio;	 
-    uint16_t sel_pin;
-    uint16_t dplx_pin;
-    uint16_t de_pin;
-
-    Uart_Interface_Type_Typedef interface_type; /* 0: default(ttl 232), 1: 485 ,2:3160*/
-    Uart_RS_Mode_TypeDef mode_232_485;       /* 0 commome  1:485*/
-    Uart_Transmode_TypeDef trans_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_Transmode_TypeDef rcv_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_IDLE_Enable_TypeDef idle_enable_disable;     /* 0 :不启用空闲 , 1: 启用空闲*/
  
-    SC6_TypeDef *sc6; /*不是常量  不能直接初始化*/
-
-}My_SC6_TypeDef;
-extern My_SC6_TypeDef mysc6;
 
+#ifdef __cplusplus
+	}
+#endif
 #endif
 
-/**
- * 调用  
- * init:  SC6_Setup( );  SC6_SN( );  SC6_Wavelength( );
- * call:  SC6_Port( ); 
- * 
- * sn 波长部分，？？ 单独拉出来初始化，然后任务， 还是一起放任务里头？
- * 多个任务放一个统一开始的开关？ 用一个字节的多个位表示？
- * @register:  viper
-    DataBeginAddress: 2614
-    SNAddress: 2980,10
-    SNLen: 5
-    WLBeginAddress: 2102
-    count: 3
-    functioncode: 3
-    slaveaddress: 1
-    122   122*4+5  = 493
-
-  wl:
-    01 03 08 36 00 7A 26 47    (2102  122)
-    01 03 08 B0 00 7A C7 AE    (2224  122)
-    01 03 09 2A 00 7A E6 7D    (2346  122)
-
-  data: 
-    01 03 0A 36 00 7A 27 FF    (2614  122)
-    01 03 0A B0 00 7A C6 16    (2736  122)
-    01 03 0B 2A 00 7A E7 C5    (2758  122)
-
-  01 03 0B A4 00 05 C6 0E    (SN  2980 5  demo)
-  01 03 00 0A 00 05 A5 CB    (SN  10   5   实际)
- * 
- */
-
-/**
- * @register:   viper
-    DataBeginAddress: 2614
-    SNAddress: 2840
-    SNLen: 5
-    WLBeginAddress: 2102
-    count: 2
-    functioncode: 3
-    slaveaddress: 1
-    wl:
-    01 03 08 36 00 7A 26 47    (2102  122)
-    01 03 08 B0 00 7A C7 AE    (2224  122)
- 
-
-  data: 
-    01 03 0A 36 00 7A 27 FF    (2614  122)
-    01 03 0A B0 00 7A C6 16    (2736  122)
- 
 
-    01 03 0B 18 00 05 07 EA    (SN  2840 5  demo)
-    01 03 00 0A 00 05 A5 CB    (SN  10 5   实际)
- * 
- */
+/*
+    ph.init();
+    ph.port();
+    ph.test();
+
+    // uint64_t ticks = osKernelGetTickCount();
+
+    // while ( ph.state != SC6_State_Ready )
+    // {
+    //     if ( ( osKernelGetTickCount() -ticks) > 5000   )
+    //     {
+    //         log_e(" pH test error.... %d", ph.state) ;
+    //         break;
+    //     }
+    // }
+    osDelay(1000);
+    log_w(" pH test ok.... %d", ph.state) ;
+*/

device/Inc/uart_helper.h

@@ -1,89 +0,0 @@
-#ifndef __UART_HELPER_H
-#define __UART_HANDLE_H
-/**
-* 封装 uart 发送接收操作
-* ??  是否用到buf? 
-*/
-
-#ifdef __cplusplus
-	extern "C" {
-#endif
-
-#include "uart_interface.h"
-
-/*  回调函数，将数据返回上层 */
-typedef void (*it_callback)(void *obj,uint8_t *buf, uint32_t buf_size );
-
-// typedef struct uart_tx_record
-// {
-//     uint32_t size;
-//     uint8_t *buf;
-// } Uart_Trans_Record_TypeDef;
-
-typedef struct 
-{
-    UART_HandleTypeDef *huart;
-	UartInterface_TypeDef *interface;
-    uint8_t interface_type; /* 0: common, 1: 485 ,2:3160*/
-	uint8_t mode_232_485; /* 0: common, 1: 485  */
-    uint8_t trans_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t rcv_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t idle_enable_disable;    /* 0 不开启空闲中断 ， 1 开启空闲中断 */
-	uint8_t trans_mode;         /* 0 :polling, 1: IT  2: DMA*/
-
-    volatile uint32_t trans_size;
-    uint8_t *trans_buf;
-
-    volatile uint8_t receive_buf_con;
-    // volatile uint8_t transferring_flag;
-    volatile uint32_t receive_data_size;
-    uint8_t *receive_buf;
-    uint32_t receive_buf_half_len;
-    uint8_t half_flag;  /*0 : 未半满， 1：半满， 2： 半满已经处理*/
-
-    volatile Uart_Status_TypeDef status;  /* 发送状态 0: ready , 1：正在发送 busy，2：发送ok，*/
-
-    void * obj;
-    it_callback callback;
-
-}UartHelper_TypeDef;
-
-UartHelper_TypeDef * UartHelper_Init( );
-void UartHelper_Set_Interface( UartHelper_TypeDef *uarthelper,  UartInterface_TypeDef * interface );
-void UartHelper_Set_Huart( UartHelper_TypeDef *uarthelper,  UART_HandleTypeDef * huart  );
-void UartHelper_Set_Interface_Type( UartHelper_TypeDef *uarthelper,   Uart_Interface_Type_Typedef interface_type  );
-void UartHelper_Set_Trans_Type( UartHelper_TypeDef *uarthelper,  Uart_Transmode_TypeDef trans_type  );
-void UartHelper_Set_Rcv_Type( UartHelper_TypeDef *uarthelper,  Uart_Transmode_TypeDef rcv_type  );
-void UartHelper_Set_Idle_Enable( UartHelper_TypeDef *uarthelper,  Uart_IDLE_Enable_TypeDef idle_enable_disable  );
-void UartHelper_Set_TransMode( UartHelper_TypeDef *uarthelper,  Uart_Transmode_TypeDef trans_mode  );
-void UartHelper_Set_RsMode_232_485( UartHelper_TypeDef *uarthelper,  Uart_RS_Mode_TypeDef mode_232_485  );
-// void UartHelper_Set_timeout( UartHelper_TypeDef *uarthelper,  uint32_t timeout_ms  );
-
-int UartHelper_Set_callback_func_obj( UartHelper_TypeDef *uarthelper,   void * obj,  it_callback callback );
-
-
-void UartHelper_Set_rcv_buf( UartHelper_TypeDef *uarthelper, uint8_t *buf, uint32_t buf_size );
-void UartHelper_Set_Trans_Buf( UartHelper_TypeDef *uarthelper, uint8_t *buf, uint32_t buf_size );
-
-int UartHelper_Transmit( UartHelper_TypeDef *uarthelper,  uint8_t * buf, uint16_t size);
-int UartHelper_Begin_Rcv(UartHelper_TypeDef *uarthelper,  uint8_t * buf, uint16_t size);
-
-void UartHelper_Set_GPIO_For_Trans_Cplt(  UartHelper_TypeDef *uarthelper );
-void UartHelper_Rcv_Cplt_Callback( UartHelper_TypeDef *uarthelper  );
-void UartHelper_Rcv_Idle_Callback( UartHelper_TypeDef *uarthelper  );
-void UartHelper_Rcv_DMA_Half_Callback( UartHelper_TypeDef *uarthelper  );
-
-int UartHelper_copy(UartHelper_TypeDef *uarthelper,uint8_t *buf,uint32_t buf_size);
-int UartHelper_isbusy(UartHelper_TypeDef *uarthelper );
-void UartHelper_error(UartHelper_TypeDef *uarthelper );
- 
-
-uint16_t Get_Crc16(const char *buf, uint16_t len);
-uint8_t Check_Crc16(uint8_t *buf, uint16_t length); 
-#ifdef __cplusplus
-	}
-#endif
-
-#endif
-
- 

device/Inc/uart_interface.h

@@ -1,153 +0,0 @@
-#ifndef __UART_INTERFACE_H
-#define __UART_INTERFACE_H
-/**
-* 封装不同使用类型串口  232  485 max3160
-* 封装对应的 GPIO操作
-*/
-/*  485 3160 启用一个， 两个接口都有 MAX3160_ENABLE */
-
-
-#ifdef __cplusplus
-	extern "C" {
-#endif
-
-#include <stdlib.h>
-#include "main.h"
-
-#define MAX485_ENABLE  0
-#define MAX3160_ENABLE 1
-
-typedef enum 
-{
-  Uart_Status_Ready       	= 0x00U,
-  Uart_Status_Sending   	= 0x01U,
-  Uart_Status_Send_Cplt    = 0x02U,
-  Uart_Status_Timeout    	= 0x10U,
-  Uart_Status_Error    	= 0x11U,
-} Uart_Status_TypeDef;
-
-typedef enum 
-{
-  Uart_Interface_Default       	= 0x00U,
-  Uart_Interface_485   	= 0x01U,
-  Uart_Interface_Max3160     = 0x02U,
-} Uart_Interface_Type_Typedef; 
-
-
-typedef enum 
-{
-  Uart_Trans_Polling       	= 0x00U,
-  Uart_Trans_IT   	= 0x01U,
-  Uart_Trans_DMA     = 0x02U,
-} Uart_Transmode_TypeDef;
- 
-
-typedef enum 
-{
-  Uart_RSMODE_232       	= 0x00U,
-  Uart_RSMODE_485   	= 0x01U,
-} Uart_RS_Mode_TypeDef;
- 
- 
-typedef enum 
-{
-  Uart_IDLE_IT_DISABLE       	= 0x00U,
-  Uart_IDLE_IT_ENABLE   	= 0x01U,
-} Uart_IDLE_Enable_TypeDef;
- 
-
-
-#if MAX3160_ENABLE
-
-typedef enum{
-	SEL_232 =	0,
-	SEL_485 =	1,
-}Max3160_Sel_TypeDef;
-
-typedef enum{
-	DUPLEX_FULL =	0,
-	DUPLEX_HALF =	1,
-}Max3160_Duplex_TypeDef;   /* 发送时切换全双工（拉低），否则回显， 接收为半双工（拉高 默认）*/
-
-typedef enum{
-	DISABLE_485_SEND =	0,
-	ENABLE_485_SEND =	1,
-}Max3160_DE_TypeDef;
-
-# endif
-
-#if MAX485_ENABLE
-typedef enum{
-	DISABLE_485_SEND =	0,
-	ENABLE_485_SEND =	1,
-}Max_DE_TypeDef;
-# endif
-
-
-
-typedef struct 
-{
-	// UART_HandleTypeDef *huart;
-	uint8_t  interface_type; /* 0: common, 1: 485 ,2:3160*/
-	uint8_t  mode_232_485; /* 0: common, 1: 485  */
-
-#if MAX485_ENABLE
-	GPIO_TypeDef *de485_gpio;
-	uint16_t de485_pin;
-    uint8_t de485;
-#endif
-
-#if MAX3160_ENABLE
-	GPIO_TypeDef *de485_gpio;
-	uint16_t de485_pin;
-	GPIO_TypeDef *sel_gpio;
-	GPIO_TypeDef *dplx_gpio;
-	uint16_t sel_pin;
-	uint16_t dplx_pin;
-    uint8_t sel;
-    uint8_t dplx;
-#endif
-	uint8_t trans_mode; /* 0 :polling, 1: IT  2: DMA*/
-
-
-}UartInterface_TypeDef;
-
-// extern UartInterface_TypeDef *uart_helper;
-
-UartInterface_TypeDef * UartInterface_Init( );
-
-int UartInterface_Setup_Mode_232_485( UartInterface_TypeDef * interface, Uart_RS_Mode_TypeDef mode_232_485 );
-int UartInterface_Setup_Transmod( UartInterface_TypeDef * interface, Uart_Transmode_TypeDef trans_mode );
-int UartInterface_Setup_Interface_type( UartInterface_TypeDef * interface, Uart_Interface_Type_Typedef interface_type );
-// int UartInterface_Setup_Woek_Mode( UartInterface_TypeDef * interface, uint8_t rs_232_485 );
-
-void UartInterface_Set_Sel_GPIO_Pin(UartInterface_TypeDef * interface, GPIO_TypeDef *gpio, uint16_t pin);
-void UartInterface_Set_Dplx_GPIO_Pin(UartInterface_TypeDef * interface, GPIO_TypeDef *gpio, uint16_t pin);
-void UartInterface_Set_DE485_GPIO_Pin(UartInterface_TypeDef * interface, GPIO_TypeDef *gpio, uint16_t pin);
-
-void UartInterface_Set_232(UartInterface_TypeDef * interface);
-void UartInterface_Set_485(UartInterface_TypeDef * interface);
-
-int UartInterface_Set_GPIO_For_Transmit( UartInterface_TypeDef * interface );
-int UartInterface_Set_GPIO_For_Trans_Cplt( UartInterface_TypeDef * interface );
-
-/* 接收方式 也有三种类型 */
-// int UartInterface_Start_Rcv(UartInterface_TypeDef * interface, uint8_t *buf, uint16_t size);
-// void UartInterface_Set_Huart(UartInterface_TypeDef * interface, UART_HandleTypeDef *huart);
-// int UartInterface_Send(UartInterface_TypeDef * interface, uint8_t *buf, uint16_t size);
-// int __UartInterface_Send(UartInterface_TypeDef * interface , uint8_t *buf, uint16_t size);
-#ifdef __cplusplus
-	}
-#endif
-
-#endif
-
-/**
-// int UartInterface_Send(UartInterface_TypeDef * interface, uint8_t *buf, uint16_t size);
-// int __UartInterface_Send(UartInterface_TypeDef * interface , uint8_t *buf, uint16_t size);
-
-// int UartInterface_Send_TxCplt_Callback( UartInterface_TypeDef * interface );
-
-// int UartInterface_Send_Cplt(UartInterface_TypeDef * interface);
-// void UartInterface_Set_tc_flag(UartInterface_TypeDef * interface);
- */

device/Inc/viper.h

@@ -1,243 +1,190 @@
-#ifndef __Viper_H
-#define __Viper_H
+/*
+加入队列 处理
+*/
+#ifndef __VIPER__H
+#define __VIPER__H
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
 
-#include <string.h>
-#include "uart_helper.h"
-#include "uart_interface.h"
-// #include "config.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "main.h"
+#include "cmsis_os.h"
+#include "usart.h"
+ 
+#include "elog.h"
 
-#define  Viper_DEMO           0  /*sn 读取位置不一样*/
-#define  Viper_Rcv_Buf_Size   (3+244+2) 
-#define  Viper_Command_Number       3
-
-#define Viper_FLAG_MASK_BUSY ((uint32_t)1<<(uint32_t)0)
-#define Viper_FLAG_MASK_RECVED_SN ((uint32_t)1<<(uint32_t)1)
-#define Viper_FLAG_MASK_RECVED_WL ((uint32_t)1<<(uint32_t)2)
-#define Viper_FLAG_MASK_RECVED_DATA ((uint32_t)1<<(uint32_t)3)
-// #define Viper_FLAG_MASK_RECVED_WL_1 ((uint32_t)1<<(uint32_t)3)
-// #define Viper_FLAG_MASK_RECVED_DATA_0 ((uint32_t)1<<(uint32_t)4)
-// #define Viper_FLAG_MASK_RECVED_DATA_1 ((uint32_t)1<<(uint32_t)5)
+
+#include <string.h>
+#include "bsp_uart.h"
+ 
+#define Viper_USE_MAX485 0
+#define Viper_USE_MAX3160_232 0
+#define Viper_USE_MAX3160_485 1
  
+#define  Viper_Rcv_Buf_Size   (3+244+2) 
+// #define  Viper_Command_Number       1
+
+static void Viper_MAX3160_232(void) 
+{
+  HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, RESET);
+  HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET);
+}
 
 typedef enum 
 {
-    MODULE_Viper_STATE_WAIT,
-    MODULE_Viper_STATE_START,
-    MODULE_Viper_STATE_GET_SN,
-    MODULE_Viper_STATE_CHECK_SN,
-    MODULE_Viper_STATE_GET_WL_0,
-    MODULE_Viper_STATE_GET_WL_1,
-    MODULE_Viper_STATE_GET_WL_2,
-    MODULE_Viper_STATE_CHECK_WL,
-    MODULE_Viper_STATE_Ready_GET_DATA,
-    MODULE_Viper_STATE_START_DATA,
-    MODULE_Viper_STATE_GET_DATA_0,
-    MODULE_Viper_STATE_GET_DATA_1,
-    MODULE_Viper_STATE_GET_DATA_2,
-    MODULE_Viper_STATE_CHECK_DATA,
-    MODULE_Viper_STATE_OK,
-    MODULE_Viper_STATE_ERROR,
-    MODULE_Viper_STATE_STOP
-} MODULE_Viper_WORK_STATE;
+  Viper_Event_Ready ,
+  Viper_Event_Test,
+  Viper_Event_Test_OK  ,
+  Viper_Event_Get_Data,
+  Viper_Event_Check_Data  ,
+} Module_Viper_Event_TypeDef;
 
+typedef enum 
+{
+  Viper_State_Waiting  ,
+  Viper_State_Test ,
+  Viper_State_Test_Start ,
+  Viper_State_SN_Getting ,
+  Viper_State_SN_OK ,
+  Viper_State_Ready  ,
+  Viper_State_Get_WAVELENGTH  ,
+//   Viper_State_Get_WAVELENGTH_Wait  ,
+//   Viper_State_Get_WAVELENGTH_OK,
+//   Viper_State_Get_WAVELENGTH_Check  ,
+  Viper_State_Get_DATA  ,
+  Viper_State_Get_DATA_Trans,
+  Viper_State_Get_DATA_Wait  ,
+  Viper_State_Get_DATA_OK,
+  Viper_State_Get_DATA_Check  ,
+  Viper_State_Get_Queue_MSG  ,
+  Viper_State_Stop ,
+  Viper_State_Timeout ,
+  Viper_State_Error   ,
+} Module_Viper_State_TypeDef;
+
+extern UART_HELPER_TypeDef *Viper_uart_helper;
 typedef struct 
 {
-	  UartHelper_TypeDef *uarthelper;
-    volatile MODULE_Viper_WORK_STATE state;
+    int (*init)(void);
+    void (*port)(void);
+    int (*test)(void);
+    void (*start)(void);
+    void (*stop)(void);
 
-    volatile uint8_t flag;     /* Viper_FLAG_MASK_ SN WL1 WL2  DATA1  DATA2 ，*/
-    volatile uint8_t send_flag;  		/* 发送标志位 */
-    volatile Uart_Status_TypeDef send_status;  /* 发送状态 1：正在发送 busy，0：发送ok，*/
-    volatile Uart_Status_TypeDef status;  /* 发送状态 0: ready , 1：正在发送 busy，2：发送ok，*/
+    osMessageQueueId_t transQueue;  // 队列可选
 
-    uint8_t interface_type; /* 0: common, 1: 485 ,2:3160*/
-    uint8_t *send_buf;
-    uint16_t size_send;
-    uint8_t *rcv_buf;
-    uint16_t size_rcv;
+    volatile Module_Viper_State_TypeDef state; 
+    uint8_t data_ok;                 /* 接收数据完整可以处理 */
 
+    uint8_t result_buf[1024];
+    uint8_t size_received;
 
-	  uint8_t mode_232_485; /* 0: common, 1: 485  */
-    uint8_t trans_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t rcv_type;  /* 0 :polling, 1: IT  2: DMA*/
-    uint8_t idle_enable_disable;    /* 0 不开启空闲中断 ， 1 开启空闲中断 */
-	  uint8_t trans_mode;         /* 0 :polling, 1: IT  2: DMA*/
+    uint64_t  timebase_ticks;
+    uint64_t  timeout_ticks;
 
-    volatile uint8_t step;             /* 0 : normal , 1 : get wavelength ,  2 : get sn   3: 空*/
-    volatile uint8_t command_seq ;      /* 命令序号 */
+    uint8_t		event_flag;
+	uint8_t		wavelength_ok;
 
-    uint16_t sn;
+    Record_Trans_Rcv_TypeDef transRecord[3];
 
-    uint8_t sn_buf[15];
+    uint8_t vipersn_buf[15];
     uint8_t Viper_Wavelength_Buf[3][ Viper_Rcv_Buf_Size ];
     uint8_t Viper_Data_Buf[3][ Viper_Rcv_Buf_Size ];
 
-    // uint8_t rcv_ok;                 /* 接收数据完整可以处理 */
-    // uint8_t data_begin_flag;                 /* 接收数据完整可以处理 */
-    uint8_t error;                 /* 接收数据完整可以处理 */
-    uint8_t data_ok;                 /* 接收数据完整可以处理 */
-    volatile uint16_t size_received;                  
-
-    uint64_t timebase;
-    uint64_t timeout_ms;
-    uint64_t timeout_enable;
-
 }Viper_TypeDef;
 
-extern Viper_TypeDef *viper ;
-
-uint8_t Viper_Init(   );
+extern Viper_TypeDef viper ;
 
-void Viper_Set_Uarthelper(Viper_TypeDef *viper, UartHelper_TypeDef *uarthelper);
-void Viper_Set_Interface(Viper_TypeDef *viper, UartInterface_TypeDef *interface);
+int Viper_Init( void );
+void Viper_Task( void);
+void Viper_Port( void);
+int Viper_Test( );
+void Viper_Start( );
+void Viper_Stop( );
 
-void Viper_Set_Huart( Viper_TypeDef * oscar,  UART_HandleTypeDef * huart  );
-void Viper_Set_RsMode_232_485( Viper_TypeDef * oscar,  Uart_RS_Mode_TypeDef rs_232_485  );
-
-void Viper_Set_Trans_Type( Viper_TypeDef *viper,  Uart_Transmode_TypeDef trans_type  );
-void Viper_Set_Rcv_Type( Viper_TypeDef *viper,  Uart_Transmode_TypeDef rcv_type  );
-void Viper_Set_Idle_Enable( Viper_TypeDef *viper,  Uart_IDLE_Enable_TypeDef idle_enable_disable  );
-void Viper_Set_TransMode( Viper_TypeDef *viper,  Uart_Transmode_TypeDef trans_mode  );
- 
-void Viper_Set_Timeout( Viper_TypeDef *viper,    uint16_t timeout_ms );
-void Viper_Set_Sendbuf( Viper_TypeDef *viper,  uint8_t * buf, uint16_t size );
-void Viper_Set_Rcvbuf( Viper_TypeDef *viper,  uint8_t * buf, uint16_t size );
+void Viper_Wavelength( );
 
+void Viper_Set_Sendbuf(   uint8_t * buf, uint16_t size );
+void Viper_Set_Rcvbuf(   uint8_t * buf, uint16_t size );
+void Viper_Set_Timeout_ms(    uint64_t ms_ticks );
+int Viper_Validate(   );
 
 
+int Viper_Transmit();
+int Viper_Receive();
 
+void Viper_Trans_GPIO(void) ;
 
-void Viper_Set_Timeout( Viper_TypeDef * oscar,    uint16_t timeout_ms );
+void Viper_Trans_Cplt_GPIO(void) ;
 
-// void Viper_Set_Sendbuf( Viper_TypeDef * oscar,  uint8_t * buf, uint16_t size );
-// void Viper_Set_Rcvbuf( Viper_TypeDef * oscar,  uint8_t * buf, uint16_t size );
+int Viper_CallBack( Viper_TypeDef *pViper , uint8_t *buf, uint16_t size );
 
-int Viper_Get_Timeout( Viper_TypeDef * oscar );
-
-int Viper_Transmit( Viper_TypeDef * oscar,  uint8_t * buf, uint16_t size );
-int Viper_Begin_Rcv( Viper_TypeDef * oscar,  uint8_t * buf, uint16_t size );
-
-int Viper_Set_UartHelper_Status( Viper_TypeDef * oscar  ,Uart_Status_TypeDef status);
-Uart_Status_TypeDef Viper_Get_UartHelper_Status( Viper_TypeDef * oscar  );
- 
-
-int  Viper_Get_Data_OK(Viper_TypeDef * oscar   );
-void Viper_Set_Send_Flag(  Viper_TypeDef * oscar );
-
-void Viper_callback( Viper_TypeDef * oscar,  uint8_t * buf, uint16_t size );
-void Viper_Set_GPIO_For_TC_Cplt( Viper_TypeDef * oscar );
-
-void Viper_clean_flag(Viper_TypeDef * oscar,uint8_t mask);
-uint8_t Viper_get_flag(Viper_TypeDef * oscar,uint8_t mask);
-
-uint16_t Viper_get_serial_number(Viper_TypeDef * oscar );
-
-// int Viper_copy(uint8_t *targer_buf, uint8_t *src_buf,uint32_t buf_size);
-int Viper_copy(Viper_TypeDef * oscar ,uint16_t size);
-void Viper_Error( Viper_TypeDef * oscar, char* str );
- 
-// MODULE_Viper_WORK_STATE Set_State( MODULE_Viper_WORK_STATE state );
-void Viper_Set_State( MODULE_Viper_WORK_STATE state  );
-
-// int Viper_Send( Viper_TypeDef * oscar,  uint8_t * buf, uint16_t size);
-// void Viper_Begin_Rcv(Viper_TypeDef * oscar,  uint8_t * buf, uint16_t size);
-
-// extern  void Viper_Rcv_Cplt_Callback( Viper_TypeDef * oscar  );
-// extern  void Viper_Send_Cplt_Callback(  Viper_TypeDef * oscar );
-
-// void Viper_Set_Interface_Type( Viper_TypeDef * oscar,   Uart_Interface_Typedef interface_type  );
-// void Viper_Set_Trans_Type( Viper_TypeDef * oscar,  Uart_Transmode_TypeDef trans_type  );
-// void Viper_Set_Rcv_Type( Viper_TypeDef * oscar,  Uart_Transmode_TypeDef rcv_type  );
-// void Viper_Set_Idle_Enable( Viper_TypeDef * oscar,  Uart_IDLE_Enable_TypeDef idle_enable_disable  );
-// void Viper_Set_TransMode( Viper_TypeDef * oscar,  Uart_Transmode_TypeDef trans_mode  );
-// void Viper_Set_RsMode_232_485( Viper_TypeDef * oscar,  Uart_RS_Mode_TypeDef rs_232_485  );
-
-// extern void Viper_Setup(    );
-extern void Viper_Port( );
-// extern void Viper_SN( );
-// extern void Viper_Wavelength( );
-void Viper_Task( void* argument);
- 
-/* 再封装演示 */ 
-typedef struct 
-{
-	uint8_t (*init)( );			 
-	void (*port)(void);	
-  void  (*Set_State)(MODULE_Viper_WORK_STATE state );
-  // MODULE_Viper_WORK_STATE  (*Set_State)( MODULE_Viper_WORK_STATE state );
-
-    GPIO_TypeDef *sel_gpio;	 
-    GPIO_TypeDef *dplx_gpio;	 
-    GPIO_TypeDef *de_gpio;	 
-    uint16_t sel_pin;
-    uint16_t dplx_pin;
-    uint16_t de_pin;
-
-    Uart_Interface_Type_Typedef interface_type; /* 0: default(ttl 232), 1: 485 ,2:3160*/
-    Uart_RS_Mode_TypeDef mode_232_485;       /* 0 commome  1:485*/
-    Uart_Transmode_TypeDef trans_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_Transmode_TypeDef rcv_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_IDLE_Enable_TypeDef idle_enable_disable;     /* 0 :不启用空闲 , 1: 启用空闲*/
- 
-    Viper_TypeDef *viper; /*不是常量  不能直接初始化*/
-
-}My_Viper_TypeDef;
-extern My_Viper_TypeDef myviper;
 
+#ifdef __cplusplus
+	}
+#endif
 #endif
 
-/**
- * 调用  
- * init:  Viper_Setup( );  Viper_SN( );  Viper_Wavelength( );
- * call:  Viper_Port( ); 
- * 
- * sn 波长部分，？？ 单独拉出来初始化，然后任务， 还是一起放任务里头？
- * 多个任务放一个统一开始的开关？ 用一个字节的多个位表示？
- * @register:  viper
-    DataBeginAddress: 2614
-    SNAddress: 2980,10
-    SNLen: 5
-    WLBeginAddress: 2102
-    count: 3
-    functioncode: 3
-    slaveaddress: 1
-    122   122*4+5  = 493
-
-  wl:
-    01 03 08 36 00 7A 26 47    (2102  122)
-    01 03 08 B0 00 7A C7 AE    (2224  122)
-    01 03 09 2A 00 7A E6 7D    (2346  122)
-
-  data: 
-    01 03 0A 36 00 7A 27 FF    (2614  122)
-    01 03 0A B0 00 7A C6 16    (2736  122)
-    01 03 0B 2A 00 7A E7 C5    (2758  122)
-
-  01 03 0B A4 00 05 C6 0E    (SN  2980 5  demo)
-  01 03 00 0A 00 05 A5 CB    (SN  10   5   实际)
- * 
- */
-
-/**
- * @register:   viper
-    DataBeginAddress: 2614
-    SNAddress: 2840
-    SNLen: 5
-    WLBeginAddress: 2102
-    count: 2
-    functioncode: 3
-    slaveaddress: 1
-    wl:
-    01 03 08 36 00 7A 26 47    (2102  122)
-    01 03 08 B0 00 7A C7 AE    (2224  122)
- 
-
-  data: 
-    01 03 0A 36 00 7A 27 FF    (2614  122)
-    01 03 0A B0 00 7A C6 16    (2736  122)
- 
 
-    01 03 0B 18 00 05 07 EA    (SN  2840 5  demo)
-    01 03 00 0A 00 05 A5 CB    (SN  10 5   实际)
- * 
- */
+/*
+    temp.init();
+    temp.port();
+    temp.test();
+
+    uint64_t ticks = osKernelGetTickCount();
+
+    while ( temp.state != PH_State_Ready )
+    {
+        if ( ( osKernelGetTickCount() -ticks) > 3000 )
+        {
+            log_e(" pH test error.... ") ;
+            break;
+        }
+    }
+    log_w(" pH test ok.... ") ;
+
+
+// osMessageQueueId_t TestQQueueueueHandle;
+// 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,
+// void *  msg_ptr,       //储存读取结果的变量地址
+// uint8_t *  msg_prio,  // ==NULL
+// uint32_t  timeout    //阻塞超时时间
+// );
+// osStatus_t osMessageQueuePut ( osMessageQueueId_t  mq_id,
+// const void *  msg_ptr,     //储存写入内容的变量地址
+// uint8_t  msg_prio,        //==0U
+// uint32_t  timeout         //阻塞超时时间
+// );
+
+
+// uint8_t Viper_SN_command[8] = {0x01, 0x03, 0x00, 0x0A, 0x00, 0x05, 0xA5, 0xCB};
+
+// uint8_t Viper_Wavelength_sendbuf[3][8]   = {
+//         
+//         // 01 03 08 36 00 7A 26 47    (2102  122)
+//         // 01 03 08 B0 00 7A C7 AE    (2224  122)
+//         // 01 03 09 2A 00 7A E6 7D    (2346  122)
+//         
+//         { 0x01, 0x03, 0x08, 0x36, 0x00, 0x7A, 0x26, 0x47 },
+//         { 0x01, 0x03, 0x08, 0xB0, 0x00, 0x7A, 0xC7, 0xAE },
+//         { 0x01, 0x03, 0x09, 0x2A, 0x00, 0x7A, 0xE6, 0x7D }
+//     };
+// uint8_t Viper_Data_sendbuf[3][8]   = {
+//         
+//         //01 03 0A 36 00 7A 27 FF    (2614  122)
+//         //01 03 0A B0 00 7A C6 16    (2736  122)
+//         //01 03 0B 2A 00 7A E7 C5    (2858  122)
+//         
+//         { 0x01, 0x03, 0x0A, 0x36, 0x00, 0x7A, 0x27, 0xFF },
+//         { 0x01, 0x03, 0x0A, 0xB0, 0x00, 0x7A, 0xC6, 0x16 },
+//         { 0x01, 0x03, 0x0B, 0x2A, 0x00, 0x7A, 0xE7, 0xC5 }
+//     };
+// uint8_t Viper_sn_buf[15] = {0};
+
+
+*/

device/Inc/wh_lte_7s4_v2.h

@@ -1,29 +1,40 @@
-/**
- * @file wh_lte_7s4_v2.h
- * @author Chen Jihang (embedded@eseaoptics.com)
- * @brief WH LTE 7S4 V2驱动
- * @version 0.1
- * @date 2022-07-18
- * 
- * @copyright ESEA (c) 2020
- * 
- */
 #ifndef WH_LTE_7S4_V2_H_
 #define WH_LTE_7S4_V2_H_
-#include "stdint.h"
-// #include "config.h"
-#include "uart_helper.h"
-#include "uart_interface.h"
-// #include "platform.h"
 
-#define    WH_LTE_Rcv_Buf_Size  (1024)
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "main.h"
+#include "cmsis_os.h"
+#include "usart.h"
+ 
+#include "elog.h"
+
+
+#include <string.h>
+#include "bsp_uart.h"
+ 
+#define WH_LTE_USE_MAX485 0
+#define WH_LTE_USE_MAX3160_232 0
+#define WH_LTE_USE_MAX3160_485 1
+ 
+#define  WH_LTE_Rcv_Buf_Size   (3+244+2) 
+// #define  WH_LTE_Command_Number       1
+
+static void WH_LTE_MAX3160_232(void) 
+{
+  HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, RESET);
+  HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET);
+}
 
 #define WH_LTE_FLAG_MASK_BUSY ((uint32_t)1<<(uint32_t)0)
 #define WH_LTE_FLAG_MASK_RECVED_SN ((uint32_t)1<<(uint32_t)1)
 #define WH_LTE_FLAG_MASK_RECVED_WL ((uint32_t)1<<(uint32_t)2)
 #define WH_LTE_FLAG_MASK_RECVED_DATA ((uint32_t)1<<(uint32_t)3)
 
-
 typedef enum 
 {
     MODULE_WH_LTE_EVENT_READY,
@@ -39,7 +50,6 @@ typedef enum
     MODULE_WH_LTE_EVENT_SEND_DATA,
 } MODULE_WH_LTE_EVENT_TypeDef;
 
-
 typedef enum 
 {
     MODULE_WH_LTE_7S4_INIT_STATE_WAIT,
@@ -59,38 +69,6 @@ typedef enum
 } MODULE_WH_LTE_WORK_STATE;
 
 
-typedef int (*wh_lte_7s4_send_fun)(void *send_obj,char *buf,uint32_t size);
-
-typedef struct  
-{
-    // UartHelper_TypeDef *uarthelper;
-    volatile MODULE_WH_LTE_WORK_STATE state;
-
-    uint8_t receive_err_code;
-    uint8_t receive_ok_flag;
-    uint8_t receive_a_flag;
-    uint8_t receive_para_num;
-    uint32_t receive_size;
-    char receive_para[8][32];
-    char send_args_buf[64];
-    uint8_t receive_buf[1024];
-    void *send_obj;
-    wh_lte_7s4_send_fun send_fun;
-
-    uint8_t error;                 /* 接收数据完整可以处理 */
-    uint8_t data_ok;                 /* 接收数据完整可以处理 */
-    volatile uint16_t size_received;                  
-
-    uint64_t timebase;
-    uint32_t timeout_ms;
-    uint8_t timeout_enable;
-
-    //  f服务器信息
-    char server_ip_domain[64];
-    uint16_t server_port;
-
-}WH_LTE_7S4_Typedef;
-
 enum wh_lte_7s4_cmd_state{
     WH_LTE_7S4_CMD_STATE_OFF=0,
     WH_LTE_7S4_CMD_STATE_ON=1
@@ -114,131 +92,76 @@ enum wh_lte_7s4_cmd_protocol{
     WH_LTE_7S4_CMD_PROTOCOL_UDP
 };
 
-extern WH_LTE_7S4_Typedef *wh_lte_7s4;
+extern UART_HELPER_TypeDef *WH_LTE_uart_helper;
 
-
-/* 再封装演示 */ 
 typedef struct 
 {
-	uint8_t (*init)( );			 
-	void (*port)( );	
-  void  (*setstate)( MODULE_WH_LTE_WORK_STATE state);
-  // MODULE_WH_LTE_WORK_STATE  (*Set_State)( MODULE_WH_LTE_WORK_STATE state );
-
-    GPIO_TypeDef *sel_gpio;	 
-    GPIO_TypeDef *dplx_gpio;	 
-    GPIO_TypeDef *de_gpio;	 
-    uint16_t sel_pin;
-    uint16_t dplx_pin;
-    uint16_t de_pin;
-
-    Uart_Interface_Type_Typedef interface_type; /* 0: default(ttl 232), 1: 485 ,2:3160*/
-    Uart_RS_Mode_TypeDef mode_232_485;       /* 0 commome  1:485*/
-    Uart_Transmode_TypeDef trans_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_Transmode_TypeDef rcv_type;     /* 0 :polling, 1: IT  2: DMA*/
-    Uart_IDLE_Enable_TypeDef idle_enable_disable;     /* 0 :不启用空闲 , 1: 启用空闲*/
- 
-    WH_LTE_7S4_Typedef *sample; /*不是常量  不能直接初始化*/
-
-}My_WH_LTE_TypeDef;
-extern My_WH_LTE_TypeDef my_wh_lte;
-
-void WH_LTE_Port(void);
-void WH_LTE_Task(void* argument);
-void  WH_LTE_Set_State(MODULE_WH_LTE_WORK_STATE state);
-
-void WH_LTE_Set_Timeout( WH_LTE_7S4_Typedef * wh_lte_7s4,    uint16_t timeout_ms );
-int WH_LTE_Get_Timeout( WH_LTE_7S4_Typedef * wh_lte_7s4 );
-
-int WH_LTE_Transmit( WH_LTE_7S4_Typedef * wh_lte_7s4,  uint8_t * buf, uint16_t size );
-int WH_LTE_Begin_Rcv( WH_LTE_7S4_Typedef * wh_lte_7s4,  uint8_t * buf, uint16_t size );
-
-void WH_LTE_Set_GPIO_For_TC_Cplt( WH_LTE_7S4_Typedef * wh_lte_7s4 );
-int WH_LTE_copy(WH_LTE_7S4_Typedef * wh_lte_7s4 ,uint16_t size);
-
-int wh_lte_7s4_init(  );
-int wh_lte_7s4_ppp(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_a(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_test(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size);
-int wh_lte_7s4_inquire(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size);
-int wh_lte_7s4_run(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size);
-int wh_lte_7s4_set(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t cmd_size,char *args,uint32_t args_size);
-int wh_lte_7s4_at_help(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_z(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_reboot(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_echo(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_echo(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state echo_state);
-int wh_lte_7s4_at_entm(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_workmode(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_work_mode work_mode);
-int wh_lte_7s4_at_get_workmode(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_csq(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_system_info(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_reload(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_clear(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_sn(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_iccid(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_imei(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_local_ip(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_uart(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_uart(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t buad,uint8_t data,uint8_t stop,enum wh_lte_7s4_cmd_uart_parity parity);
-int wh_lte_7s4_at_get_uartft(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_uartft(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t ft);
-int wh_lte_7s4_at_get_uartfl(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_uartfl(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t len);
-int wh_lte_7s4_at_get_socka(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_socka(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port);
-int wh_lte_7s4_at_get_sockb(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sockb(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port);
-int wh_lte_7s4_at_get_socka_en(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_socka_en(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state);
-int wh_lte_7s4_at_get_sockb_en(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sockb_en(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state);
-int wh_lte_7s4_at_get_sockasl(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sockasl(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type);
-int wh_lte_7s4_at_get_sockbsl(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sockbsl(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type);
-int wh_lte_7s4_at_get_sockalk(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_sockblk(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_sdpen(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sdpen(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state new_state);
-int wh_lte_7s4_at_get_cclk(WH_LTE_7S4_Typedef *wh_lte_7s4);
-void wh_lte_7s4_receive_callback(WH_LTE_7S4_Typedef *wh_lte_7s4, uint32_t size);
-void wh_lte_7s4_receive_unpack(WH_LTE_7S4_Typedef *wh_lte_7s4,char *buf,uint32_t size);
-
-int Compare_RcvBuf_And_Procedure_Table(int seq, uint8_t *buf, uint16_t size);
-unsigned wh_lte_convert_u2s(unsigned integer,char *str,unsigned length);
-#endif
+    int (*init)(void);
+    void (*port)(void);
+    int (*test)(void);
+    void (*start)(void);
+    void (*stop)(void);
 
-/*
-AT+CCLK? 
-+CCLK: “20/06/19,20:05:19+32”
+    osMessageQueueId_t transQueue;  // 队列可选
 
-AT+LBS 
-+LBS:"520C","03207502"
+    volatile MODULE_WH_LTE_WORK_STATE state; 
+    uint8_t data_ok;                 /* 接收数据完整可以处理 */
 
-AT+APN=3gnet,admin,admin,0
-OK
+    uint8_t receive_buf[1024];
+    uint16_t size_received;
 
-[CR][LF][+CMD][OP][PARA][CR][LF]<CR><LF>[OK]<CR><LF>
+    uint64_t  timebase_ticks;
+    uint64_t  timeout_ticks;
 
-AT+ENTM  OK
+    uint8_t		event_flag;
+	uint8_t		wavelength_ok;
 
-AT+ID=0001
+    Record_Trans_Rcv_TypeDef transRecord[3];
 
-1 +++a 进入指令配置状态 
-2 AT+WKMOD=UDC 工作模式设置为：UDC 
-3 AT+SOCKAEN=ON 设置 socket A 为使能状态 
-4 AT+SOCKA=TCP,test.usr.cn,2317 设置 socket A 为 TCP Client 
-5 AT+SOCKASL=LONG 设置 socket A 为长连接 
-6 AT+REGEN=ON 设置注册包使能为开 
-7 AT+ID=0001 设置UDC的设备ID为0001，最大长度11位 
-8 AT+Z 重启模块
+    char receive_para[8][32];
+    char send_args_buf[64];
+    uint8_t WH_LTE_Data_Buf[3][ WH_LTE_Rcv_Buf_Size ];
 
-1 +++a 进入指令配置状态 
-2 AT+WKMOD=NET 工作模式设置为：NET 
-3 AT+REGEN=ON 开启注册包功能 
-4 AT+REGTP=CLOUD 设置注册包内容类型为CLOUD 
-5 AT+CLOUD=01234567890123456789，12345678 设置透传云用户名和密码 
-6 AT+Z 重启模块
-*/
+	uint8_t receive_err_code;
+    uint8_t receive_ok_flag;
+    uint8_t receive_a_flag;
+    uint8_t receive_para_num;
+    uint32_t receive_size;
+	uint8_t error;
+
+	    // 服务器信息
+    char server_ip_domain[64];
+    uint16_t server_port;
+
+
+}WH_LTE_TypeDef;
+
+extern WH_LTE_TypeDef wh_lte ;
+
+int WH_LTE_Init( void );
+void WH_LTE_Task( void);
+void WH_LTE_Port( void);
+int WH_LTE_Test( );
+void WH_LTE_Start( );
+void WH_LTE_Stop( );
+
+void WH_LTE_Wavelength( );
+
+void WH_LTE_Set_Sendbuf(   uint8_t * buf, uint16_t size );
+void WH_LTE_Set_Rcvbuf(   uint8_t * buf, uint16_t size );
+void WH_LTE_Set_Timeout_ms(    uint64_t ms_ticks );
+int WH_LTE_Validate(   );
+
+
+int WH_LTE_Transmit();
+int WH_LTE_Receive();
+
+void WH_LTE_Trans_GPIO(void) ;
+
+void WH_LTE_Trans_Cplt_GPIO(void) ;
+
+int WH_LTE_CallBack( WH_LTE_TypeDef *pWHLTE , uint8_t *buf, uint16_t size );
+
+unsigned wh_lte_convert_u2s(unsigned integer,char *str,unsigned length);
+unsigned wh_let_7s4_get_work_state(void);
+#endif

device/Inc/wh_lte_7s4_v2_2.h

@@ -1,134 +0,0 @@
-/**
- * @file wh_lte_7s4_v2.h
- * @author Chen Jihang (embedded@eseaoptics.com)
- * @brief WH LTE 7S4 V2驱动
- * @version 0.1
- * @date 2022-07-18
- * 
- * @copyright ESEA (c) 2020
- * 
- */
-#ifndef WH_LTE_7S4_V2_H_
-#define WH_LTE_7S4_V2_H_
-#include "stdint.h"
-#include "config.h"
-#include "myuart.h"
-// typedef int (*wh_lte_7s4_send_fun)(void *send_obj,char *buf,uint32_t size);
-// typedef struct wh_lte_7s4_buff
-typedef struct  
-{
-    MYUART_TypeDef *myuart;
-    uint8_t receive_err_code;
-    uint8_t receive_ok_flag;
-    uint8_t receive_a_flag;
-    uint8_t receive_para_num;
-    uint32_t receive_size;
-    char receive_para[8][32];
-    char send_args_buf[64];   /* 组装命令 */
-    uint8_t receive_buf[1024];
-    uint32_t timebase;
-    uint32_t timeout;
-    uint8_t step; 
-    // void *send_obj;
-    // wh_lte_7s4_send_fun send_fun;
-
-}WH_LTE_7S4_Typedef;
-enum wh_lte_7s4_cmd_state{
-    WH_LTE_7S4_CMD_STATE_OFF=0,
-    WH_LTE_7S4_CMD_STATE_ON=1
-};
-enum wh_lte_7s4_cmd_work_mode{
-    WH_LTE_7S4_CMD_WORK_MODE_NET=0,
-    WH_LTE_7S4_CMD_WORK_MODE_HTTPD=1,
-    WH_LTE_7S4_CMD_WORK_MODE_UDC=0,
-};
-enum wh_lte_7s4_cmd_uart_parity{
-    WH_LTE_7S4_CMD_UART_PARITY_NONE=0,
-    WH_LTE_7S4_CMD_UART_PARITY_ODD=1,
-    WH_LTE_7S4_CMD_UART_PARITY_EVEN=2
-};
-enum wh_lte_7s4_cmd_sockasl{
-    WH_LTE_7S4_CMD_SOCKASL_SHORT=0,
-    WH_LTE_7S4_CMD_SOCKASL_LONG=1
-};
-enum wh_lte_7s4_cmd_protocol{
-    WH_LTE_7S4_CMD_PROTOCOL_TCP,
-    WH_LTE_7S4_CMD_PROTOCOL_UDP
-};
-
-WH_LTE_7S4_Typedef *wh_lte_7s4_init( );
-int __wh_lte_7s4_send(WH_LTE_7S4_Typedef *wh_lte_7s4, uint8_t *buf, uint16_t size);
-int __wh_lte_7s4_receive(WH_LTE_7S4_Typedef *wh_lte_7s4, uint8_t *buf, uint16_t size);
-
-void  wh_lte_7s4_receive_callback(WH_LTE_7S4_Typedef *wh_lte_7s4 );
-void  wh_lte_7s4_receive_error_callback(WH_LTE_7S4_Typedef *wh_lte_7s4 );
-
-int wh_lte_7s4_ppp(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_a(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_test(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size);
-int wh_lte_7s4_inquire(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size);
-int wh_lte_7s4_run(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size);
-int wh_lte_7s4_set(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t cmd_size,char *args,uint32_t args_size);
-int wh_lte_7s4_at_help(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_z(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_reboot(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_echo(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_echo(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state echo_state);
-int wh_lte_7s4_at_entm(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_workmode(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_work_mode work_mode);
-int wh_lte_7s4_at_get_workmode(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_csq(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_system_info(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_reload(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_clear(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_sn(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_iccid(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_imei(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_local_ip(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_uart(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_uart(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t baud,uint8_t data,uint8_t stop,enum wh_lte_7s4_cmd_uart_parity parity);
-int wh_lte_7s4_at_get_uartft(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_uartft(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t ft);
-int wh_lte_7s4_at_get_uartfl(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_uartfl(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t len);
-int wh_lte_7s4_at_get_socka(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_socka(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port);
-int wh_lte_7s4_at_get_sockb(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sockb(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port);
-int wh_lte_7s4_at_get_socka_en(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_socka_en(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state);
-int wh_lte_7s4_at_get_sockb_en(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sockb_en(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state);
-int wh_lte_7s4_at_get_sockasl(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sockasl(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type);
-int wh_lte_7s4_at_get_sockbsl(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sockbsl(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type);
-int wh_lte_7s4_at_get_sockalk(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_sockblk(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_get_sdpen(WH_LTE_7S4_Typedef *wh_lte_7s4);
-int wh_lte_7s4_at_set_sdpen(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state new_state);
-int wh_lte_7s4_at_get_cclk(WH_LTE_7S4_Typedef *wh_lte_7s4);
-void wh_lte_7s4_receive_unpack(WH_LTE_7S4_Typedef *wh_lte_7s4,char *buf,uint32_t size);
-
-unsigned convert_u_2_s(unsigned integer,char *str,unsigned length);
-
-#endif
-
-
-/**
- * wh_lte_7s4 封装
- * 
- at  : AT\r
- test : AT+[cmd]+?\r\n
- inquire: AT+[cmd]=?\r\n
- run: AT+[cmd]\r\n
- set: AT+[cmd]=[args]\r\n
- 
-wh_lte_7s4_buff  :
-封装myuart
-初始化
-port
-回调 - 空闲回调
-常用组合操作任务，
-*/

device/Inc/wk2114.h

@@ -14,8 +14,16 @@
 #include <stddef.h>
 #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,23 +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);
 
-#endif
+
+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触发点时，该中断被清除。
+
+
+wk2114_read_reg( wk2114, 0x00 ); 自动加上 [7:6] 0 1
+
+    HAL_UART_DMAStop(pWK2114Uart);
+    HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, rcvbuf, 1024);
+    wk2114->cmd =0;
+    wk2114_read_reg( wk2114, 0x00 );
+
+
+*/

device/Inc/wk2xxx.h

@@ -1,346 +0,0 @@
-#ifndef _WK2XXX_H_
-#define _WK2XXX_H_
-
-#include "main.h"
-
-#define 	WK2XXX_GPORT    1//	/wkxxxx  Global rigister of PORT
-
-#define 	WK2XXX_GENA     0X00
-#define 	WK2XXX_GRST     0X01
-#define		WK2XXX_GMUT     0X02
-#define 	WK2XXX_GIER     0X10
-#define 	WK2XXX_GIFR     0X11
-#define 	WK2XXX_GPDIR    0X21
-#define 	WK2XXX_GPDAT    0X31
-//wkxxxx  slave uarts  rigister address defines
-
-#define 	WK2XXX_SPAGE    0X03
-//PAGE0
-#define 	WK2XXX_SCR      0X04
-#define 	WK2XXX_LCR      0X05
-#define 	WK2XXX_FCR      0X06
-#define 	WK2XXX_SIER     0X07
-#define 	WK2XXX_SIFR     0X08
-#define 	WK2XXX_TFCNT    0X09
-#define 	WK2XXX_RFCNT    0X0A
-#define 	WK2XXX_FSR      0X0B
-#define 	WK2XXX_LSR      0X0C
-#define 	WK2XXX_FDAT     0X0D
-#define 	WK2XXX_FWCR     0X0E
-#define 	WK2XXX_RS485    0X0F
-//PAGE1
-#define 	WK2XXX_BAUD1    0X04
-#define 	WK2XXX_BAUD0    0X05
-#define 	WK2XXX_PRES     0X06
-#define 	WK2XXX_RFTL     0X07
-#define 	WK2XXX_TFTL     0X08
-#define 	WK2XXX_FWTH     0X09
-#define 	WK2XXX_FWTL     0X0A
-#define 	WK2XXX_XON1     0X0B
-#define 	WK2XXX_XOFF1    0X0C
-#define 	WK2XXX_SADR     0X0D
-#define 	WK2XXX_SAEN     0X0E
-#define 	WK2XXX_RTSDLY   0X0F
-
-//WK串口扩展芯片的寄存器的位定义
-//wkxxx register bit defines
-// GENA
-#define 	WK2XXX_UT4EN	0x08
-#define 	WK2XXX_UT3EN	0x04
-#define 	WK2XXX_UT2EN	0x02
-#define 	WK2XXX_UT1EN	0x01
-//GRST
-#define 	WK2XXX_UT4SLEEP	0x80
-#define 	WK2XXX_UT3SLEEP	0x40
-#define 	WK2XXX_UT2SLEEP	0x20
-#define 	WK2XXX_UT1SLEEP	0x10
-#define 	WK2XXX_UT4RST	0x08
-#define 	WK2XXX_UT3RST	0x04
-#define 	WK2XXX_UT2RST	0x02
-#define 	WK2XXX_UT1RST	0x01
-//GIER
-#define 	WK2XXX_UT4IE	0x08
-#define 	WK2XXX_UT3IE	0x04
-#define 	WK2XXX_UT2IE	0x02
-#define 	WK2XXX_UT1IE	0x01
-//GIFR
-#define 	WK2XXX_UT4INT	0x08
-#define 	WK2XXX_UT3INT	0x04
-#define 	WK2XXX_UT2INT	0x02
-#define 	WK2XXX_UT1INT	0x01
-//SPAGE
-#define 	WK2XXX_SPAGE0	  0x00
-#define 	WK2XXX_SPAGE1   0x01
-//SCR
-#define 	WK2XXX_SLEEPEN	0x04
-#define 	WK2XXX_TXEN     0x02
-#define 	WK2XXX_RXEN     0x01
-//LCR
-#define 	WK2XXX_BREAK	  0x20
-#define 	WK2XXX_IREN     0x10
-#define 	WK2XXX_PAEN     0x08
-#define 	WK2XXX_PAM1     0x04
-#define 	WK2XXX_PAM0     0x02
-#define 	WK2XXX_STPL     0x01
-//FCR
-//SIER
-#define 	WK2XXX_FERR_IEN      0x80
-#define 	WK2XXX_CTS_IEN       0x40
-#define 	WK2XXX_RTS_IEN       0x20
-#define 	WK2XXX_XOFF_IEN      0x10
-#define 	WK2XXX_TFEMPTY_IEN   0x08
-#define 	WK2XXX_TFTRIG_IEN    0x04
-#define 	WK2XXX_RXOUT_IEN     0x02
-#define 	WK2XXX_RFTRIG_IEN    0x01
-//SIFR
-#define 	WK2XXX_FERR_INT      0x80  /* 接收FIFO数据错误中断标志位 */
-#define 	WK2XXX_CTS_INT       0x40
-#define 	WK2XXX_RTS_INT       0x20
-#define 	WK2XXX_XOFF_INT      0x10
-#define 	WK2XXX_TFEMPTY_INT   0x08  /*  发送FIFO空中断标志位  */
-#define 	WK2XXX_TFTRIG_INT    0x04  /*  发送FIFO触点中断标志位  */
-#define 	WK2XXX_RXOVT_INT     0x02  /*  接收FIFO超时中断标志位  */
-#define 	WK2XXX_RFTRIG_INT    0x01  /*  接收FIFO触点中断标志位  */
-
-//TFCNT
-//RFCNT
-//FSR  FIFO
-#define 	WK2XXX_RFOE     0x80   /* 子串口溢出 */
-#define 	WK2XXX_RFBI     0x40   /* 子串口 break line 	*/
-#define 	WK2XXX_RFFE     0x20   /* 子串口数据帧错误  	*/
-#define 	WK2XXX_RFPE     0x10   /* 子串口数据校验错误  	*/
-#define 	WK2XXX_RDAT     0x08   /* 子串口接收为空  0：非空  1：空*/
-#define 	WK2XXX_TDAT     0x04   /* 子串口发送为空  		*/
-#define 	WK2XXX_TFULL    0x02   /* 子串口发送满  		*/
-#define 	WK2XXX_TBUSY    0x01   /* 子串口发送忙  		*/
-//LSR  接收状态
-#define 	WK2XXX_OE       0x08   /* 子串口接收溢出 		*/
-#define 	WK2XXX_BI       0x04   /* 子串口接收 line-break */
-#define 	WK2XXX_FE       0x02   /* 子串口数据接收帧错误  */
-#define 	WK2XXX_PE       0x01   /* 子串口数据接收校验错误  */
-//FWCR
-
-uint16_t WK_PortSendData(uint8_t port, const void* buf, uint16_t len);
-uint16_t WK_PortRecvData(uint8_t port, void* buf, uint16_t len);
-void WK_PortInit(uint8_t port, uint32_t fosc, uint32_t baudrate);
-void WK_IRQHandler(void);
-void WK_Rst(void);
-uint8_t Wk2xxx_Test(void);
-
-/* 切换子串口回调函数 */
-// int wk2114_sub_uart_chenge_recv_fun(struct wk2114_sub_uart *sub_uart,void *recv_class,wk2114_sub_uart_recv_fun recv_fun);
-
-#endif /* _WK2XXX_H_ */
-
-
-// // #include "sys.h"
-// #include "myuart.h"
-// #include "main.h"
-// static uint8_t init_buf=0x55;
-
-// //如下为WK系列串口扩展芯片的寄存器地址定义，不同的芯片，可能寄存器少一些，所以具体的寄存器请看数据手册
-// //wkxxxx  Global rigister address defines
-// #define 	WK2XXX_GENA     0X00
-// #define 	WK2XXX_GRST     0X01
-// #define		WK2XXX_GMUT     0X02
-// #define 	WK2XXX_GIER     0X10
-// #define 	WK2XXX_GIFR     0X11
-// #define 	WK2XXX_GPDIR    0X21
-// #define 	WK2XXX_GPDAT    0X31
-// #define 	WK2XXX_GPORT    1//	/wkxxxx  Global rigister of PORT
-// //wkxxxx  slave uarts  rigister address defines
-
-// #define 	WK2XXX_SPAGE    0X03
-// //PAGE0
-// #define 	WK2XXX_SCR      0X04
-// #define 	WK2XXX_LCR      0X05
-// #define 	WK2XXX_FCR      0X06
-// #define 	WK2XXX_SIER     0X07
-// #define 	WK2XXX_SIFR     0X08
-// #define 	WK2XXX_TFCNT    0X09
-// #define 	WK2XXX_RFCNT    0X0A
-// #define 	WK2XXX_FSR      0X0B
-// #define 	WK2XXX_LSR      0X0C
-// #define 	WK2XXX_FDAT     0X0D
-// #define 	WK2XXX_FWCR     0X0E
-// #define 	WK2XXX_RS485    0X0F
-// //PAGE1
-// #define 	WK2XXX_BAUD1    0X04
-// #define 	WK2XXX_BAUD0    0X05
-// #define 	WK2XXX_PRES     0X06
-// #define 	WK2XXX_RFTL     0X07
-// #define 	WK2XXX_TFTL     0X08
-// #define 	WK2XXX_FWTH     0X09
-// #define 	WK2XXX_FWTL     0X0A
-// #define 	WK2XXX_XON1     0X0B
-// #define 	WK2XXX_XOFF1    0X0C
-// #define 	WK2XXX_SADR     0X0D
-// #define 	WK2XXX_SAEN     0X0E
-// #define 	WK2XXX_RRSDLY   0X0F
-
-// //WK串口扩展芯片的寄存器的位定义
-// //wkxxx register bit defines
-// // GENA
-// #define 	WK2XXX_UT4EN	0x08
-// #define 	WK2XXX_UT3EN	0x04
-// #define 	WK2XXX_UT2EN	0x02
-// #define 	WK2XXX_UT1EN	0x01
-// //GRST
-// #define 	WK2XXX_UT4SLEEP	0x80
-// #define 	WK2XXX_UT3SLEEP	0x40
-// #define 	WK2XXX_UT2SLEEP	0x20
-// #define 	WK2XXX_UT1SLEEP	0x10
-// #define 	WK2XXX_UT4RST	0x08
-// #define 	WK2XXX_UT3RST	0x04
-// #define 	WK2XXX_UT2RST	0x02
-// #define 	WK2XXX_UT1RST	0x01
-// //GIER
-// #define 	WK2XXX_UT4IE	0x08
-// #define 	WK2XXX_UT3IE	0x04
-// #define 	WK2XXX_UT2IE	0x02
-// #define 	WK2XXX_UT1IE	0x01
-// //GIFR
-// #define 	WK2XXX_UT4INT	0x08
-// #define 	WK2XXX_UT3INT	0x04
-// #define 	WK2XXX_UT2INT	0x02
-// #define 	WK2XXX_UT1INT	0x01
-// //SPAGE
-// #define 	WK2XXX_SPAGE0	0x00
-// #define 	WK2XXX_SPAGE1   0x01
-// //SCR
-// #define 	WK2XXX_SLEEPEN	0x04
-// #define 	WK2XXX_TXEN     0x02
-// #define 	WK2XXX_RXEN     0x01
-// //LCR
-// #define 	WK2XXX_BREAK	0x20
-// #define 	WK2XXX_IREN     0x10
-// #define 	WK2XXX_PAEN     0x08
-// #define 	WK2XXX_PAM1     0x04
-// #define 	WK2XXX_PAM0     0x02
-// #define 	WK2XXX_STPL     0x01
-// //FCR
-// //SIER
-// #define 	WK2XXX_FERR_IEN      0x80
-// #define 	WK2XXX_CTS_IEN       0x40
-// #define 	WK2XXX_RTS_IEN       0x20
-// #define 	WK2XXX_XOFF_IEN      0x10
-// #define 	WK2XXX_TFEMPTY_IEN   0x08
-// #define 	WK2XXX_TFTRIG_IEN    0x04
-// #define 	WK2XXX_RXOVT_IEN     0x02
-// #define 	WK2XXX_RFTRIG_IEN    0x01
-// //SIFR
-// #define 	WK2XXX_FERR_INT      0x80
-// #define 	WK2XXX_CTS_INT       0x40
-// #define 	WK2XXX_RTS_INT       0x20
-// #define 	WK2XXX_XOFF_INT      0x10
-// #define 	WK2XXX_TFEMPTY_INT   0x08
-// #define 	WK2XXX_TFTRIG_INT    0x04
-// #define 	WK2XXX_RXOVT_INT     0x02
-// #define 	WK2XXX_RFTRIG_INT    0x01
-
-
-// //TFCNT
-// //RFCNT
-// //FSR
-// #define 	WK2XXX_RFOE     0x80
-// #define 	WK2XXX_RFBI     0x40
-// #define 	WK2XXX_RFFE     0x20
-// #define 	WK2XXX_RFPE     0x10
-// #define 	WK2XXX_RDAT     0x08
-// #define 	WK2XXX_TDAT     0x04
-// #define 	WK2XXX_TFULL    0x02
-// #define 	WK2XXX_TBUSY    0x01
-// //LSR
-// #define 	WK2XXX_OE       0x08
-// #define 	WK2XXX_BI       0x04
-// #define 	WK2XXX_FE       0x02
-// #define 	WK2XXX_PE       0x01
-// //FWCR
-// //RS485
-// //常用波特率宏定义
-
-// #define     B600      1
-// #define 	B1200	    2
-// #define 	B2400	    3
-// #define 	B4800     4
-// #define 	B9600	    5
-// #define 	B19200	  6
-// #define 	B38400	  7
-// #define 	B76800	  8
-// #define 	B1800	    9
-// #define 	B3600	    10
-// #define		B7200	    11
-// #define 	B14400	  12
-// #define  	B28800	  13
-// #define	    B57600	  14
-// #define		B115200	  15
-// #define		B230400	  16
-
-// // typedef int (*wk2xxx_send_fun)(void *send_obj,char *buf,uint32_t size);
-
-// typedef void (*wk2xxx_sub_uart_recv_fun)( void *recv_obj, uint8_t *buf, uint32_t size );  //< 子串口接收数据回调函数
-// typedef int (*wk2xxx_send_fun)( void *send_obj, uint8_t *buf, uint32_t size );            //< wk2114发送函数
-
-// /* 发送数据的buf  size*/
-// struct wk2114_send_record
-// {
-//     uint32_t size;
-//     uint8_t *p_data;
-// };
-
-// /*子串口*/
-// struct wk2114_sub_uart
-// {
-//     uint8_t flag;                               //< 标志位
-//     uint8_t cmd;                                //< 上一次的子串口寄存器读命令
-//     uint8_t reg;                                //< 上一次接收到的子串口寄存器
-//     uint8_t uart_index;                         //< 串口地址
-//     void *recv_obj;                           //< 接收回调函数的第一个参数
-//     wk2xxx_sub_uart_recv_fun recv_fun;          //< 接收回调函数
-//     uint8_t *recv_buf;                          //< 接收缓冲区
-//     uint8_t *send_buf;                          //< 当前发送数据指针
-//     uint32_t recv_buf_p;                        //< 接收缓冲区计数
-//     uint32_t recv_buf_size;                     //< 接收缓冲区大小
-//     uint32_t send_buf_p;                        //< 发送缓冲区计数
-//     struct wk2114_send_record send_record[8];   //< 发送记录
-
-//     WK2xxx_TypeDef *wk2114;                      //< wk2114结构指针
-// };
-
-
-// /*主串口 主spi*/
-// typedef struct 
-// {
-// 	// UART_HandleTypeDef *huart;
-//     uint8_t flag;                           //< 标志位
-//     uint8_t cmd;                            //< 上一次的全局寄存器读命令
-//     uint8_t reg;                            //< 上一次接收到的全局寄存器
-//     uint32_t dev_clock_hz;                  //< wk2114时钟源频率
-//     uint8_t cmd_buf[64][2];                 //< 命令队列缓冲区
-//     uint8_t send_buf[18];                   //< 发送缓冲区
-// 	void *send_obj;							//< 主spi  
-// 	wk2xxx_send_fun send;
-// 	EXTI_HandleTypeDef *exti;
-// 	uint8_t trans_mode; /* 0 :polling, 1: IT  2: DMA*/
-
-// 	struct wk2114_sub_uart *sub_uart[4];    //< 子串口
-// }WK2xxx_TypeDef;
-
-// WK2xxx_TypeDef* WK2XXX_Init( void );
-
-// void WK2xxx_EXTI_callback( WK2xxx_TypeDef *wk2xxx );
-
-
-// void Wk2xxxWriteReg( unsigned char port, unsigned char reg, unsigned char dat );
-// unsigned char Wk2xxxReadReg( unsigned char port, unsigned char reg );
-// void Wk2xxxWriteFifo( unsigned char port,unsigned char *wbuf,unsigned int len );
-// void Wk2xxxReadFifo( unsigned char port,unsigned char *rbuf,unsigned int len );
-// void Wk2xxxInit( unsigned char port );
-// void Wk2xxxClose( unsigned char port );
-// void Wk2xxxSetBaud( unsigned char port, int baud );
-// unsigned int Wk2xxxGetBuf( unsigned char port,unsigned char *getbuf );
-// unsigned int Wk2xxxSendBuf( unsigned char port,unsigned char *sendbuf,unsigned int len );
-
-// extern void WK2XXX_SPI_Init(void);
-// extern void WK2XXX_Reset_Init(void);
-// extern void WK2XXX_RST_Init(void);

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 .... ");
+
+    // }

device/Src/bsp_i2c_ads1115.c

@@ -22,31 +22,20 @@ const osEventFlagsAttr_t ads1115Event_attributes = {
   .name = "ads1115Event"
 };
 
-uint16_t  resultbuf[1] = {0};
-double  result_double = 0;
 
-// ads1115EventHandle = osEventFlagsNew (&ads1115Event_attributes);
-//  typedef enum
-// {
-//     EV_READY,                   /*!< Startup finished. */
-//     EV_FRAME_RECEIVED,          /*!< Frame received. */
-//     EV_EXECUTE,                 /*!< Execute function. */
-//     EV_FRAME_SENT               /*!< Frame sent. */
-// } eMBEventType;
-// osEventFlagsSet(modbusEventHandle,eEvent);
-    // osEventFlagsClear (osEventFlagsId_t ef_id, uint32_t flags)
-// recvedEvent = osEventFlagsWait (modbusEventHandle,
-//                                     EV_READY | EV_FRAME_RECEIVED | EV_EXECUTE |
-//                                         EV_FRAME_SENT, /* 接收任务感兴趣的事件                                                       */
-//                                     0,  
-//                                     portMAX_DELAY); /* 指定超时事件,无限等待 */
+I2C_HELPER_TypeDef *ads1115_i2c_helper;
+
+// uint16_t  resultbuf[1] = {0};
+// double  result_double = 0;
 
 ADS1115_TypeDef my_ads1115 =
 {
         ads1115_init,
         ads1115_port,
-        ads1115_get_data_start,
-        NULL,
+        ads1115_test,
+        ads1115_start,
+        ads1115_stop,
+        // NULL,
         ADS1115_REG_CONFIG_OS_START,
         ADS1115_REG_CONFIG_MUX_SINGLE_0,
         ADS1115_REG_CONFIG_PGA_4,
@@ -62,14 +51,18 @@ ADS1115_TypeDef my_ads1115 =
         { 0, 0, 0 },
         ADS1115_OUTPUT_UNIT_mv,  // 默认输出毫伏
         0,
-        0.0,
+        0.0,  //  coeff  放大1000
+        0.0,   // voltage——mv
         ADS1115_WORK_STATE_WAITING,
+        0,
 };
 
 void ads1115_task(void)
 {
     uint8_t rx_data[2] = {0};
-    uint32_t event_flags = 0;
+    my_ads1115.event_flag = 0;
+    uint64_t  ticks;
+    int err_con = 0;
     int st;
 
     for ( ; ; )
@@ -83,270 +76,141 @@ void ads1115_task(void)
         case ADS1115_WORK_STATE_START:
             break;     
 
-        case ADS1115_WORK_STATE_INIT:
-            log_e( " ADS1115 init  ********** %d"  ,pADS1115_I2C->State  );
-
-            my_ads1115.config_H = my_ads1115.config_os|my_ads1115.config_mux
-                        |my_ads1115.config_PGA|my_ads1115.config_MODE;
-            my_ads1115.config_L = my_ads1115.config_DR|my_ads1115.config_COMP_MODE|my_ads1115.config_COMP_POL
-                    |my_ads1115.config_COMP_LAT|my_ads1115.config_COMP_QUE ;
+        case ADS1115_WORK_STATE_TEST:
+            log_e( " ADS1115 test  ********** %d"  ,pADS1115_I2C->State  );
+            ads1115_get_reg_data( );
 
-            my_ads1115.reg_data[0] = 0x01;                 //  point addr  8bit  配置寄存器
-            my_ads1115.reg_data[1] = my_ads1115.config_H;  //  config_reg 高位
-            my_ads1115.reg_data[2] = my_ads1115.config_L;  //  config_reg 低位
-
-            // while(  HAL_I2C_Master_Transmit(pADS1115_I2C, ADS1115_WRITE_ADDRESS, my_ads1115.reg_data, 3 ,1000)!= HAL_OK)
-            // {
-            //     if (HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF)
-            //     {
-            //         log_w("ads1115 0x01 Reg  error!!!\r\n");
-            //     }
-            // }
-            st = HAL_I2C_Master_Transmit(pADS1115_I2C, ADS1115_WRITE_ADDRESS, my_ads1115.reg_data, 3 ,1000);
-            // st = HAL_I2C_Master_Transmit_IT(pADS1115_I2C, ADS1115_WRITE_ADDRESS, my_ads1115.reg_data, 3 );
-      
+            I2C_HELPER_Set_mem_addr( ads1115_i2c_helper, 0x01 );
+            st = I2C_HELPER_Trans( ads1115_i2c_helper, my_ads1115.reg_data, 2 );
             if ( st != HAL_OK)
             {
-                log_w( " ADS1115 init  ********** trans error "  );
+                log_w( " ADS1115 init  **********  trans error "  );
                 my_ads1115.state = ADS1115_WORK_STATE_ERROR;;
                 break;
             } 
-            my_ads1115.state =ADS1115_WORK_STATE_GET_DATA_READY;
-
-            // event_flags = osEventFlagsWait ( ads1115EventHandle, ADS1115_Event_INIT, 0 , portMAX_DELAY );
-            // if (event_flags && ADS1115_Event_INIT)
-            // {
-            //     my_ads1115.state =ADS1115_WORK_STATE_READY_GET_DATA;
-            // }
-            
+            ticks =  osKernelGetTickCount();
+            err_con = 0;
+            my_ads1115.state = ADS1115_WORK_STATE_TESTING;
             continue; 
-        case ADS1115_WORK_STATE_GET_DATA_READY:
-            // log_w( " ADS1115 Ready  ********** %d"  ,pADS1115_I2C->State  );
-
-            osDelay(20);
-            break;   
-        case ADS1115_WORK_STATE_GET_DATA_START:
-            log_w( " ADS1115 GET_DATA_START  ********** %d"  ,pADS1115_I2C->State  ); 
-            my_ads1115.result_int16 = 0;
-            my_ads1115.voltage_mv = 0.0;
-            while(  HAL_I2C_Master_Transmit(pADS1115_I2C, ADS1115_WRITE_ADDRESS, my_ads1115.reg_data, 3 ,1000)!= HAL_OK)
+        case ADS1115_WORK_STATE_TESTING:
+            if ( osKernelGetTickCount() - ticks > 1000 )
             {
-                if (HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF)
+                err_con++;
+                if( err_con >3)
                 {
-                    log_w("ads1115 01 Register error!!!\r\n");
+                    log_w( " ADS1115 testing  ******** error "  );
+                    my_ads1115.state = ADS1115_WORK_STATE_ERROR;
                 }
+                my_ads1115.state = ADS1115_WORK_STATE_TEST;                
             }
-            my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_Convert_Register;
+            osDelay(1);
+            continue;
+        case ADS1115_WORK_STATE_TEST_OK:
+            log_w( " ADS1115 TEST_OK  ********** %d"  ,pADS1115_I2C->State  );
+            my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_READY;
+            // TODO Stop  DMA   
             continue;
-        case ADS1115_WORK_STATE_GET_DATA_Convert_Register:
-            log_i( " ADS1115 Ready  **********  Convert_Register "  );
 
-            while (HAL_I2C_Master_Transmit(pADS1115_I2C, ADS1115_WRITE_ADDRESS, 0x00, 1, 2000) != HAL_OK)
+        case ADS1115_WORK_STATE_GET_DATA_READY:
+            osDelay(1);
+            continue; 
+
+        case ADS1115_WORK_STATE_GET_DATA_START:
+            log_w( " ADS1115 GET_DATA_START  ********** %d " , pADS1115_I2C->State  ); 
+            my_ads1115.result_int16 = 0 ;
+            my_ads1115.voltage_mv   = 0.0 ;
+            ads1115_get_reg_data( );
+            ads1115_get_coeff( );
+            my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_SET_REG01;
+            continue;
+       case ADS1115_WORK_STATE_GET_DATA_SET_REG01:
+            I2C_HELPER_Set_mem_addr( ads1115_i2c_helper, 0x01 );
+            st = I2C_HELPER_Trans( ads1115_i2c_helper, my_ads1115.reg_data, 2 );
+            if ( st != HAL_OK)
             {
-                if (HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF)
+                log_w( " ADS1115 init  **********  trans error "  );
+                my_ads1115.state = ADS1115_WORK_STATE_ERROR;;
+                break;
+            } 
+            ticks =  osKernelGetTickCount();
+            err_con = 0;
+            my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_SET_REG01_Wait;
+            continue;
+        case ADS1115_WORK_STATE_GET_DATA_SET_REG01_Wait:
+            if ( osKernelGetTickCount() - ticks > 1000 )
+            {
+                err_con++;
+                if( err_con >3)
                 {
-                    printf("ads1115 convert Register error!!!\r\n");
+                    log_w( " ADS1115 set reg   ******** error "  );
+                    my_ads1115.state = ADS1115_WORK_STATE_ERROR;
                 }
+                my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_START;                
             }
-            my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_RCV;
- 
-
-            // // osEventFlagsClear( ads1115TaskHandle, ADS1115_Event_Get_Data );  
-            // st = HAL_I2C_Master_Transmit (pADS1115_I2C, ADS1115_WRITE_ADDRESS, 0x00, 1 ,1000);
-            // if ( st != HAL_OK)
-            // {
-            //     log_e( " ADS1115 init  ********** Convert_Register error "  );
-            //     my_ads1115.state = ADS1115_WORK_STATE_ERROR;
-            //     break;
-            // } 
-            // if ( HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF )
-            // {
-            //     log_e("ads1115 read data error!!!\r\n");
-            //     break;
-            // } 
-            // my_ads1115.state =ADS1115_WORK_STATE_GET_DATA_RCV;
-            // if  (HAL_I2C_Master_Transmit_IT(pADS1115_I2C, ADS1115_WRITE_ADDRESS, 0x00, 1 ) != HAL_OK) {
-            //      my_ads1115.state =ADS1115_WORK_STATE_ERROR;
-            // }
-            // if ( HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF )
-            // {
-            //     printf("ads1115 convert Register error!!!\r\n");
-            // } 
-
-            // event_flags = osEventFlagsWait ( ads1115EventHandle, 
-            //         ADS1115_Event_Get_Data_Convert_Register, 0 , portMAX_DELAY );
-            //  if (event_flags && ADS1115_Event_Get_Data_Convert_Register)
-            // {
-            //     my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_RCV;
-            // }
- 
-            continue;    
+            osDelay(1);
+            continue; 
         case ADS1115_WORK_STATE_GET_DATA_RCV:
             log_i( " ADS1115 Ready  ********** _DATA_RCV   "   );
-
-            int16_t data;
-            // uint8_t rx_data[2] = {0};
             memset( rx_data,0,2);
-        
-            // 读两位
-            // while (HAL_I2C_Master_Receive(pADS1115_I2C, ADS1115_READ_ADDRESS, (uint8_t*)resultbuf, 2, 2000) != HAL_OK)
-            while (HAL_I2C_Master_Receive(pADS1115_I2C, ADS1115_READ_ADDRESS, rx_data, 2, 2000) != HAL_OK)
+            I2C_HELPER_Set_mem_addr(ads1115_i2c_helper, 0x00);
+            st = I2C_HELPER_Start_Rcv(ads1115_i2c_helper, rx_data, 2);    
+            if ( st != HAL_OK)
             {
-                if ( HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF )
+                log_w( " ADS1115 init  **********  trans error "  );
+                my_ads1115.state = ADS1115_WORK_STATE_ERROR;;
+                break;
+            }   
+            ticks =  osKernelGetTickCount();
+            err_con = 0;
+            my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_RCV_Wait;
+            continue;
+        case ADS1115_WORK_STATE_GET_DATA_RCV_Wait:
+            if ( osKernelGetTickCount() - ticks > 1000 )
+            {
+                err_con++;
+                if( err_con >3)
                 {
-                    log_e("ads1115 read data error!!!\r\n");
+                    log_w( " ADS1115 data rcv  ******** error "  );
+                    my_ads1115.state = ADS1115_WORK_STATE_ERROR;
                 }
+                my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_START;                
             }
-            my_ads1115.result_int16 = rx_data[0] * 256 + rx_data[1];
-
-
-            log_w( " readout :  %d  %02X %02X %04X",my_ads1115.result_int16 , rx_data[0], rx_data[1],*(uint16_t*)rx_data);
-
-            my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_FLOAT;
-                    continue;
-            osDelay(80);
-
-            // st=HAL_I2C_Master_Receive_IT(pADS1115_I2C, ADS1115_READ_ADDRESS, (uint8_t*)resultbuf, 2 );
-            // if ( st != HAL_OK)
-            // {
-            //     log_e( " ADS1115 init  ********** _DATA_RCV error "  );
-            //     my_ads1115.state = ADS1115_WORK_STATE_ERROR;
-            //     break;
-            // } 
-            // if ( HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF )
-            // {
-            //     log_e("ads1115 read data error!!!\r\n");
-            //     break;
-            // } 
-            // my_ads1115.state =ADS1115_WORK_STATE_GET_DATA_OK;
-            // osEventFlagsClear( ads1115TaskHandle, ADS1115_Event_Get_Data_Convert_Register );  
-            // if ( HAL_I2C_Master_Receive_IT(pADS1115_I2C, ADS1115_READ_ADDRESS, (uint8_t*)resultbuf, 2 ) != HAL_OK )
-            // {
-            //     my_ads1115.state =ADS1115_WORK_STATE_ERROR;
-            // }
-
-            // if ( HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF )
-            // {
-            //     printf("ads1115 read data error!!!\r\n");
-            // }
-
-            // event_flags = osEventFlagsWait ( ads1115EventHandle, 
-            //         ADS1115_Event_Get_Data_RCV, 0 , portMAX_DELAY );
-            //  if (event_flags && ADS1115_Event_Get_Data_RCV)
-            // {
-            //     my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_OK;
-            // }
-            continue;
-        case ADS1115_WORK_STATE_GET_DATA_FLOAT:
-            log_i( " ADS1115 Ready  **********   DATA_FLOAT   %d" ,my_ads1115.result_int16 );
-            // osEventFlagsClear( ads1115TaskHandle, ADS1115_Event_Get_Data_RCV );  
+            osDelay(1);
+            continue; 
+        case ADS1115_WORK_STATE_GET_DATA_OK:
+            log_i( " ADS1115   **********   DATA_OK   %d" ,my_ads1115.result_int16 );
             double val;
+            my_ads1115.result_int16 = rx_data[0] * 256 + rx_data[1];
             if ( (my_ads1115.result_int16  == 0x7FFF) | (my_ads1115.result_int16  == 0X8000)) // 是否超量程了
             {
-                resultbuf[0] = 0;
-                // printf("over PGA\r\n");
+                my_ads1115.result_int16 = 0;
             }
-            switch ((0x0E & my_ads1115.config_H) >> 1) // 量程对应的分辨率
-            {
-            case (0x00):
-                val = (double)my_ads1115.result_int16  * 187.5 / 1000.0; //
-                break;
-            case (0x01):
-                val = (double)my_ads1115.result_int16  * 125 / 1000.0;
-                break;
-            case (0x02):
-                val = (double)my_ads1115.result_int16  * 62.5 / 1000.0;
-                break;
-            case (0x03):
-                val = (double)my_ads1115.result_int16  * 31.25 / 1000.0;
-                break;
-            case (0x04):
-                val = (double)my_ads1115.result_int16  * 15.625 / 1000.0;
-                break;
-            case (0x05):
-                val = (double)my_ads1115.result_int16  * 7.8125 / 1000.0;
-                break;
-            } 
-            my_ads1115.voltage_mv =  (my_ads1115.unit == ADS1115_OUTPUT_UNIT_mv)?val:(val/1000.0);
-            log_i(  " f    %06f",my_ads1115.voltage_mv);
-            my_ads1115.state  = ADS1115_WORK_STATE_GET_DATA_OK ;
+            my_ads1115.voltage_mv =  ((double)my_ads1115.result_int16 *(double) my_ads1115.coeff)/1000.0;;
+            log_i(  " voltage mv :    %06f",my_ads1115.voltage_mv);
+            my_ads1115.state  = ADS1115_WORK_STATE_STOP ;
             break;    
-        case ADS1115_WORK_STATE_GET_DATA_OK:
-            osDelay(10);
-            break;
         case ADS1115_WORK_STATE_ERROR:
             log_w( " ADS1115 error ..... "  );
             // my_ads1115.state  = ADS1115_WORK_STATE_WAITING ;
             osDelay(10);
-            break;    
+            continue;    
         case ADS1115_WORK_STATE_STOP:
             log_w( " ADS1115 stop..... "  );
             // my_ads1115.state  = ADS1115_WORK_STATE_WAITING ;
             osDelay(10);
-            break;  
+            continue;  
         default:
             break;
         }
  
         osDelay(200);
-    }
-    // for (;;)
-    // {
-    //     // 启用中断发送,判断状态, 
-    //     // 地址中断， 确认是哪I2C 设备通讯
-    //     /* code */
-    //     /*  TODO 统一的超时机制 */
-
-    //     /*  事件来管理 */
-    //     event_flags = osEventFlagsWait ( 
-    //             ads1115EventHandle
-    //             , ADS1115_Event_READY|ADS1115_Event_INIT|ADS1115_Event_TRANS_ONLY|ADS1115_Event_DATA_RCV
-    //             , 0
-    //             , portMAX_DELAY );
-    //     if ( event_flags & (ADS1115_Event_READY|ADS1115_Event_INIT) 
-    //                 == (ADS1115_Event_READY|ADS1115_Event_INIT)  )
-    //     {
-    //         // if (HAL_I2C_GetError(&hi2c1)!= HAL_I2C_ERROR_AF)
-    //         // {
-    //         //     Error_Handler();
-    //         // }
-    //         // if (HAL_I2C_GetState(&hi2c1)!= HAL_I2C_STATE_READY)
-    //         // {
-    //         //     Error_Handler();
-    //         // }
-
-    //         osEventFlagsClear(ads1115EventHandle, ADS1115_Event_INIT);
-    //         osEventFlagsSet(ads1115EventHandle, ADS1115_Event_INIT_SUCCESS);
-    //     }
-
-    //     if ( event_flags & ( ADS1115_Event_READY|ADS1115_Event_TRANS_ONLY ) 
-    //                 == (ADS1115_Event_READY|ADS1115_Event_TRANS_ONLY) )
-    //     {
-    //         osEventFlagsClear(ads1115EventHandle, ADS1115_Event_TRANS_ONLY);
-            
-    //     }
-
-    //     if ( event_flags & ( ADS1115_Event_READY|ADS1115_Event_TRANS_FOR_DATA ) 
-    //                 == (ADS1115_Event_READY|ADS1115_Event_TRANS_FOR_DATA) )
-    //     {
-    //         osEventFlagsClear(ads1115EventHandle, ADS1115_Event_TRANS_FOR_DATA);
-    //         osEventFlagsSet(ads1115EventHandle, ADS1115_Event_DATA_RCV);
-            
-    //     }
-    //     if ( event_flags & ( ADS1115_Event_READY|ADS1115_Event_DATA_RCV ) 
-    //                 == ( ADS1115_Event_READY|ADS1115_Event_DATA_RCV ) )
-    //     {
-    //         osEventFlagsClear( ads1115EventHandle, ADS1115_Event_DATA_RCV );           
-    //     }
-    //     // __HAL_I2C_GET_FLAG(&hi2c1, I2C_FLAG_TXE) ;
-    //     osDelay(20);
-    // }   
+    } 
 }
 
 void ads1115_port(void)
 {
-    ads1115TaskHandle = osThreadNew(ads1115_task, NULL, &ads1115Task_attributes);
-    ads1115EventHandle = osEventFlagsNew (&ads1115Event_attributes);
+    ads1115TaskHandle = osThreadNew(ads1115_task, NULL, &ads1115Task_attributes );
+    // ads1115EventHandle = osEventFlagsNew (&ads1115Event_attributes );
 }
 
 /**
@@ -360,28 +224,43 @@ void ads1115_port(void)
  */
 int ads1115_init(void)
 {
-    uint8_t reg_data[3]; 
-    my_ads1115.hi2c= pADS1115_I2C;
-    my_ads1115.config_H = my_ads1115.config_os|my_ads1115.config_mux
-                |my_ads1115.config_PGA|my_ads1115.config_MODE;
-    my_ads1115.config_L = my_ads1115.config_DR|my_ads1115.config_COMP_MODE|my_ads1115.config_COMP_POL
-            |my_ads1115.config_COMP_LAT|my_ads1115.config_COMP_QUE ;
-
-            // log_i(  " %02X  %02X %02X", 0x01,my_ads1115.config_H,my_ads1115.config_L );
-    my_ads1115.reg_data[0] = 0x01;                 //  point addr  8bit  配置寄存器
-    my_ads1115.reg_data[1] = my_ads1115.config_H;  //  config_reg 高位
-    my_ads1115.reg_data[2] = my_ads1115.config_L;  //  config_reg 低位
-            // log_i(  " %02X  %02X %02X", my_ads1115.reg_data[0],my_ads1115.reg_data[1],my_ads1115.reg_data[2] );
+    ads1115_i2c_helper = I2C_HELPER_Init( );
+    I2C_HELPER_Set_Hi2c( ads1115_i2c_helper,  pADS1115_I2C );
+    I2C_HELPER_Set_dev_addr( ads1115_i2c_helper, ADS1115_WRITE_ADDRESS);
+    I2C_HELPER_Set_mem_addr_size( ads1115_i2c_helper,  I2C_MEMADD_SIZE_8BIT );  //I2C_MEMADD_SIZE_16BIT
+    // I2C_HELPER_Set_mem_addr(ads1115_i2c_helper, uint16_t mem_addr);
 
-    // TODO 阻塞式 仅init 使用
-    // my_ads1115.state = ADS1115_WORK_STATE_INIT;
-    // osEventFlagsSet ( ads1115TaskHandle, ADS1115_Event_INIT );
-    if (HAL_I2C_Master_Transmit(pADS1115_I2C, ADS1115_WRITE_ADDRESS, my_ads1115.reg_data, 3,1000 ) != HAL_OK)
-    {
-        return -1;
-    }
+    I2C_HELPER_Setup_Trans_mode( ads1115_i2c_helper, I2C_Trans_IT );
+
+    //  设置回调
+    I2C_HELPER_Set_Callback( ads1115_i2c_helper,  (void *)&my_ads1115, (i2c_callback_fun) ads1115_callback);
+
+    // ads1115_get_reg_data( );
+    // // polling mode test, cfg register : 0x01
+    // int st = 0;
+    // st = HAL_I2C_Mem_Write( ads1115_i2c_helper->hi2c, ADS1115_WRITE_ADDRESS, 0x01, 
+    //         ads1115_i2c_helper->mem_addr_size, my_ads1115.reg_data, 2, 0xFFFF );
+
+    // if (st != HAL_OK)
+    // {
+    //     return -1;
+    // }
     return 0;
+}
 
+int ads1115_test(void)
+{
+    my_ads1115.state = ADS1115_WORK_STATE_TEST;
+}
+
+void ads1115_start(void)
+{
+    my_ads1115.state =ADS1115_WORK_STATE_GET_DATA_START;
+    // osEventFlagsSet( ads1115TaskHandle, ADS1115_Event_Get_Data );
+}
+
+void ads1115_stop(void)
+{
 }
 
 int ads1115_setup(ADS1115_REG_CONFIG_MUX_Diff_TypeDef mux)
@@ -391,6 +270,7 @@ int ads1115_setup(ADS1115_REG_CONFIG_MUX_Diff_TypeDef mux)
     return 0;
 }
 
+
 int16_t ads1115_read_data( )
 {
     int16_t data;
@@ -417,45 +297,54 @@ int16_t ads1115_read_data( )
     return data;
 }
 
-double ads1115_get_voltage_val( )
+double ads1115_get_coeff( )
 {
-    double val;
-    int16_t ad_val;
-    //  TODO  去掉延时，使用寄存器的指示,  setup  和读取数据分开执行
-    // ads1115_setup( pADS1115_I2C, pointADD, configH, configL );
-    ads1115_setup( ADS1115_REG_CONFIG_MUX_SINGLE_0 );
-    
-    HAL_Delay(10);
-    ad_val = ads1115_read_data( pADS1115_I2C );
-    if ( (ad_val == 0x7FFF) | (ad_val == 0X8000)) // 是否超量程了
-    {
-        ad_val = 0;
-        // printf("over PGA\r\n");
-    }
+    my_ads1115.coeff = 1.0;
     switch ((0x0E & my_ads1115.config_H) >> 1) // 量程对应的分辨率
     {
     case (0x00):
-        val = (double)ad_val * 187.5 / 1000.0; //
+        my_ads1115.coeff =my_ads1115.coeff * 187.5 ; //
         break;
     case (0x01):
-        val = (double)ad_val * 125 / 1000.0;
+        my_ads1115.coeff = my_ads1115.coeff * 125 ;
         break;
     case (0x02):
-        val = (double)ad_val * 62.5 / 1000.0;
+        my_ads1115.coeff = my_ads1115.coeff * 62.5;
         break;
     case (0x03):
-        val = (double)ad_val * 31.25 / 1000.0;
+        my_ads1115.coeff = my_ads1115.coeff * 31.25 ;
         break;
     case (0x04):
-        val = (double)ad_val * 15.625 / 1000.0;
+        my_ads1115.coeff = my_ads1115.coeff * 15.625;
         break;
     case (0x05):
-        val = (double)ad_val * 7.8125 / 1000.0;
+        my_ads1115.coeff = my_ads1115.coeff * 7.8125;
         break;
     }
+}
 
-    return (my_ads1115.unit == ADS1115_OUTPUT_UNIT_mv)?val:(val/1000.0);
+double ads1115_get_voltage_val( )
+{
+    double val;
+    int16_t ad_val;
+    //  TODO  去掉延时，使用寄存器的指示,  setup  和读取数据分开执行
+    // ads1115_setup( pADS1115_I2C, pointADD, configH, configL );
+    ads1115_setup( ADS1115_REG_CONFIG_MUX_SINGLE_0 );
+    HAL_Delay(10);
+    ad_val = ads1115_read_data( pADS1115_I2C );
+    if ( (ad_val == 0x7FFF) | (ad_val == 0X8000)) // 是否超量程了
+    {
+        ad_val = 0;
+        // printf("over PGA\r\n");
+    }
+    ads1115_get_coeff( );
+    val = ad_val * my_ads1115.coeff/1000.0;
 
+    if (my_ads1115.unit == ADS1115_OUTPUT_UNIT_v)
+    {
+        val = val/1000.0;
+    }
+    return val;
 }
 
  
@@ -467,64 +356,120 @@ void ads1115_get_data_start(void)
 } 
 
 
-void I2C1_EV_IRQHandler(void)
+void ads1115_callback(ADS1115_TypeDef *pAds1115, uint8_t *buf, uint16_t size)
 {
+    switch (my_ads1115.state)
+    {
+        case ADS1115_WORK_STATE_TESTING :
+            my_ads1115.state++;
+            break;
+        case ADS1115_WORK_STATE_GET_DATA_SET_REG01_Wait :
+            my_ads1115.state++;
+            break;
+        case ADS1115_WORK_STATE_GET_DATA_RCV_Wait :
+            // TODO Check data?
+            my_ads1115.state++;
+            break;        
+        default:
+            break;
+    }
+ 
+} 
  
-    // if (__HAL_I2C_GET_FLAG(&hi2c1, I2C_FLAG_TC) != RESET)
+
+// ads1115EventHandle = osEventFlagsNew (&ads1115Event_attributes);
+//  typedef enum
+// {
+//     EV_READY,                   /*!< Startup finished. */
+//     EV_FRAME_RECEIVED,          /*!< Frame received. */
+//     EV_EXECUTE,                 /*!< Execute function. */
+//     EV_FRAME_SENT               /*!< Frame sent. */
+// } eMBEventType;
+// osEventFlagsSet(modbusEventHandle,eEvent);
+    // osEventFlagsClear (osEventFlagsId_t ef_id, uint32_t flags)
+// recvedEvent = osEventFlagsWait (modbusEventHandle,
+//                                     EV_READY | EV_FRAME_RECEIVED | EV_EXECUTE |
+//                                         EV_FRAME_SENT, /* 接收任务感兴趣的事件                                                       */
+//                                     0,  
+//                                     portMAX_DELAY); /* 指定超时事件,无限等待 */
+    // TODO 阻塞式 仅init 使用
+    // my_ads1115.state = ADS1115_WORK_STATE_INIT;
+    // osEventFlagsSet ( ads1115TaskHandle, ADS1115_Event_INIT );
+
+    // I2C_HELPER_Set_mem_addr(ads1115_i2c_helper, 0x01);
+    // st = I2C_HELPER_Trans(ads1115_i2c_helper, reg_data,2);
+
+    // I2C_HELPER_Set_mem_addr(ads1115_i2c_helper, 0x00);
+    // st = I2C_HELPER_Start_Rcv(ads1115_i2c_helper, rx_data, 2);
+
+
+
+
+
+    // st = HAL_I2C_Mem_Write(ads1115_i2c_helper->hi2c, ads1115_i2c_helper->dev_addr, my_ads1115.reg_data[0],ads1115_i2c_helper->mem_addr_type ,  reg_data,2,0xFFFF);
+    // if (HAL_I2C_Master_Transmit(pADS1115_I2C, ADS1115_WRITE_ADDRESS, my_ads1115.reg_data, 3,1000 ) != HAL_OK)
     // {
-    // log_i( " i2c master send cplt  ******");
+    //     return -1;
+    // }
+    // while (HAL_I2C_Master_Transmit(pADS1115_I2C, ADS1115_WRITE_ADDRESS, 0x00, 1, 2000) != HAL_OK)
+    // {
+    //     if (HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF)
+    //     {
+    //         printf("ads1115 convert Register error!!!\r\n");
+    //     }
+    // }
+    // // 读两位
+    // while (HAL_I2C_Master_Receive(pADS1115_I2C, ADS1115_READ_ADDRESS, rx_data, 2, 2000) != HAL_OK)
+    // {
+    //     if ( HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF )
+    //     {
+    //         printf("ads1115 read data error!!!\r\n");
+    //     }
     // }
 
-    log_i( " i2c master send cplt  ******");
-  
-    HAL_I2C_EV_IRQHandler(&hi2c1);
- 
-}
 
- 
-void I2C1_ER_IRQHandler(void)
-{
- 
-  HAL_I2C_ER_IRQHandler(&hi2c1);
- 
-}
- 
 
-// void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c)
-// {
-//     log_i( " i2c master send cplt  ------------------- ");
-//     if (my_ads1115.state = ADS1115_WORK_STATE_INIT)
-//     {
-//         osEventFlagsSet( ads1115TaskHandle, ADS1115_Event_INIT );   
-//     }
-//     if (my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_Convert_Register)
-//     {
-//         osEventFlagsSet( ads1115TaskHandle, ADS1115_Event_Get_Data_Convert_Register );   
-//     }
-//     //    //发送完成回调函数 
-//     //    {
-//     //         //一些其他操作
-//     //     }
-//     //    HAL_I2C_Master_Receive_IT(&I2cHandle,i2c_slave_recv,I2C_REC_BYTES);
-//     //     {
-//     //         //一些其他操作
-//     //     }
-// }
+
+            // case ADS1115_WORK_STATE_GET_DATA_Convert_Register:
+            // log_i( " ADS1115 Ready  **********  Convert_Register "  );
+
+            // while (HAL_I2C_Master_Transmit(pADS1115_I2C, ADS1115_WRITE_ADDRESS, 0x00, 1, 2000) != HAL_OK)
+            // {
+            //     if (HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF)
+            //     {
+            //         printf("ads1115 convert Register error!!!\r\n");
+            //     }
+            // }
+            // my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_RCV;
  
-// void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c)
-// {
-//     log_i( " i2c master rx cplt  ------------------- ");
-//     //    //接收完成回调函数
-//     //     {
-//     //         //一些其他操作
-//     //     }
-//     //     HAL_I2C_Slave_Transmit_IT(&I2cHandle,send_buffer,send_cnt);
-//     //     {
-//     //         //一些其他操作
-//     //     }
-// }
+
+            // // // osEventFlagsClear( ads1115TaskHandle, ADS1115_Event_Get_Data );  
+            // // st = HAL_I2C_Master_Transmit (pADS1115_I2C, ADS1115_WRITE_ADDRESS, 0x00, 1 ,1000);
+            // // if ( st != HAL_OK)
+            // // {
+            // //     log_e( " ADS1115 init  ********** Convert_Register error "  );
+            // //     my_ads1115.state = ADS1115_WORK_STATE_ERROR;
+            // //     break;
+            // // } 
+            // // if ( HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF )
+            // // {
+            // //     log_e("ads1115 read data error!!!\r\n");
+            // //     break;
+            // // } 
+            // // my_ads1115.state =ADS1115_WORK_STATE_GET_DATA_RCV;
+            // // if  (HAL_I2C_Master_Transmit_IT(pADS1115_I2C, ADS1115_WRITE_ADDRESS, 0x00, 1 ) != HAL_OK) {
+            // //      my_ads1115.state =ADS1115_WORK_STATE_ERROR;
+            // // }
+            // // if ( HAL_I2C_GetError(pADS1115_I2C) != HAL_I2C_ERROR_AF )
+            // // {
+            // //     printf("ads1115 convert Register error!!!\r\n");
+            // // } 
+
+            // // event_flags = osEventFlagsWait ( ads1115EventHandle, 
+            // //         ADS1115_Event_Get_Data_Convert_Register, 0 , portMAX_DELAY );
+            // //  if (event_flags && ADS1115_Event_Get_Data_Convert_Register)
+            // // {
+            // //     my_ads1115.state = ADS1115_WORK_STATE_GET_DATA_RCV;
+            // // }
  
-// void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c)
-// {
-//        //错误异常回调函数
-// }
+            // continue;

device/Src/bsp_i2c_soft.c

@@ -0,0 +1,295 @@
+#include "bsp_i2c_soft.h"
+#include "elog.h"
+// #include "delay.h"
+ 
+void IIC_Init(const IIC_SOFT_TypeDef *pSoftIIC )
+{
+    GPIO_InitTypeDef GPIO_Initure;
+    
+    __HAL_RCC_GPIOB_CLK_ENABLE();   		// 使能GPIOB时钟
+
+    //PB6  SCL PB7初始化设置
+    GPIO_Initure.Pin	= pSoftIIC->scl_pin ;
+    GPIO_Initure.Mode	= GPIO_MODE_OUTPUT_PP;  // 推挽输出
+    GPIO_Initure.Pull	= GPIO_PULLUP;          // 上拉
+    GPIO_Initure.Speed	= GPIO_SPEED_FAST;     // 快速
+    HAL_GPIO_Init( pSoftIIC->scl_port, &GPIO_Initure );
+
+    //  SDA PB7 初始化设置
+    GPIO_Initure.Pin	= pSoftIIC->sda_pin;
+    HAL_GPIO_Init( pSoftIIC->sda_port, &GPIO_Initure ); 
+    
+    GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);
+    GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1);  
+}
+
+
+int IIC_READ_SDA_Pin(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+    return HAL_GPIO_ReadPin(pSoftIIC->sda_port,pSoftIIC->sda_pin);
+}
+
+int IIC_SDA_Mode_In(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+    // 取针脚号 pin6 的值为 2^6
+    // GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);
+    pSoftIIC->sda_port->MODER&=~(3<<(pSoftIIC->sda_pin_num*2));
+    pSoftIIC->sda_port->MODER|=0<<pSoftIIC->sda_pin_num*2;
+}
+int IIC_SDA_Mode_Out(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+    // GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);
+    pSoftIIC->sda_port->MODER&=~(3<<(pSoftIIC->sda_pin_num*2));
+    pSoftIIC->sda_port->MODER|=1<<pSoftIIC->sda_pin_num*2;
+}
+//产生IIC起始信号
+void IIC_Start(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+	// SDA_OUT();//sda线输出
+    IIC_SDA_Mode_Out( pSoftIIC); //sda线输出   
+ 
+	GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);	  	  
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1);
+	delay_us(4);
+ 	GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 0);		//START:when CLK is high,DATA change form high to low 
+	delay_us(4);
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);//钳住I2C总线，准备发送或接收数据 
+}	 
+
+//产生IIC停止信号
+void IIC_Stop(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+	// SDA_OUT();//sda线输出
+    IIC_SDA_Mode_Out( pSoftIIC); //sda线输出  
+
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);
+	GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 0);//STOP:when CLK is high DATA change form low to high
+ 	delay_us(4);
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1); 
+	GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);//发送I2C总线结束信号
+	delay_us(4);							   	
+}
+//等待应答信号到来
+//返回值：1，接收应答失败
+//        0，接收应答成功
+int IIC_Wait_Ack(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+	uint8_t ucErrTime=0;
+	// SDA_IN();      //SDA设置为输入  
+    IIC_SDA_Mode_In( pSoftIIC); //SDA设置为输入  
+
+	GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);delay_us(1);	   
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1);delay_us(1);	 
+	while(IIC_READ_SDA_Pin(pSoftIIC))
+	// while( READ_SDA() )
+	{
+		ucErrTime++;
+		if(ucErrTime>250)
+		{
+			IIC_Stop(pSoftIIC);
+			return 1;
+		}
+	}
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);//时钟输出0 	   
+	return 0;  
+} 
+//产生ACK应答
+void IIC_Ack(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);
+
+	// SDA_OUT();//sda线输出
+    IIC_SDA_Mode_Out( pSoftIIC); //sda线输出  
+
+	GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 0);
+	delay_us(2);
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1);
+	delay_us(2);
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);
+}
+//不产生ACK应答		    
+void IIC_NAck(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);
+
+	// SDA_OUT();//sda线输出
+    IIC_SDA_Mode_Out( pSoftIIC); //sda线输出  
+
+	GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, 1);
+	delay_us(2);
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1);
+	delay_us(2);
+	GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);
+}					 				     
+//IIC发送一个字节
+//返回从机有无应答
+//1，有应答
+//0，无应答			  
+int IIC_Send_Byte(const IIC_SOFT_TypeDef *pSoftIIC, uint8_t txd)
+{                        
+    uint8_t t;   
+	// SDA_OUT();//sda线输出
+    IIC_SDA_Mode_Out( pSoftIIC); //sda线输出  
+
+    GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);//拉低时钟开始数据传输
+    for(t=0;t<8;t++)
+    {              
+        // IIC_SDA=(txd&0x80)>>7;
+        // IIC_SDA( (txd&0x80)>>7);
+        GPIO_WRITE_PIN(pSoftIIC->sda_port, pSoftIIC->sda_pin, (txd&0x80)>>7 );
+        txd<<=1; 	  
+		delay_us(2);    
+		GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1);
+		delay_us(2); 
+		GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0);	
+		delay_us(2);
+    }	
+	return 0; 
+} 	    
+
+int IIC_Read_Byte( const IIC_SOFT_TypeDef *pSoftIIC)
+{
+	unsigned char i,receive=0;
+
+	// SDA_IN();      //SDA设置为输入  
+    IIC_SDA_Mode_In( pSoftIIC); //SDA设置为输入  
+
+    for(i=0;i<8;i++ )
+	{
+        GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 0); 
+        delay_us(2);
+		GPIO_WRITE_PIN(pSoftIIC->scl_port, pSoftIIC->scl_pin, 1);
+        receive<<=1;
+        if(IIC_READ_SDA_Pin(pSoftIIC))receive++;   
+        // if( READ_SDA() )receive++;   
+
+		delay_us(1); 
+    }					 
+ 
+    return receive;
+}
+
+// 发送Slave_Addr 带应答， 兼容7bit  10bit
+int IIC_Send_Slave_Addr(const IIC_SOFT_TypeDef *pSoftIIC,uint8_t r_w)
+{
+    if( pSoftIIC->slave_address_width == I2C_SW_Slave_Address_7Bit )
+    {
+		log_i("salve adrr %02X  %02X",pSoftIIC->addr, (pSoftIIC->addr << 1)|r_w);
+        IIC_Send_Byte(pSoftIIC, (pSoftIIC->addr << 1) | r_w);
+		if(IIC_Wait_Ack(pSoftIIC)) 	{ IIC_Stop(pSoftIIC); return -1;}; 
+    }
+    else if( pSoftIIC->slave_address_width == I2C_SW_Slave_Address_10Bit )
+    {
+        uint8_t h_addr = 0x0F00 | ((pSoftIIC->addr >> 8 & 0x03) << 2) | r_w;
+        IIC_Send_Byte(pSoftIIC, h_addr);
+		if(IIC_Wait_Ack(pSoftIIC)) 	{ IIC_Stop(pSoftIIC); return -1;}; 
+
+        uint8_t l_addr = pSoftIIC->addr & 0xff;
+        IIC_Send_Byte(pSoftIIC, l_addr);
+		if(IIC_Wait_Ack(pSoftIIC)) 	{ IIC_Stop(pSoftIIC); return -1;}; 
+    }
+    return 0;
+}
+
+// 发送reg_addr  带应答， 兼容8bit  16bit  32bit
+int IIC_Send_Reg_Addr( const IIC_SOFT_TypeDef *pSoftIIC, uint32_t reg_addr )
+{
+    for(int j = 0; j < pSoftIIC->slave_reg_addr_width; j++)
+    {
+        uint8_t offset = (pSoftIIC->slave_reg_addr_width - 1 - j) * 8;
+        uint8_t temp_reg_addr = (reg_addr >> offset) & 0xff;
+
+       IIC_Send_Byte(pSoftIIC, temp_reg_addr);
+		if(IIC_Wait_Ack(pSoftIIC)) 	{ IIC_Stop(pSoftIIC); return -1;}; 
+
+    }
+    return 0;
+}
+
+int IIC_Send_One_Reg_Value( const IIC_SOFT_TypeDef *pSoftIIC, uint32_t reg_val )
+{
+    for(int k = 0; k < pSoftIIC->slave_reg_value_width; k++)
+    {
+        uint8_t offset = (pSoftIIC->slave_reg_value_width - 1 - k) * 8;
+
+        i2c_send_byte(pSoftIIC, (reg_val >> offset) & 0xff);
+        if(!i2c_wait_ack(pSoftIIC))
+            return false;
+    }
+    return 0;
+}
+
+int IIC_Send_Receive_One_Reg_Value( const IIC_SOFT_TypeDef *pSoftIIC, uint32_t* reg_val, uint8_t ack )
+{
+    for(int k = 0; k < pSoftIIC->slave_reg_value_width; k++)
+    {
+        uint8_t offset = (pSoftIIC->slave_reg_value_width - 1 - k) * 8;
+        *reg_val |= (IIC_Read_Byte(pSoftIIC) << offset);
+
+        if(ack)
+            i2c_ack(pSoftIIC);
+        else
+            i2c_no_ack(pSoftIIC);
+    }
+
+    return 0;
+}
+
+
+ int IIC_Write_Buf(const IIC_SOFT_TypeDef *pSoftIIC , uint32_t reg_addr, uint8_t *buf, uint8_t len)
+ {
+    IIC_Start(pSoftIIC);  
+	
+	IIC_Send_Slave_Addr( pSoftIIC,I2C_WRITE );
+	IIC_Send_Reg_Addr(  pSoftIIC,  reg_addr );
+
+	for (size_t i = 0; i < len; i++)
+	{
+		IIC_Send_Byte(pSoftIIC,*buf);
+		if(IIC_Wait_Ack(pSoftIIC)) 	{ IIC_Stop(pSoftIIC); return -1;}; 
+        *buf++;
+	}
+
+    IIC_Stop(pSoftIIC);//产生一个停止条件 
+	// HAL_Delay( 200 );
+	// delay_us(6000);
+	return 0;
+}
+
+// 寄存器地址 8位置
+int IIC_Read_Buf(const IIC_SOFT_TypeDef *pSoftIIC, uint32_t reg_addr, uint8_t *buf, uint8_t len)
+{
+	uint8_t temp=0;		
+
+    IIC_Start(pSoftIIC);  
+	IIC_Send_Slave_Addr( pSoftIIC,I2C_WRITE );
+	IIC_Send_Reg_Addr(  pSoftIIC,  reg_addr );
+
+	IIC_Start(pSoftIIC);  	  
+	IIC_Send_Slave_Addr( pSoftIIC,I2C_READ );
+	for(int i=0; i<len-1; i++)
+	{
+		*buf=IIC_Read_Byte(pSoftIIC);
+        IIC_Ack(pSoftIIC);  // 应答
+        buf++;
+	}
+	*buf = IIC_Read_Byte(pSoftIIC);// 读非应答
+	IIC_NAck(pSoftIIC);
+	// if(IIC_Wait_Ack()) 	{ IIC_Stop(); return -1;}; 
+
+	IIC_Stop(pSoftIIC);
+	return 0;
+}
+
+
+int IIC_Device_Check(const IIC_SOFT_TypeDef *pSoftIIC)
+{
+    uint8_t ret = 0;
+    IIC_Start(pSoftIIC);  
+
+    ret = IIC_Send_Slave_Addr( pSoftIIC,I2C_WRITE );
+
+    IIC_Stop(pSoftIIC);
+
+    return ret;
+}

device/Src/eeprom.c

@@ -8,170 +8,241 @@
  * @copyright ESEA (c) 2020
  *
  */
+#include "eeprom.h"
 
-// osEventFlagsId_t eepromEventHandle;
-// const osEventFlagsAttr_t eepromEvent_attributes = {
-//     .name = "eepromEvent"
-// };
+osThreadId_t eepromTaskHandle;
+const osThreadAttr_t eepromTask_attributes = {
+  .name = "eepromTask",
+  .stack_size = 256 * 4,
+  .priority = (osPriority_t) osPriorityNormal,
+};
 
+uint8_t  eeprom_read_buf[1024] ={0};
 
-#include "eeprom.h"
 #define pEepromI2C &hi2c1
-EEPROM_TypeDef *eeprom;
+
+I2C_HELPER_TypeDef *eeprom_helper;
+
+// EEPROM_TypeDef *eeprom;
 
 
 My_EEPROM_TypeDef my_eeprom=
 {
-    Eeprom_Init,
-    Eeprom_DeInit,
-    Eeprom_Port,
+    Eeprom_Init,  Eeprom_Port,  Eeprom_Test,
+ 
     AT24C02,
     EEPROM_MEM_ADDR_TYPE_Bit8,
-    // EEPROM_MEM_ADDR_BIT_10,
     0xA0,   // 7+1 bit or 10 + 1 bit, EEPROM 8bit , write A0 , read  A1
     0,
+    8,
+    0,NULL,
+    0,
 };
 
 void Eeprom_Init()
 {
-    eeprom  = (EEPROM_TypeDef *)malloc(sizeof(EEPROM_TypeDef));
-    if ( eeprom == NULL )
-    {
-        return NULL;
-    }
-    eeprom->hi2c = pEepromI2C;
-    // eeprom->i2chelper = I2CHelper_Init( );
-    // I2CHelper_Set_Hi2c( eeprom->i2chelper, pEepromI2C );
-    Eeprom_SET_Device_Model( eeprom, my_eeprom.model );
-    Eeprom_SET_Device_Addr( eeprom, my_eeprom.dev_addr );
-    Eeprom_SET_Mem_Addr_Type( eeprom, my_eeprom.mem_addr_type );
-
-    eeprom->writeCplt       = 0;
-    eeprom->readCplt        = 0;
-    eeprom->size            = 0;
-    eeprom->is_busy         = 0;
-    eeprom->time_base         = 0;
-    eeprom->write_delay_ms  = 5;
-    eeprom->mem_addr        = 0;
+
+    eeprom_helper = I2C_HELPER_Init( );
+    I2C_HELPER_Set_Hi2c( eeprom_helper,  pEepromI2C );
+    I2C_HELPER_Set_dev_addr( eeprom_helper, EEPROM_WRITE_ADDRESS);
+    I2C_HELPER_Set_mem_addr_size( eeprom_helper,  I2C_MEMADD_SIZE_8BIT );  //I2C_MEMADD_SIZE_8BIT
+    // I2C_HELPER_Set_mem_addr(ads1115_i2c_helper, uint16_t mem_addr);
+
+    // I2C_HELPER_Setup_Trans_mode( eeprom_helper, I2C_Trans_IT );
+
+    //  设置回调
+    I2C_HELPER_Set_Callback( eeprom_helper,  (void *)&my_eeprom, (i2c_callback_fun) Eeprom_callback);
+
     return 0;
 }
 
-void Eeprom_DeInit(  )
+ 
+
+void Eeprom_Port(  )
 {
-    free(eeprom);
+    eepromTaskHandle = osThreadNew(Eeprom_Task, NULL, &eepromTask_attributes );
 }
 
-void Eeprom_Port(  )
+void Eeprom_Task(  )
 {
-    uint32_t  i;
+    uint64_t  ticks;
+    int count = 0;
     int st;
     for (;;)
     {
-        /* 判断size, size 大于零才开始工作*/
-        if (eeprom->size == 0) 
-        {
-            eeprom->send_buf = NULL;
-            eeprom->is_busy == 0;
-            // log_i("eeprom port func...");
-            osDelay(100);
-        };
-
-        /* size> 0, 写入一个数据 */
-        if ( eeprom->size > 0 && eeprom->writeCplt == 0 && eeprom->is_busy == 0 )
+        switch (my_eeprom.state)
         {
-            eeprom->time_base   = osKernelGetTickCount( );
-            eeprom->is_busy     = 1;
-            // log_i("eeporm  write ... "); 
-            st = HAL_I2C_Mem_Write(eeprom->hi2c, eeprom->dev_addr, AT24C02, eeprom->mem_addr_type, eeprom->send_buf, 1, eeprom->write_delay_ms);
-            if (st != HAL_OK) {
-                log_e(" Eeprom Write error");
-                eeprom->size        = 0;
-                eeprom->send_buf    = NULL;
-                eeprom->is_busy     = 0;        
-                break;        
+        case EEPROM_WORK_STATE_WAITING:
+            log_d( " eeporm waiting  ********** "  );
+            osDelay(20);
+            break;
+        case EEPROM_WORK_STATE_READY:
+            // log_d( " eeporm ready  ********** "  );
+            osDelay(1);
+            break;
+        case EEPROM_WORK_STATE_Writing:
+            log_d( " eeporm writing  ********** %d" ,count );
+            if (my_eeprom.size == 0 )
+            {
+                my_eeprom.state = EEPROM_WORK_STATE_STOP;
             }
-            // I2CHelper_Write( eeprom->i2chelper, eeprom->send_buf, 1 );
-            continue;
-        };
-
-        /*  等待 eeprom->write_delay_ms ，写入数据*/
-        if ( eeprom->size > 0 && eeprom->writeCplt == 0 && eeprom->is_busy == 1 )
-        {
-            if( (osKernelGetTickCount( ) - eeprom->time_base)  > eeprom->write_delay_ms)
+            I2C_HELPER_Set_mem_addr( eeprom_helper, count );
+            st = I2C_HELPER_Trans( eeprom_helper, my_eeprom.buf, 1 );
+            ticks =  osKernelGetTickCount();
+            my_eeprom.state = EEPROM_WORK_STATE_WRITE_Waiting;
+            break;   
+        case EEPROM_WORK_STATE_WRITE_Waiting:
+            if (osKernelGetTickCount()-ticks >my_eeprom.write_delay_ms){
+                count++;
+                my_eeprom.size--;
+                my_eeprom.buf++;
+            }
+            if (my_eeprom.size> 0 )
             {
-                // log_i("eeporm  write ... 5ms "); 
-                eeprom->writeCplt = 1 ;
+                my_eeprom.state = EEPROM_WORK_STATE_Writing;
+                continue;
             }
-            continue;
-        };
-
-        /* 写完成，处理数据等待进入下一组 */
-        if ( eeprom->size > 0 && eeprom->writeCplt == 1 )
-        {
-            eeprom->send_buf++;
-            eeprom->mem_addr++;
-            eeprom->size--;
-            eeprom->is_busy = 0; 
-            eeprom->writeCplt = 0;
-            continue;
-        };
-        osDelay( 1);
+            my_eeprom.state = EEPROM_WORK_STATE_STOP;
+            count = 0;
+            break;
+        case EEPROM_WORK_STATE_Reading:
+            I2C_HELPER_Set_mem_addr(eeprom_helper, 0);
+            while( I2C_HELPER_Start_Rcv( eeprom_helper, eeprom_read_buf, 24 ) != HAL_OK )
+            {
+                osDelay(1);
+            }
+            // log_d( "  eeprom_read_buf **********  %02X   %02X " ,eeprom_read_buf[0],eeprom_read_buf[23] );
+            // 或等到 I2C 状态为 ready
+            // while(i2c_get_state(&i2c_buf)!=0){
+            //     if(time_clock_get_time_offset_ms(&time)>1000){
+            //         return -1;
+            //     }
+            // }
+            my_eeprom.state = EEPROM_WORK_STATE_STOP;
+            break; 
+        case EEPROM_WORK_STATE_ERROR:
+            log_w( " ADS1115 error ..... "  );
+            // my_ads1115.state  = ADS1115_WORK_STATE_WAITING ;
+            osDelay(10);
+            continue;    
+        case EEPROM_WORK_STATE_STOP:
+            log_w( " ADS1115 stop..... "  );
+            // my_ads1115.state  = ADS1115_WORK_STATE_WAITING ;
+            osDelay(10);
+            continue;  
+        default:
+            break;
+        }
+        // /* 判断size, size 大于零才开始工作*/
+        // if (eeprom->size == 0) 
+        // {
+        //     eeprom->send_buf = NULL;
+        //     eeprom->is_busy == 0;
+        //     // log_i("eeprom port func...");
+        //     osDelay(100);
+        // };
+
+        // /* size> 0, 写入一个数据 */
+        // if ( eeprom->size > 0 && eeprom->writeCplt == 0 && eeprom->is_busy == 0 )
+        // {
+        //     eeprom->time_base   = osKernelGetTickCount( );
+        //     eeprom->is_busy     = 1;
+        //     // log_i("eeporm  write ... "); 
+        //     st = HAL_I2C_Mem_Write(eeprom->hi2c, eeprom->dev_addr, AT24C02, eeprom->mem_addr_type, eeprom->send_buf, 1, eeprom->write_delay_ms);
+        //     if (st != HAL_OK) {
+        //         log_e(" Eeprom Write error");
+        //         eeprom->size        = 0;
+        //         eeprom->send_buf    = NULL;
+        //         eeprom->is_busy     = 0;        
+        //         break;        
+        //     }
+        //     // I2CHelper_Write( eeprom->i2chelper, eeprom->send_buf, 1 );
+        //     continue;
+        // };
+
+        // /*  等待 eeprom->write_delay_ms ，写入数据*/
+        // if ( eeprom->size > 0 && eeprom->writeCplt == 0 && eeprom->is_busy == 1 )
+        // {
+        //     if( (osKernelGetTickCount( ) - eeprom->time_base)  > eeprom->write_delay_ms)
+        //     {
+        //         // log_i("eeporm  write ... 5ms "); 
+        //         eeprom->writeCplt = 1 ;
+        //     }
+        //     continue;
+        // };
+
+        // /* 写完成，处理数据等待进入下一组 */
+        // if ( eeprom->size > 0 && eeprom->writeCplt == 1 )
+        // {
+        //     eeprom->send_buf++;
+        //     eeprom->mem_addr++;
+        //     eeprom->size--;
+        //     eeprom->is_busy = 0; 
+        //     eeprom->writeCplt = 0;
+        //     continue;
+        // };
+        osDelay( 10);
     }
 }
 
-// int Eeprom_SET_I2CHelper( EEPROM_TypeDef *eeprom, I2CHelper_TypeDef *i2chelper )
-// {
-//     eeprom->i2chelper = i2chelper;
-//     return 0;
-// }
-
-int Eeprom_SET_Device_Model(EEPROM_TypeDef *eeprom, EEPROM_MODEL_TypeDef model)
+int Eeprom_Test(  )
 {
-    eeprom->model = model;
-    if (eeprom->model < AT24C04 )
-    {
-        eeprom->mem_addr_type = I2C_MEMADD_SIZE_8BIT;
-    }else{
-        eeprom->mem_addr_type = I2C_MEMADD_SIZE_16BIT;
-    }
-    return 0;
-}
+    uint8_t test_send[1] = { 0xFF  };  // 不同model,地址不同  方法也不同
+    uint8_t test_rcv  = 0;
+    int st;
+    //  write
+    I2C_HELPER_Set_mem_addr( eeprom_helper, AT24C02 );
+    st = I2C_HELPER_Trans( eeprom_helper, test_send, 1 );
 
-int Eeprom_SET_Device_Addr(EEPROM_TypeDef *eeprom, uint8_t dev_addr)
-{
-    eeprom->dev_addr = dev_addr;
-    // TODO: 需要对I2C 进行设置
-    return 0;
-}
+    HAL_Delay(my_eeprom.write_delay_ms);
 
-int Eeprom_SET_Mem_Addr ( EEPROM_TypeDef *eeprom, uint16_t mem_addr  )
-{
-    eeprom->mem_addr = mem_addr;
-    return 0;
+    // // Read
+    I2C_HELPER_Set_mem_addr(eeprom_helper, AT24C02);
+    st = I2C_HELPER_Start_Rcv(eeprom_helper, (uint8_t *)&test_rcv , 2);  
+
+    if ( test_rcv == 255 ){
+        return 0;
+    }
+ 
+    return -1;
 }
 
-int Eeprom_SET_Mem_Addr_Type(EEPROM_TypeDef *eeprom, EEPROM_MEM_ADDR_TypeDef mem_addr_type)
+int Eeprom_callback(My_EEPROM_TypeDef *pEeprom, uint8_t *buf, uint16_t size)
 {
-    eeprom->mem_addr_type = mem_addr_type;
-    return 0;
-}
+    // switch (my_eeprom.state)
+    // {
+    //     // case ADS1115_WORK_STATE_TESTING :
+    //     //     my_ads1115.state++;
+    //     //     break;
+    //     // case ADS1115_WORK_STATE_GET_DATA_SET_REG01_Wait :
+    //     //     my_ads1115.state++;
+    //     //     break;
+    //     // case ADS1115_WORK_STATE_GET_DATA_RCV_Wait :
+    //     //     // TODO Check data?
+    //     //     my_ads1115.state++;
+    //     //     break;        
+    //     default:
+    //         break;
+    // }
+ 
+} 
 
-int Eeprom_SET_Mem_Addr_Bit(EEPROM_TypeDef *eeprom, EEPROM_MEM_ADDR_BIT_TypeDef mem_addr_bit)
+int Eeprom_SET_Device_Model(EEPROM_MODEL_TypeDef model)
 {
-    // eeprom->mem_addr_bit = mem_addr_bit;
+    my_eeprom.model = model;
+    if (my_eeprom.model < AT24C04 )
+    {
+        I2C_HELPER_Set_mem_addr_size( eeprom_helper,  I2C_MEMADD_SIZE_8BIT );
+    }else{
+        I2C_HELPER_Set_mem_addr_size( eeprom_helper,  I2C_MEMADD_SIZE_16BIT );
+    }
     return 0;
 }
 
-// int Eeprom_SET_WorkMode( EEPROM_TypeDef *eeprom, I2C_HELPER_MODE_TypeDef mode )
-// {
-//     eeprom->mode = mode;
-//     I2CHelper_Set_Mode( eeprom->i2chelper, mode );
-//     return 0;
-// }
 
-int Eeprom_SET_Write_Delay_ms( EEPROM_TypeDef *eeprom, uint8_t write_delay_ms)
+int Eeprom_SET_Write_Delay_ms(uint8_t write_delay_ms)
 {
-    eeprom->write_delay_ms = write_delay_ms;
+    my_eeprom.write_delay_ms = write_delay_ms;
     return 0;
 }
 
@@ -190,12 +261,10 @@ int Eeprom_SET_Write_Delay_ms( EEPROM_TypeDef *eeprom, uint8_t write_delay_ms)
 
 // }
 
-int Eeprom_Read(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size)
+int Eeprom_Read(  uint8_t * buf, uint16_t size)
 {
-    // osEventFlagsGet(eepromEventHandle, EEPROM_EVT_READ);
-    eeprom->readCplt = 0;
     int st;
-    st = HAL_I2C_Mem_Read( eeprom->hi2c, eeprom->dev_addr, eeprom->mem_addr, eeprom->mem_addr_type, buf, size, 0xFFFF);
+    // st = HAL_I2C_Mem_Read( eeprom->hi2c, eeprom->dev_addr, eeprom->mem_addr, eeprom->mem_addr_type, buf, size, 0xFFFF);
     if ( st != HAL_OK ) {
         return -1;
     }
@@ -203,41 +272,28 @@ int Eeprom_Read(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size)
     // HAL_I2C_Master_Transmit_IT (eeprom->hi2c, eeprom->dev_addr, buf ,size);
 }
 
-// int Eeprom_Write(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size)
-// {
-//     // osEventFlagsGet(eepromEventHandle, EEPROM_EVT_WRITE);
-//     eeprom->writeCplt = 0;
-//     // HAL_I2C_Master_Transmit_IT (eeprom->i2chelper->hi2c, eeprom->dev_addr, buf ,size);
-// }
-
-void Eeprom_Set_Sendbuf_Size(EEPROM_TypeDef *eeprom,  uint8_t * buf, uint16_t size)
+int Eeprom_Write(  uint8_t * buf, uint16_t size)
 {
-    eeprom->send_buf    = buf;
-    eeprom->size        = size;
-    return ;
+    my_eeprom.buf    = buf;
+    my_eeprom.size        = size;
+    int st;
+    // st = HAL_I2C_Mem_Read( eeprom->hi2c, eeprom->dev_addr, eeprom->mem_addr, eeprom->mem_addr_type, buf, size, 0xFFFF);
+    if ( st != HAL_OK ) {
+        return -1;
+    }
+    return 0;
+    // HAL_I2C_Master_Transmit_IT (eeprom->hi2c, eeprom->dev_addr, buf ,size);
 }
+ 
 
-int Eeprom_Test(  )
+void Eeprom_Set_Sendbuf_Size(   uint8_t * buf, uint16_t size)
 {
-    uint8_t test_send[1] = { 0xFF  };  // 不同model,地址不同  方法也不同
-    uint8_t test_rcv  = 0;
-    int st;
-
-    // st  = Eeprom_Write( eeprom,  test_send, 1 );
-    st = HAL_I2C_Mem_Write(eeprom->hi2c, eeprom->dev_addr, AT24C02, eeprom->mem_addr_type, test_send, 1, eeprom->write_delay_ms);
-    osDelay( 10 );
+    my_eeprom.buf    = buf;
+    my_eeprom.size        = size;
+    return ;
+}
 
-    // st = Eeprom_Read( eeprom, &test_rcv, 1);
-    st = HAL_I2C_Mem_Read(eeprom->hi2c, eeprom->dev_addr, AT24C02, eeprom->mem_addr_type, &test_rcv, 1, eeprom->write_delay_ms);
-    osDelay( 5 );
 
-    if ( test_rcv == 255 ){
-        // log_i( " Test Result  :  PASS " );
-        return 0;
-    }
-    // log_i( " Test Result :  Error  st %d  val %d  " , st, test_rcv );
-    return -1;
-}
 
 // //主机模式发送回调函数
 // void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *I2cHandle)

device/Src/i2c_helper.c

@@ -1,142 +0,0 @@
-#include "i2c_helper.h"
-
-// static I2C_HandleTypeDef *pADS1115_I2C = &hi2c1;
-
-// osEventFlagsId_t i2chelperEventHandle;
-// const osEventFlagsAttr_t i2chelperEvent_attributes = {
-//   .name = "i2chelperEvent"
-// };
-
-I2CHelper_TypeDef * I2CHelper_Init( )
-{
-    I2CHelper_TypeDef *Handle = (I2CHelper_TypeDef *)malloc(sizeof(I2CHelper_TypeDef));
-    if (Handle == NULL)
-    {
-        return NULL;
-    }
-	// Handle->delaytime_trans_byte = 0;
-    return Handle;
-}
-void I2CHelper_Set_Hi2c( I2CHelper_TypeDef *i2chelper,  I2C_HandleTypeDef * hi2c  )
-{
-	i2chelper->hi2c = hi2c;
-}
-void I2CHelper_Set_Mode( I2CHelper_TypeDef *i2chelper,  I2C_HELPER_MODE_TypeDef mode  )
-{
-	i2chelper->mode	= mode;
-}
-void I2CHelper_Set_Trans_Type( I2CHelper_TypeDef *i2chelper,  I2C_HELPER_TRANS_TypeDef trans_type  )
-{
-	i2chelper->trans_type	= trans_type;
-}
-void I2CHelper_Set_Rcv_Type( I2CHelper_TypeDef *i2chelper,  I2C_HELPER_RCV_TypeDef rcv_type  )
-{
-	i2chelper->rcv_type	= rcv_type;
-}
-
-int I2CHelper_Set_callback_func_obj( I2CHelper_TypeDef *i2chelper,   void * obj,  it_callback callback )
-{
-	i2chelper->obj	= obj;
-	i2chelper->callback	= callback;
-	return 0;
-}
-
-void I2CHelper_Set_rcv_buf( I2CHelper_TypeDef *i2chelper, uint8_t *buf, uint32_t buf_size )
-{
-	i2chelper->receive_buf	= buf;
-	i2chelper->receive_size	= buf_size;
-	i2chelper->receive_data_con	= 0;
-
-}
-void I2CHelper_Set_Trans_Buf( I2CHelper_TypeDef *i2chelper, uint8_t *buf, uint32_t buf_size )
-{
-	i2chelper->trans_buf	= buf;
-	i2chelper->trans_size	= buf_size;
-	i2chelper->trans_data_con	= 0;
-}
-
-int I2CHelper_Write( I2CHelper_TypeDef *i2chelper,  uint8_t * buf, uint16_t size)
-{
-	// 考虑主从机模式
-	int st = -1;
-	switch ( i2chelper->mode == I2C_HELPER_MODE_MASTER )
-	{
-	case I2C_HELPER_MODE_MASTER:
-		if ( i2chelper->trans_type == I2C_HELPER_TRANS_POLLING )
-		{
-			st = HAL_I2C_Master_Transmit( i2chelper->hi2c, i2chelper->i2c_write_address
-						, buf, size, 0xFFFF );
-		}
-		if ( i2chelper->trans_type == I2C_HELPER_TRANS_IT )
-		{
-			// st = HAL_I2C_Master_Transmit_IT( i2chelper->hi2c, i2chelper->i2c_write_address
-			// 			, buf, size  );	
-			st = HAL_I2C_Master_Transmit_IT( i2chelper->hi2c, i2chelper->i2c_write_address, buf,size  );			
-		}
-		if ( i2chelper->trans_type == I2C_HELPER_TRANS_DMA )
-		{
-			// st = HAL_I2C_Master_Transmit_DMA( i2chelper->hi2c, i2chelper->i2c_write_address
-			// 			, buf, size  );			
-			st = HAL_I2C_Master_Transmit_DMA( i2chelper->hi2c, i2chelper->i2c_write_address, buf, size );		
-		}
-		break;
-	case I2C_HELPER_MODE_SLAVE:
-		break;	
-	default:
-		break;
-	}
-	return st;
-}
-
-int I2CHelper_Read(I2CHelper_TypeDef *i2chelper,  uint8_t * buf, uint16_t size)
-{
-	int st = -1;
-	switch ( i2chelper->mode == I2C_HELPER_MODE_MASTER )
-	{
-	case I2C_HELPER_MODE_MASTER:
-		if ( i2chelper->rcv_type == I2C_HELPER_TRANS_POLLING )
-		{
-			st = HAL_I2C_Master_Receive( i2chelper->hi2c, i2chelper->i2c_write_address
-						, buf, size, 0xFFFF );
-		}
-		if ( i2chelper->rcv_type == I2C_HELPER_TRANS_IT )
-		{
-			// st = HAL_I2C_Master_Transmit_IT( i2chelper->hi2c, i2chelper->i2c_write_address
-			// 			, buf, size  );	
-			st = HAL_I2C_Master_Receive_IT( i2chelper->hi2c, i2chelper->i2c_write_address
-						, buf, size );			
-		}
-		if ( i2chelper->rcv_type == I2C_HELPER_TRANS_DMA )
-		{
-			// st = HAL_I2C_Master_Transmit_DMA( i2chelper->hi2c, i2chelper->i2c_write_address
-			// 			, buf, size  );			
-			st = HAL_I2C_Master_Receive_DMA( i2chelper->hi2c, i2chelper->i2c_write_address
-						, buf, size );		
-		}
-		break;
-	case I2C_HELPER_MODE_SLAVE:
-		break;	
-	default:
-		break;
-	}
-	return st;
-}
-
-int I2CHelper_Flags_Set(I2CHelper_TypeDef *i2chelper,  I2C_HELPER_Event_TypeDef evt_type )
-{
-	return osEventFlagsSet(i2chelper, evt_type);
-}
-
-// int I2CHelper_Flags_Clear(I2CHelper_TypeDef *i2chelper,  I2C_HELPER_Event_TypeDef evt_type )
-// {
-// 	return osEventFlagsClear(i2chelper, evt_type);
-// }
-
-// int I2CHelper_Flags_Wait(I2CHelper_TypeDef *i2chelper,  uint32_t delay )
-// {
-// 	return 	osEventFlagsWait ( 
-//                 i2chelperEventHandle
-//                 , I2C_HELPER_Event_READY|I2C_HELPER_Event_INIT|I2C_HELPER_Event_TRANS_ONLY|I2C_HELPER_Event_DATA_RCV
-//                 , 0
-//                 , delay );
-// }

device/Src/pH.c

@@ -1,412 +1,349 @@
-#include "pH.h"
-#include "elog.h"
-#include "FreeRTOS.h"
-#include "cmsis_os.h"
-#include "stm32f4xx.h"
-#include "usart.h"
-#include "main.h"
+#include "PH.h"
 
- 
-/******           Port             ***************/
-#if 1
+osThreadId_t PH_Handle;
+const osThreadAttr_t PH_attributes = {
+    .name       = "PH",
+    .stack_size = 1024,
+    .priority   = (osPriority_t) osPriorityBelowNormal,
+};
 
-#define  PH_Uart_IRQHandler   USART3_IRQHandler
-// #define  PH_Uart_IRQHandler   USART4_IRQHandler
-UART_HandleTypeDef *pPHUart = &huart3;
-PH_TypeDef *ph ;
+// 事件
+osEventFlagsId_t PH_EventHandle;
+const osEventFlagsAttr_t PH_Event_attributes = {
+  .name = "PH_Event"
+};
 
-My_PH_TypeDef my_pH =
-{
+extern UART_HandleTypeDef huart1;
+UART_HandleTypeDef *pPHUart = &huart1;
+
+// uint8_t PH_TEST_BUF[8]  ={0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x09};
+uint8_t PH_TEST_BUF[8]  ={0x01, 0x03, 0x00, 0x00, 0x00, 0x02, 0xC4, 0x0B};
+uint8_t PH_TRANS_BUF[8]  ={0x01, 0x03, 0x00, 0x00, 0x00, 0x04, 0x44, 0x09};
+uint8_t PH_RCV_BUF[13]  ={0};
+
+UART_HELPER_TypeDef *ph_uart_helper;
+
+PH_TypeDef  ph ={
     PH_Init,
     PH_Port,
     PH_Test,
     PH_Start,
     PH_Stop,
-    SEL_232_485_GPIO_Port,
-    HDPLX_GPIO_Port, 
-    DE485_GPIO_Port,
-    SEL_232_485_Pin,
-    HDPLX_Pin,
-    DE485_Pin,
-    Uart_Interface_Max3160,  /* 接口类型 0: common, 1: 485 ,2:3160*/
-    Uart_RSMODE_485,  /* mode_232_485 0 commome  1:485*/
-    Uart_Trans_DMA,     /* trans_type0 :polling, 1: IT  2: DMA*/
-    Uart_Trans_DMA,     /* rcv_type 0 :polling, 1: IT  2: DMA*/
-    Uart_IDLE_IT_ENABLE,     /* idle_enable_disable 0 :不启用空闲 , 1: 启用空闲*/
-    0,      //ph
-    0,      // temprature
-    NULL, /* pointer huart*/
+    NULL,
+    0,      // state
+    0,      // data_ok
+    {0},    // buf
+    0,      // size_received
+    0,      // time base
+    1000,      // timeout ticks,  1000ms = 1S
+    0,          // event_flag
 };
 
-extern volatile uint8_t measure_flag  ;
+int PH_Init( )
+{
+    ph_uart_helper = UART_HELPER_Init( );
 
-uint8_t PH_SND_Buf[8] = { 0x01, 0x03, 0x00, 0x00, 0x00, 0x02, 0xC4, 0x0B };
-uint8_t PH_RCV_Buf[PH_Rcv_Buf_Size*2]  = { 0 };
+    if (ph_uart_helper ==NULL)  return -1;
 
-osThreadId_t phHandle;
-const osThreadAttr_t PH_attributes = {
-    .name       = "ph",
-    .stack_size = 1024,
-    .priority   = (osPriority_t) osPriorityBelowNormal,
-};
+    // TODO 接口
+    UART_HELPER_Set_Huart( ph_uart_helper, pPHUart );
+    UART_HELPER_Set_Interface_Type(ph_uart_helper, Uart_Interface_Max3160_485);
 
-void PH_Uart_IRQHandler(void)
-{
-    if (__HAL_UART_GET_FLAG( ph->uarthelper->huart, UART_FLAG_TC) != RESET)
-    {
-        // log_i("ph....huart3 TC callback ...");
-        PH_Send_Cplt_Callback(   ph );
-        // ph->state = PH_Status_Send_Cplt; 
-        ph->uarthelper->huart->gState = HAL_UART_STATE_READY;       
-        __HAL_UART_CLEAR_FLAG( ph->uarthelper->huart, UART_FLAG_TC );
-    }
+    //  传输
+    UART_HELPER_Setup_Trans_mode(  ph_uart_helper, Uart_Trans_DMA);
+    // UART_HELPER_Setup_Rcv_mode( ph_uart_helper, Uart_Trans_IT );
+    UART_HELPER_Set_enable_idle(  ph_uart_helper, Uart_IDLE_IT_ENABLE);
+
+    //  回调GPIO 操作 数据操作
+    UART_HELPER_Set_trans_GPIO(  ph_uart_helper, PH_Trans_GPIO );  // enbale rcv
+    UART_HELPER_Set_trans_cplt_GPIO( ph_uart_helper, PH_Trans_Cplt_GPIO );
+
+    UART_HELPER_Set_Callback( ph_uart_helper,&ph, PH_CallBack );
 
-    if (__HAL_UART_GET_FLAG( ph->uarthelper->huart, UART_FLAG_IDLE ) != RESET)
+    // 设置 Buf
+    UART_HELPER_Set_Rcv_Buf(ph_uart_helper, PH_RCV_BUF, sizeof(PH_RCV_BUF));
+    UART_HELPER_Set_Trans_Buf( ph_uart_helper, PH_TRANS_BUF, sizeof(PH_TRANS_BUF) );
+
+    //  GPIO 操作
+    switch (ph_uart_helper->interface_type)
     {
-        uint16_t count = __HAL_DMA_GET_COUNTER( ph->uarthelper->huart->hdmarx );
-        log_i("....huart3 IDLE.... %d   site3 == 4 %02X ", count, PH_RCV_Buf[2] );
-        uint16_t data_length  = 2*PH_Rcv_Buf_Size - count; 
-        if (count == PH_Rcv_Buf_Size) 
-        {            
-            // HAL_UART_DMAStop( ph->uarthelper->huart ); 
-            ph->state = PH_Status_RCV_OK;
-        }
-        if (count < PH_Rcv_Buf_Size) 
-        {            
-            // HAL_UART_DMAStop( ph->uarthelper->huart ); 
-            ph->state = PH_Status_Error;
-        }
-        __HAL_UART_CLEAR_IDLEFLAG( ph->uarthelper->huart );
+        case Uart_Interface_Default:
+            break;
+        case Uart_Interface_485:
+            usart6_send_enable();   
+            break;
+        case Uart_Interface_Max3160_232:
+            PH_MAX3160_232();
+            break;
+        case Uart_Interface_Max3160_485:
+            max3160_485_receive_mode();
+            break;    
+        default:
+            break;
     }
-    HAL_UART_IRQHandler( ph->uarthelper->huart );
+    ph.state = PH_State_Waiting;
+    ph.timebase_ticks = osKernelGetTickCount( );
 }
 
-int PH_Init( )
+void PH_Port( )
 {
-    ph = (PH_TypeDef *)malloc(sizeof(PH_TypeDef));
-
-    UartInterface_TypeDef *interface    = UartInterface_Init( );
-    UartHelper_TypeDef *uarthelper      = UartHelper_Init();
+    PH_Handle = osThreadNew( PH_Task, NULL, &PH_attributes );
+    // PH_EventHandle = osEventFlagsNew(&PH_Event_attributes);
+}
 
-    PH_Set_Uarthelper( ph,  uarthelper );
-    PH_Set_Interface( ph,  interface );
-    PH_Set_Huart( ph, pPHUart );
- 
-    /* set_GPIO  UartInterface */
-    UartInterface_Set_Sel_GPIO_Pin( ph->uarthelper->interface, my_pH.sel_gpio, my_pH.sel_pin );
-    UartInterface_Set_Dplx_GPIO_Pin( ph->uarthelper->interface, my_pH.dplx_gpio, my_pH.dplx_pin );
-    UartInterface_Set_DE485_GPIO_Pin( ph->uarthelper->interface, my_pH.de_gpio, my_pH.de_pin );
-
-    /* interface type */
-    PH_Set_Interface_Type( ph, my_pH.interface_type );
-    PH_Set_RsMode_232_485 ( ph, my_pH.mode_232_485 ); //  max3160 的232  485选择
-    PH_Set_Trans_Type( ph, my_pH.trans_type ) ;
-    PH_Set_Rcv_Type ( ph, my_pH.rcv_type ) ;
-    PH_Set_Idle_Enable (ph, my_pH.idle_enable_disable ) ;
-    // UartHelper_Setup_Interface_type( ph ,my_pH.interface_type); 
- 
-    //  check  
-    if ( ph->uarthelper->huart == pPHUart ){
-        log_i ( "ph set huart ok. trans_type -> %d  rcv_type -> %d  ( 0 :polling, 1: IT  2: DMA) ",ph->trans_type ,ph->rcv_type ) ;
-        log_i( " interface->   %d  %d (0:default, 1:485, 2:3160) " ,ph->uarthelper->interface_type  ,ph->uarthelper->interface->interface_type );  
-        log_i( "ph 232_485 ->   %d  %d (0:232 ,1: 485)   " ,ph->uarthelper->mode_232_485, ph->uarthelper->interface->mode_232_485  );  
-    }else{
-        log_e ( "ph set huart failure "  ) ;
-    }
-        
-    PH_Set_Timeout( ph, 500 );
-    PH_Set_Sendbuf( ph,  PH_SND_Buf, 8 );
-    PH_Set_Rcvbuf(  ph,  PH_RCV_Buf, sizeof(PH_RCV_Buf) );
-
-    // set paras;
-    ph->timebase        = 0;
-    // ph->timeout_ms    = 1000;
-    ph->send_status     = Uart_Status_Ready;
-    ph->send_flag       = 0;
-    ph->command_seq     = 4;
-    ph->mode            = 2;
-    ph->data_begin_flag = 0;
-    ph->state           = PH_Status_Waiting;
+int PH_Test( )
+{
+    ph.state = PH_State_Test;  // 操作状态
     return 0;
 }
 
+void PH_Start( )
+{
+    ph.state = PH_State_Get_DATA;  // 操作状态
+ 
+}
 
-void PH_Port( )
+void PH_Stop( )
 {
-    phHandle = osThreadNew( PH_Task, NULL, &PH_attributes );
+    ph.state = PH_State_Stop;
+    // TODO stop  task？
 }
 
 void PH_Task( )
 {
-    // log_i( " ph tran mode : %d ", ph->->trans_mode );
-    memset(  PH_RCV_Buf, 0, 2*PH_Rcv_Buf_Size );  /* ph*3 ph *2 否则内存泄漏 */
-    uint64_t time_ticks;
-    // log_i( " ph tran mode : %d    %d " , ph->trans_mode , ph->mode );
- 
+   // memset(  PH_RCV_Buf, 0, 2*PH_Rcv_Buf_Size );  /* ph*3 ph *2 否则内存泄漏 */
+    ph.event_flag = 0;
+    uint64_t  ticks;
+    int err_con = 0;
+    int st;
     for ( ; ; )
-    {   
-        switch (ph->state)
+    {  
+        switch (ph.state)
         {
-        case PH_Status_Waiting:
+        case PH_State_Waiting:
+            log_i( " ph task..... : %d    %d " , ph.state , ph.state );
             osDelay(20);
             break;
-        case PH_Status_Ready:
-            log_i(" pH send  .................. "); 
-            my_pH.ph_val        = 0;
-            my_pH.temp_val      = 0;
-            memset(  ph->rcv_buf, 0, 2*PH_Rcv_Buf_Size );
-            PH_Begin_Rcv( ph, ph->rcv_buf, ph->size_rcv );
-            // HAL_UARTEx_ReceiveToIdle_DMA( &huart3, PH_RCV_Buf, PH_Rcv_Buf_Size );
-            // HAL_UART_Receive_DMA ( &huart3, ph->rcv_buf, ph->size_rcv );
-            // __HAL_UART_ENABLE_IT(  &huart3, UART_IT_IDLE );
-
-            ph->timebase = osKernelGetTickCount( );
-            // max3160_485_send_mode();
-            ph->state = PH_Status_Sending ;
-            PH_Transmit( ph, ph->send_buf, ph->size_send );
-            break; 
-        case PH_Status_Sending:
-            time_ticks = osKernelGetTickCount() ;
-            // log_i( " time_ticks :%d   %d" , time_ticks, ph->timebase);
-            if ( ( time_ticks - ph->timebase ) > ph->timeout_ms) 
+        case PH_State_Test:
+            ph.state = PH_State_Test_Start;
+            continue;
+        case PH_State_Test_Start:
+            UART_HELPER_Set_Trans_Buf( ph_uart_helper, PH_TEST_BUF, sizeof(PH_TEST_BUF) );
+            // HAL_UARTEx_ReceiveToIdle_DMA(&huart1, PH_RCV_BUF,13);
+            // __HAL_UART_ENABLE_IT( &huart1, UART_IT_IDLE );
+            // HAL_UART_Receive_DMA( &huart1, PH_RCV_BUF, 13 );
+ 
+            PH_Receive();
+            PH_Transmit();
+            ticks =  osKernelGetTickCount();
+            err_con = 0;
+            ph.state = PH_State_Testing;
+            continue;
+        case PH_State_Testing:
+            if ( osKernelGetTickCount() - ticks > 2000 )
             {
-                ph->state = PH_Status_Timeout ;
+                err_con++;
+                if( err_con >3)
+                {
+                    log_w( " PH testing  ******** error "  );
+                    ph.state = PH_State_Error;
+                }
+                ph.state = PH_State_Test;                
             }
-            osDelay(5); 
+            osDelay(1);
+            continue;
+        case PH_State_Test_OK:
+            log_i( " ph test ok..... : %d    %d " , ph.state , ph.state );
+            ph.state = PH_State_Ready;
             break;
-        case PH_Status_Send_Cplt:
-            time_ticks = osKernelGetTickCount() ;
-            log_i( "PH_Status_Send_Cplt ..... "  );
-            if ( (time_ticks - ph->timebase ) > ph->timeout_ms) 
+
+        case PH_State_Ready:
+            osDelay(1);
+            continue;
+        case PH_State_Get_DATA:
+            ph.data_ok = 0 ;
+            ph.size_received = 0 ;
+            memset( ph.result_buf, 0, sizeof(ph.result_buf) );
+            UART_HELPER_Set_Trans_Buf( ph_uart_helper, PH_TRANS_BUF, sizeof(PH_TRANS_BUF) );
+            PH_Receive();
+            PH_Transmit();
+            ticks =  osKernelGetTickCount();
+            err_con = 0;
+            ph.state = PH_State_Get_DATA_Wait;
+            continue;
+        case PH_State_Get_DATA_Wait:
+            if ( osKernelGetTickCount() - ticks > 2000 )
             {
-                ph->state = PH_Status_Timeout ;
+                err_con++;
+                if( err_con >3)
+                {
+                    log_w( " PH testing  ******** error "  );
+                    ph.state = PH_State_Error;
+                }
+                ph.state = PH_State_Get_DATA;                
             }
-            osDelay(5); 
-            break;
-        case PH_Status_RCV_OK:
-            if ( my_pH.ph_val == 0 & my_pH.temp_val==0 )
+            osDelay(1);
+            continue;
+        case PH_State_Get_DATA_OK:
+            log_w( " PH data ok  ********  "  );
+            // TODO 停止DMA
+            if (ph_uart_helper->rcv_mode == Uart_Trans_DMA)
             {
-                my_pH.ph_val        = ph->rcv_buf[3]*256 + ph->rcv_buf[4];
-                my_pH.temp_val      = ph->rcv_buf[5]*256 + ph->rcv_buf[6];
-                
-                log_i( "PH_Status_RCV_OK ..... ph %d  temp  %d " , my_pH.ph_val, my_pH.temp_val);
-                ph->state = PH_Status_DATA_OK ;
+                HAL_UART_DMAStop( ph_uart_helper->huart );
             }
-            // TODO 停止DMA
-            HAL_UART_DMAStop( ph->uarthelper->huart ); 
-            osDelay(20); 
-            break;
-        case PH_Status_DATA_OK:
-            osDelay(20); 
-            break;        
-        case PH_Status_Timeout:
+            ph.data_ok = 1 ;
+            ph.state = PH_Statee_Get_DATA_Check ;
+            continue;       
+        case PH_Statee_Get_DATA_Check:
+            log_w( " PH data check  ********  "  );
+            if(PH_Validate(   )== 0)
+            {
+                ph.state = PH_State_Stop; 
+            }else{
+                ph.state = PH_State_Error; 
+            }
+                           
+            osDelay(10); 
+            continue;
+        case PH_State_Stop:
+            log_d("  ph stop, aftetr deal, wait to change status....");
+            osDelay(10); 
+            continue;
+ 
+        case PH_State_Timeout:
             log_e( " pH timeout ..... "  );
-            ph->state = PH_Status_Waiting ;
-            HAL_UART_DMAStop( ph->uarthelper->huart ); 
+            ph.state = PH_State_Waiting ;
+            // TODO 停止DMA
+            if (ph_uart_helper->rcv_mode == Uart_Trans_DMA)
+            {
+            HAL_UART_DMAStop( ph_uart_helper->huart );
+            }
             osDelay(5); 
             break;
-        case PH_Status_Error:
+        case PH_State_Error:
             log_e( " pH error ..... "  );
-            ph->state = PH_Status_Waiting ;
-            HAL_UART_DMAStop( ph->uarthelper->huart ); 
+            ph.state = PH_State_Waiting ;
+            // TODO 停止DMA
+            if (ph_uart_helper->rcv_mode == Uart_Trans_DMA)
+            {
+            HAL_UART_DMAStop( ph_uart_helper->huart );
+            }
             osDelay(5); 
-            break;         
-        default:
-            break;
+            break;  
         }
-
         osDelay(20); 
-    }   
-}
- 
-int PH_Test( )
-{
-    HAL_UART_Transmit_IT( &huart3, ph->send_buf, ph->size_send   );
-    osDelay(20);
-    if ( HAL_UART_Receive ( &huart3, ph->rcv_buf, ph->size_rcv ,0xFF) != HAL_OK ){
-        return -1;
     }
-    return 0;
-}
-void PH_Start( )
-{
-    // log_e( " pH PH_Start ..... "  );
-    ph->state = PH_Status_Ready; 
-}
-void PH_Stop( )
-{
-    ph->state = PH_Status_Waiting; 
 }
 
-/******************         接口           *******************/
 
-
-void PH_Set_Uarthelper( PH_TypeDef *ph,  UartHelper_TypeDef * uarthelper)
-{
-    ph->uarthelper = uarthelper;
-}
-void PH_Set_Interface( PH_TypeDef *ph,  UartInterface_TypeDef * interface  )
-{
-    UartHelper_Set_Interface( ph->uarthelper,   interface );
-}
-void PH_Set_Huart( PH_TypeDef *ph,  UART_HandleTypeDef * huart  )
-{
-    ph->uarthelper->huart = huart;
-    // UartHelper_Set_Huart( ph->uarthelper,    huart  );
-}
-void PH_Set_Interface_Type( PH_TypeDef *ph,    Uart_Interface_Type_Typedef interface_type  )
+void PH_Trans_GPIO(void) 
 {
-    ph->interface_type = interface_type;  
-    ph->uarthelper->interface_type = interface_type; 
-    UartInterface_Setup_Interface_type( ph->uarthelper->interface ,ph->interface_type); 
+    // HAL_GPIO_WritePin(R_W_GPIO_Port,R_W_Pin, SET);
+    // HAL_GPIO_WritePin(NULL,0, SET);
+    HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, SET);
+    HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET);
+    HAL_GPIO_WritePin(DE485_GPIO_Port, DE485_Pin, SET);
 }
-void PH_Set_RsMode_232_485( PH_TypeDef *ph,  Uart_RS_Mode_TypeDef rs_232_485  )
-{
-    ph->mode_232_485 = rs_232_485; 
-    ph->uarthelper->mode_232_485 = rs_232_485; 
-       UartInterface_Setup_Mode_232_485( ph->uarthelper->interface, my_pH.mode_232_485 );
- 
-}
-void PH_Set_Trans_Type( PH_TypeDef *ph,  Uart_Transmode_TypeDef trans_type  )
-{
-    ph->trans_type = trans_type; 
-}
-void PH_Set_Rcv_Type( PH_TypeDef *ph,  Uart_Transmode_TypeDef rcv_type  )
-{
-    ph->rcv_type = rcv_type; 
 
-}
-void PH_Set_Idle_Enable( PH_TypeDef *ph,  Uart_IDLE_Enable_TypeDef idle_enable_disable  )
+void PH_Trans_Cplt_GPIO(void) 
 {
-    ph->idle_enable_disable = idle_enable_disable; 
-}
-
-void PH_Set_TransMode( PH_TypeDef *ph,  Uart_Transmode_TypeDef trans_mode  )
+    // HAL_GPIO_WritePin(R_W_GPIO_Port,R_W_Pin, RESET);
+    // HAL_GPIO_WritePin(NULL,0, RESET);
+    HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, SET);
+    HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, SET);
+    HAL_GPIO_WritePin(DE485_GPIO_Port, DE485_Pin, RESET);
+} 
+
+int PH_Transmit()
 {
-    ph->trans_type = trans_mode; 
-        ph->rcv_type = trans_mode; 
+    //  TODO 结合队列
+    ph.size_received =0;
+    if( ph_uart_helper->transferring == 0)
+    {
+        return UART_HELPER_Trans(ph_uart_helper, ph_uart_helper->trans_record->buf, ph_uart_helper->trans_record->size );
+    }
+    return 0;
 }
 
-void PH_Set_Timeout( PH_TypeDef *ph,    uint16_t timeout_ms)
+int PH_Receive()
 {
-    ph->timeout_ms = timeout_ms;    
-}
-void PH_Set_Sendbuf( PH_TypeDef *ph,  uint8_t * buf, uint16_t size)
-{
-    ph->send_buf = buf;
-    ph->size_send = size;
-    // log_i( " size_send   %d", sensor->size_send);
+    return UART_HELPER_Start_Rcv(ph_uart_helper, ph_uart_helper->rcv_buf, ph_uart_helper->rcv_size);
+    // return UART_HELPER_Start_Rcv(ph_uart_helper, PH_RCV_BUF, 13);
+    // return 0;
 }
 
-void PH_Set_Rcvbuf( PH_TypeDef *ph,  uint8_t * buf, uint16_t size)
+void PH_Set_Timeout_ms(    uint64_t ms_ticks )
 {
-    ph->rcv_buf = buf;
-    ph->size_rcv = size;
-    // log_i( " size_rcv   %d", demo->size_rcv);
+    ph.timeout_ticks = ms_ticks;
 }
 
-int PH_Transmit( PH_TypeDef *ph,  uint8_t * buf, uint16_t size )
+int PH_Validate(   )
 {
-    // log_i( "SensorSend  size_    %d", demo->size_send );
-    ph->timebase    = HAL_GetTick();
-    UartInterface_Set_GPIO_For_Transmit( ph->uarthelper->interface );
-    // UartHelper_Send_TxPrepare_Callback( ph->uarthelper );
-    // ph->send_status   = 1;
-    if ( ph->trans_type == 0 )
-        return HAL_UART_Transmit( ph->uarthelper->huart,  buf,  size ,0XFF);
-    if ( ph->trans_type == 1 )
-        return HAL_UART_Transmit_IT( ph->uarthelper->huart,  buf,  size );
-    if ( ph->trans_type == 2 )
-        return HAL_UART_Transmit_DMA( ph->uarthelper->huart,  buf,  size );
-    return -1;
-    // ph->send_flag   = 0;
+    return CRC16_Check(ph.result_buf ,ph.size_received);
 }
 
 
-void PH_Begin_Rcv( PH_TypeDef *ph,  uint8_t * buf, uint16_t size)
+int PH_CallBack( PH_TypeDef *pPH, uint8_t *buf, uint16_t size )
 {
-    /* 是否开启空闲中断*/
-    if ( ph->idle_enable_disable == 1 )
-    {
-        // log_i(" ** idle  enable...");
-        __HAL_UART_ENABLE_IT( ph->uarthelper->huart, UART_IT_IDLE );
-    }
- 
-    if ( ph->trans_type == 0 )
+    log_i( " PH_CallBack  -- state %d " , ph.state);
+    uint16_t size_tmp;
+    size_tmp =size;
+    switch (ph.state)
     {
-        // TODO  发生错误怎么处理
-        HAL_UART_Receive( ph->uarthelper->huart,  buf,  size ,0X0FFF);
-    }
-
-    if ( ph->trans_type == 1 )
-    {
-        HAL_UART_Receive_IT( ph->uarthelper->huart,  buf,  size);
-    }
-
-    if ( ph->trans_type == 2 )
-    {
-        HAL_UART_Receive_DMA( ph->uarthelper->huart,  buf,  size);
-    }
-}
+        case PH_State_Testing:
+            if (size>0) 
+            {
+                ph.state++;
+            }
+            break;
+        case PH_State_Get_DATA_Wait:
+            if (size == 0)  return 0;
+            if ((size + ph.size_received) >= sizeof(ph.result_buf) )
+            {
+                size_tmp = sizeof(ph.result_buf) - ph.size_received;
+            }
+            memcpy( (uint32_t)(ph.result_buf+ph.size_received), ph_uart_helper->rcv_buf, size_tmp );
+            ph.size_received += size_tmp;
 
-void PH_Send_Cplt_Callback( PH_TypeDef *ph )
-{
-    // ph->timebase    = HAL_GetTick(); 
-    ph->status      = Uart_Status_Send_Cplt;
-    if ( ph->interface_type != 0 )
-    {
-        UartInterface_Set_GPIO_For_Trans_Cplt( ph->uarthelper->interface );
-        // UartHelper_Set_GPIO_For_Trans_Cplt( ph->uarthelper  );        
+            if ( ph_uart_helper->enable_idle_it == 0 )
+            {
+                // Modbus 长度校验，拷贝数据？
+                if( ph.size_received == ( ph.result_buf[2]+ 5 ) )
+                {
+                    ph.state++;
+                }
+                return 0;
+            }
+            if ( ph_uart_helper->enable_idle_it == 1 )
+            {
+                // 长度校验，拷贝数据？
+                if( ph.size_received == ( ph.result_buf[2]+ 5 ) )
+                {
+                    ph.state++;
+                }
+                return 0;
+            }   
+            break;  
+        default:
+            break;
     }
- 
-}
-
-void PH_Rcv_Idle_Callback( PH_TypeDef *ph )
-{
-    /* 搬运 数据到 kfifo*/
-    ph->status       = 0;
-    ph->send_flag    = 0;
-}
-
-
-
-void PH_Rcv_Cplt_Callback( PH_TypeDef *ph  )
-{
-    /* 搬运 数据到 kfifo*/
-    log_i( " PH_Rcv_Cplt_Callback 1 .... " );
-    ph->rcv_ok = 1 ;
-    // ph->status       = 0;
-    // ph->send_flag    = 1;
-    // if ( ph->mode < 2 )
-    //     ph->command_seq++; 
-}
-
-int PH_Get_Data_OK( PH_TypeDef *ph  )
-{
-    return ph->rcv_ok;
-}
-void PH_Set_Send_Flag( PH_TypeDef *ph  )
-{
-    // vPortEnterCritical();
-    ph->send_flag    =   1;
-    ph->command_seq  =   0;
-    ph->data_ok      =   0;
-    // vPortExitCritical( );
+    return 0;
 }
 
-#endif
-
-
-
-    // UartHelper_Set_232 485 UartInterface
-    // UartInterface_Setup_Mode_232_485( ph->uarthelper->interface, my_pH.mode_232_485 );
-    // if (ph->interface_type == 0)
-    //     UartInterface_Set_232( ph->uarthelper->interface);
-    // if (ph->interface_type == 1)
-    //     UartInterface_Set_485( ph->uarthelper->interface);
-    // if (ph->interface_type ==2 && my_pH.mode_232_485 ==Uart_RSMODE_232)
-    //     UartInterface_Set_232( ph->uarthelper->interface);
-    // if (ph->interface_type ==2 && my_pH.mode_232_485 ==Uart_RSMODE_485)
-    //     UartInterface_Set_485( ph->uarthelper->interface);
-    // log_i( " interface->   %d  %d (0:default, 1:485, 2:3160) " ,ph->uarthelper->interface_type  ,ph->uarthelper->interface->interface_type );  
-    // log_i( "ph 232_485 ->   %d  %d (0:232 ,1: 485)   " ,ph->uarthelper->mode_232_485, ph->uarthelper->interface->mode_232_485  );  
+// CRCValue = HAL_CRC_Calculate(&hcrc, (uint32_t *)dataBuffer, BUFFER_SIZE);
+
+// void PH_Set_Interface( PH_TypeDef *ph,  UartInterface_TypeDef * interface  )
+// {
+//     UartHelper_Set_Interface( ph.uarthelper,   interface );
+// }
+// void PH_Set_Huart( PH_TypeDef *ph,  UART_HandleTypeDef * huart  )
+// {
+//     ph.uarthelper->huart = huart;
+//     // UartHelper_Set_Huart( ph.uarthelper,    huart  );
+// }
+// void PH_Set_Interface_Type( PH_TypeDef *ph,    Uart_Interface_Type_Typedef interface_type  )
+// {
+//     ph.interface_type = interface_type;  
+//     ph.uarthelper->interface_type = interface_type; 
+//     UartInterface_Setup_Interface_type( ph.uarthelper->interface ,ph.interface_type); 
+// }

device/Src/ramses_utils.c

@@ -0,0 +1,279 @@
+#include "ramses.h"
+#include "elog.h"
+
+/*  进一步对RAMSES 信息进行处理 */
+
+// /**
+//  * @brief 获取转换后的光谱数据
+//  * 
+//  * @param trios_ramses 设备描述符
+//  * @param data 数据缓冲区
+//  * @param num 缓冲区长度
+//  * @return uint32_t 成功:数据长度 失败:0xffffffff
+//  */
+// uint32_t trios_ramses_get_data(struct trios_ramses *trios_ramses,int16_t *data,uint32_t num)
+// {
+//     int i;
+//     int j;
+//     uint8_t endian_mask;
+//     endian_mask=endian_get_local_endian_mask(ENDIAN_MASK_LITTLE_ENDIAN);
+//     if(num<(TRIOS_RAMSES_DATA_SIZE-8)*TRIOS_RAMSES_DATA_NUM/2)
+//     {
+//         return 0;
+//     }
+//     if((trios_ramses->flag&TRIOS_RAMSES_FLAG_MASK_RECVED_DATA)==0){
+//         return 0;
+//     }
+//     for(i=0,j=0;i<TRIOS_RAMSES_DATA_NUM;i++){
+//         if(endian_write(endian_mask,ENDIAN_WIDTH_MASK_2BYTE,&((uint8_t*)data)[j],trios_ramses->data[i].data,trios_ramses->data[i].data_size)!=0){
+//             trios_ramses_clean_data_recved_flag(trios_ramses);
+//             return 0xffffffff;
+//         }
+//         j+=trios_ramses->data[i].data_size;
+//     }
+//     return j/2;
+// }
+// /**
+//  * @brief 获取X轴倾斜角度
+//  * 
+//  * @param trios_ramses 设备描述符
+//  * @param incl_xgain 标定数据
+//  * @param incl_xoffset 标定数据
+//  * @return double 成功:X轴倾角 失败:NAN
+//  */
+// double trios_ramses_get_x_inclination_angle(struct trios_ramses *trios_ramses,double incl_xgain,double incl_xoffset)
+// {
+//     if((trios_ramses->flag&TRIOS_RAMSES_FLAG_MASK_RECVED_IP)==0){
+//         return NAN;
+//     }
+//     return (trios_ramses->ip.data[4]-incl_xoffset)*incl_xgain;
+// }
+// /**
+//  * @brief 获取Y轴倾斜角度
+//  * 
+//  * @param trios_ramses 设备描述符
+//  * @param incl_ygain 标定数据
+//  * @param incl_yoffset 标定数据
+//  * @return double 成功:Y轴倾角 失败:NAN
+//  */
+// double trios_ramses_get_y_inclination_angle(struct trios_ramses *trios_ramses,double incl_ygain,double incl_yoffset)
+// {
+//     if((trios_ramses->flag&TRIOS_RAMSES_FLAG_MASK_RECVED_IP)==0){
+//         return NAN;
+//     }
+//     return (trios_ramses->ip.data[5]-incl_yoffset)*incl_ygain;
+// }
+// /**
+//  * @brief 获取设备倾角
+//  * 
+//  * @param x_inclination_angle X轴倾角
+//  * @param y_inclination_angle Y轴倾角
+//  * @return double 成功:设备倾角 失败:NAN
+//  */
+// double trios_ramses_get_inclination_angle(double x_inclination_angle,double y_inclination_angle)
+// {
+//     if(x_inclination_angle==NAN || y_inclination_angle==NAN){
+//         return NAN;
+//     }
+//     return atan(sqrt(pow(tan(x_inclination_angle*M_PI/180),2)+pow(tan(y_inclination_angle*M_PI/180),2)));
+// }
+// /**
+//  * @brief 获取压力
+//  * 
+//  * @param trios_ramses 设备描述符
+//  * @param incl_kref 标定数据
+//  * @param incl_kbg 标定数据
+//  * @param press_gain 标定数据
+//  * @param press_surface_bar 标定数据
+//  * @param press_sens_mv_bar_1ma 标定数据
+//  * @param press_sens_mv_bar_4ma 标定数据
+//  * @return double 压力
+//  */
+// double trios_ramses_get_pressure(struct trios_ramses *trios_ramses,double incl_kref,double incl_kbg,double press_gain,double press_surface_bar,double press_sens_mv_bar_1ma,double press_sens_mv_bar_4ma)
+// {
+//     uint16_t npress;
+//     uint16_t nbg;
+//     uint16_t nrefh;
+//     uint16_t nrefl;
+//     double noffset;
+//     double press_sens;
+//     double vpress_v;
+//     double p_bar;
+//     if((trios_ramses->flag&TRIOS_RAMSES_FLAG_MASK_RECVED_IP)==0){
+//         return NAN;
+//     }
+//     npress=((uint16_t)trios_ramses->ip.data[7]<<8)+trios_ramses->ip.data[6];
+//     nbg=((uint16_t)trios_ramses->ip.data[11]<<8)+trios_ramses->ip.data[10];
+//     nrefh=((uint16_t)trios_ramses->ip.data[13]<<8)+trios_ramses->ip.data[12];
+//     nrefl=((uint16_t)trios_ramses->ip.data[15]<<8)+trios_ramses->ip.data[14];
+//     noffset=nrefl-(incl_kref*(nrefh-nrefl));
+//     vpress_v=incl_kbg*(npress-noffset)/(nbg-noffset);
+//     press_sens=(press_sens_mv_bar_4ma<=0?press_sens_mv_bar_1ma:press_sens_mv_bar_4ma);
+//     p_bar=1000.0*vpress_v/(press_sens*press_gain);
+//     return p_bar-1.021;
+// }
+// /**
+//  * @brief 获取深度(米)
+//  * 
+//  * @param pressure 压力
+//  * @return double 成功:深度 失败:NAN
+//  */
+// double trios_ramses_get_depth_m(double pressure)
+// {
+//     if(pressure==NAN){
+//         return NAN;
+//     }
+//     return pressure*10;
+// }
+// /**
+//  * @brief 获取设备序列号
+//  * 
+//  * @param trios_ramses 设备描述符
+//  * @return uint16_t 成功:设备序列号 失败:0xffff
+//  */
+// uint16_t trios_ramses_get_serial_number(struct trios_ramses *trios_ramses)
+// {
+//     if((trios_ramses->flag&TRIOS_RAMSES_FLAG_MASK_RECVED_INFO)==0){
+//         return 0xffff;
+//     }
+//     return trios_ramses->infomation.serial_number;
+// }
+
+
+// extern int Ramses_Deal_Data_Frame(Ramses_TypeDef *pRamses, uint8_t *buf, uint16_t size);
+
+// int Ramses_Deal_Data_Frame(Ramses_TypeDef *pRamses, uint8_t *buf, uint16_t size)
+// {
+//     int i;
+//     int j = 0;
+
+//     for(i=0;i<size;i++){
+// 		log_i("recv_buf i %d   %02X,  recv_buf_p %d",i, buf[i], ramses.recv_buf_p);
+//         if ( ramses.recv_buf_p==0 && buf[i]!=0x23 ){  // 下标为0，找0x23 可以过滤0x13 0x11
+// 			log_i("recv_buf i  0x23" );
+//             continue; 
+//         }
+//         if(ramses.recv_flag_40==1){
+//             if(buf[i]==0x64){
+//                 ramses.recv_buf[ramses.recv_buf_p++]=0x40;
+//             }
+//             else if(buf[i]==0x65){
+//                 ramses.recv_buf[ramses.recv_buf_p++]=0x23;
+//             }
+//             else if(buf[i]==0x66){
+//                 ramses.recv_buf[ramses.recv_buf_p++]=0x11;
+//             }
+//             else if(buf[i]==0x67){
+//                 ramses.recv_buf[ramses.recv_buf_p++]=0x13;
+//             }
+//             else{
+//                 ramses.data_index=0;
+//                 ramses.recv_flag_40=0;
+//                 ramses.recv_buf_p=0;
+//                 continue;
+//             }
+//             ramses.recv_flag_40=0;
+//         }
+//         else if(buf[i]==0x40){
+//             ramses.recv_flag_40=1;
+//         }
+//         else{  //  每帧 recv_buf中的 数组下标
+// 			// log_i("buf[i]  -> %d  %02X" ,i, buf[i]);
+//             ramses.recv_buf[ramses.recv_buf_p++]=buf[i];
+// 			j++ ;
+//         }
+	
+// 		//    每帧数据数量 大于7 判断类型，且长度校验通过 
+//         if(ramses.recv_buf_p>7 && ramses.recv_buf_p==8+(2<<(ramses.recv_buf[1]>>5))){
+// 				// j++ ;
+//             if(ramses.recv_buf[4]==0xff){   // 0xff  表征 SN信息帧
+// 				log_i(" info frame .... ") ;
+//                 if(ramses.recv_buf_p!=Ramses_INFO_SIZE){
+//                     ramses.recv_flag_40=0;
+//                     ramses.recv_buf_p=0;
+//                     continue;
+//                 }
+//                 ramses.information.dev_id=((uint16_t)ramses.recv_buf[1]<<8)+ramses.recv_buf[2];
+//                 ramses.information.module_id=ramses.recv_buf[3];
+//                 ramses.information.serial_number=((uint16_t)ramses.recv_buf[8]<<8)+ramses.recv_buf[7];
+//                 ramses.information.firmware_number[0]=ramses.recv_buf[10];
+//                 ramses.information.firmware_number[1]=ramses.recv_buf[9];
+//                 memcpy(ramses.information.individual_information,&ramses.recv_buf[7],Ramses_INFO_SIZE-12);
+//                 ramses.recv_buf_p=0;
+//                 ramses.flag|=Ramses_FLAG_MASK_RECVED_INFO;
+//                 ramses.flag&=~Ramses_FLAG_MASK_BUSY;
+//             }
+//             else if(ramses.recv_buf[4]==0xfe){  // 0xfe错误
+//                 ramses.data_index=0;
+//                 ramses.recv_flag_40=0;
+//                 ramses.recv_buf_p=0;
+//                 continue;
+//             }
+//             else{
+//                 if(ramses.recv_buf[3]==0x80 || ramses.recv_buf[3]==0x30 || ramses.recv_buf[3]==0x00){
+//                     // log_i("....  0x80 0x 30  0x00");
+//                     if((ramses.flag&Ramses_FLAG_MASK_RECVED_DATA)!=0){  // 判断为数据帧
+//                         ramses.data_index=0;
+//                         ramses.recv_flag_40=0;
+//                         ramses.recv_buf_p=0;
+//                         continue;
+//                     }
+//                     if(ramses.recv_buf_p!=Ramses_DATA_SIZE){
+//                         ramses.recv_flag_40=0;
+//                         ramses.recv_buf_p=0;
+//                         continue;
+//                     }
+//                     if(ramses.recv_buf[4]!=Ramses_DATA_NUM-1-ramses.data_index){
+//                         ramses.data_index=0;
+//                         ramses.recv_flag_40=0;
+//                         ramses.recv_buf_p=0;
+//                         continue;
+//                     }
+//                     memcpy(ramses.data[ramses.data_index].raw,ramses.recv_buf,Ramses_DATA_SIZE);
+//                     ramses.data[ramses.data_index].dev_id=((uint16_t)ramses.recv_buf[1]<<8)+ramses.recv_buf[2];
+//                     ramses.data[ramses.data_index].module_id=ramses.recv_buf[3];
+//                     ramses.data[ramses.data_index].framebyte=ramses.recv_buf[4];
+//                     ramses.data[ramses.data_index].data=&ramses.data[ramses.data_index].raw[7];
+//                     ramses.data[ramses.data_index].data_size=Ramses_DATA_SIZE-8;
+//                     ramses.data_index++;
+//                     ramses.recv_buf_p=0;
+//                     if(ramses.data_index==Ramses_DATA_NUM){
+//                         ramses.data_index=0;
+//                         ramses.flag|=Ramses_FLAG_MASK_RECVED_DATA;
+//                         ramses.flag&=~Ramses_FLAG_MASK_BUSY;
+//                     }
+//                 }
+//                 else if(ramses.recv_buf[3]==0x20){
+//                     if((ramses.flag&Ramses_FLAG_MASK_RECVED_IP)!=0){  // 判断为IP帧
+//                         ramses.data_index=0;
+//                         ramses.recv_flag_40=0;
+//                         ramses.recv_buf_p=0;
+//                         continue;
+//                     }
+//                     if(ramses.recv_buf_p!=Ramses_IP_SIZE){
+//                         ramses.recv_flag_40=0;
+//                         ramses.recv_buf_p=0;
+//                         continue;
+//                     }
+//                     memcpy(ramses.ip.raw,ramses.recv_buf,Ramses_IP_SIZE);
+//                     ramses.ip.dev_id=((uint16_t)ramses.recv_buf[1]<<8)+ramses.recv_buf[2];
+//                     ramses.ip.module_id=ramses.recv_buf[3];
+//                     ramses.ip.framebyte=ramses.recv_buf[4];
+//                     ramses.ip.data=&ramses.ip.raw[7];
+//                     ramses.ip.data_size=Ramses_IP_SIZE-8;
+//                     ramses.recv_buf_p=0;
+//                     ramses.flag|=Ramses_FLAG_MASK_RECVED_IP;
+//                 }
+//                 else{
+//                     ramses.data_index=0;
+//                     ramses.recv_flag_40=0;
+//                     ramses.recv_buf_p=0;
+//                     continue;
+//                 }
+//             }
+//         }
+    
+// 	} 
+// 	log_i("cb   i %d  j %d",i,j);
+// 	return 0;
+// }

device/Src/sc6.c

@@ -1,273 +1,250 @@
 #include "sc6.h"
-#include "elog.h"
-#include "FreeRTOS.h"
-#include "cmsis_os.h"
-#include "usart.h"
-
-/******           Port             ***************/
-#if 1
-My_SC6_TypeDef mysc6 =
-    {
-        SC6_Init,
-        SC6_Port,
-        SC6_Set_State,
-        // SEL_232_485_GPIO_Port,
-        // HDPLX_GPIO_Port,
-        // DE485_GPIO_Port,
-        // SEL_232_485_Pin,
-        // HDPLX_Pin,
-        // DE485_Pin,
-        NULL,
-        NULL,
-        NULL,
-        0,
-        0,
-        0,
-        Uart_Interface_Default, /* 接口类型 0: common, 1: 485 ,2:3160*/
-        Uart_RSMODE_232,        /* mode_232_485 0 commome  1:485*/
-        Uart_Trans_DMA,         /* trans_type0 :polling, 1: IT  2: DMA*/
-        Uart_Trans_DMA,         /* rcv_type 0 :polling, 1: IT  2: DMA*/
-        Uart_IDLE_IT_ENABLE,    /* idle_enable_disable 0 :不启用空闲 , 1: 启用空闲*/
-       NULL, /* pointer huart*/
+
+osThreadId_t SC6_Handle;
+const osThreadAttr_t SC6_attributes = {
+    .name       = "SC6",
+    .stack_size = 1024,
+    .priority   = (osPriority_t) osPriorityBelowNormal,
 };
 
-UART_HandleTypeDef *psc6Uart = &huart2;
-#define SC6_Uart_IRQHandler USART2_IRQHandler
+// 事件
+osEventFlagsId_t SC6_EventHandle;
+const osEventFlagsAttr_t SC6_Event_attributes = {
+  .name = "SC6_Event"
+};
 
-extern volatile uint8_t measure_flag;
-SC6_TypeDef *sc6;
+extern UART_HandleTypeDef huart1;
+UART_HandleTypeDef *pSC6Uart = &huart1;
 
-static uint8_t start_buf[8]  = { 0x52, 0x45, 0x53, 0x55, 0x4D, 0x45, 0x0D, 0x0A };  /* RESUME\r\n*/
-static uint8_t stop_buf[7]   = { 0x50, 0x41, 0x55, 0x53, 0x45, 0x0D, 0x0A };  /* PAUSE\r\n*/
+static uint8_t SC6_TRANS_BUF[8]  = { 0x52, 0x45, 0x53, 0x55, 0x4D, 0x45, 0x0D, 0x0A };
+static uint8_t SC6_start_buf[8]  = { 0x52, 0x45, 0x53, 0x55, 0x4D, 0x45, 0x0D, 0x0A };  /* RESUME\r\n*/
+static uint8_t SC6_stop_buf[7]   = { 0x50, 0x41, 0x55, 0x53, 0x45, 0x0D, 0x0A };  /* PAUSE\r\n*/
 
-static uint8_t start_rcv_buf[12]  = { 0x52, 0x45, 0x53, 0x55, 0x4D, 0x45, 0x44, 0x2E, 0x2E, 0x2E, 0x0D, 0x0A };  /* RESUMED...\r\n*/
-static uint8_t stop_rcv_buf[11]   = { 0x50, 0x41, 0x55, 0x53, 0x45, 0x44, 0x2E, 0x2E, 0x2E, 0x0D, 0x0A  };  /* PAUSED...\r\n*/
+static uint8_t SC6_start_rcv_buf[12]  = { 0x52, 0x45, 0x53, 0x55, 0x4D, 0x45, 0x44, 0x2E, 0x2E, 0x2E, 0x0D, 0x0A };  /* RESUMED...\r\n*/
+static uint8_t SC6_stop_rcv_buf[11]   = { 0x50, 0x41, 0x55, 0x53, 0x45, 0x44, 0x2E, 0x2E, 0x2E, 0x0D, 0x0A  };  /* PAUSED...\r\n*/
 
-//  uint8_t SC6_Data_Buf[SC6_Rcv_Buf_Size*2]    = {0};
 
 static uint8_t data_start_tag[7] =  {0x53, 0x43, 0x36 ,0x2d , 0x4c , 0x50 , 0x54};  //, "SC6-LPT" 
 static uint8_t data_end_tag[2] = {0x0D, 0x0A};
 
-// uint8_t SC6_sn_buf[15] = {0};
-// uint8_t SC6_rcvbuf[2][SC6_Rcv_Buf_Size] = {0};
-
-static uint8_t SC6_Rcv_Buf[ 2* SC6_Result_Buf_Size ] = {0};
-
-osThreadId_t sc6Handle;
-const osThreadAttr_t SC6_attributes = {
-    .name = "sc6",
-    .stack_size = 1024,
-    .priority = (osPriority_t)osPriorityBelowNormal,
+static uint8_t SC6_RCV_BUF[ 2* SC6_Result_Buf_Size ] = {0};
+
+UART_HELPER_TypeDef *SC6_uart_helper;
+
+SC6_TypeDef  sc6 ={
+    SC6_Init,
+    SC6_Port,
+    SC6_Test,
+    SC6_Start,
+    SC6_Stop,
+    NULL,
+    0,      // state
+    0,      // data_ok
+    {0},    // buf
+    0,      // size_received
+    0,      // time base
+    1000,      // timeout ticks,  1000ms = 1S
+    0,          // event_flag
+	{0},
+	{0},
+	{0},
+	0xFFFF,
 };
 
-void SC6_Uart_IRQHandler(void)
+int SC6_Init( )
 {
-    uint16_t count = 0;
-    uint16_t data_length = 0;
-    if (__HAL_UART_GET_FLAG(psc6Uart, UART_FLAG_TC) != RESET)
-    {
-        log_i("SC6_.... TC IT ...");
-        // sc6->uarthelper ->status = Uart_Status_Send_Cplt ;
-        // SC6_Set_UartHelper_Status( sc6, Uart_Status_Send_Cplt);
-        SC6_Set_GPIO_For_TC_Cplt(sc6);
-
-        sc6->uarthelper->huart->gState = HAL_UART_STATE_READY;
-        // psc6Uart->gState = HAL_UART_STATE_READY;
-        // UartHelper_Trans_Cplt_Callback(  sc6->uarthelper  );
-        //  log_i("Send SC6_Uart_IRQHandler->  interface_type %d,  232-485  %d ,  sel: %d ,de485  %d  , duplx %d "
-        //     ,sc6->uarthelper->interface->interface_type
-        //     ,sc6->uarthelper->interface->mode_232_485
-        //     ,HAL_GPIO_ReadPin(sc6->uarthelper->interface->sel_gpio,sc6->uarthelper->interface->sel_pin)
-        //     ,HAL_GPIO_ReadPin(sc6->uarthelper->interface->de485_gpio,sc6->uarthelper->interface->de485_pin)
-        //     ,HAL_GPIO_ReadPin(sc6->uarthelper->interface->dplx_gpio,sc6->uarthelper->interface->dplx_pin)
-        //     );
-        // sc6->status = Uart_Status_Send_Cplt;
-        // huart3.gState = HAL_UART_STATE_READY;
-        __HAL_UART_CLEAR_FLAG(sc6->uarthelper->huart, UART_FLAG_TC);
-    }
+    SC6_uart_helper = UART_HELPER_Init( );
 
-    if (__HAL_UART_GET_FLAG(psc6Uart, UART_FLAG_IDLE) != RESET )
-    {
-        log_i("SC6_....  IDLE  IT ....  ");
-        // TODO ...处理空闲 ，最后一位  datalength-1
+    if (SC6_uart_helper ==NULL)  return -1;
 
-        count = __HAL_DMA_GET_COUNTER(sc6->uarthelper->huart->hdmarx);
-        data_length = 2* SC6_Result_Buf_Size - count;
-        if (data_length > 0)
-        {
-            log_i("SC6_. IDLE..data_length  %d",   data_length);
-            SC6_copy(sc6, data_length);
-            // log_i("SC6_. IDLE..res  %02X %d %02X",  sc6->uarthelper ->receive_buf[0],  sc6->uarthelper ->receive_buf[2],  sc6->uarthelper ->receive_buf[data_length-1]);
-        }
- 
-        __HAL_UART_CLEAR_IDLEFLAG(psc6Uart);
-    }
+    // TODO 接口
+    UART_HELPER_Set_Huart( SC6_uart_helper, pSC6Uart );
+    UART_HELPER_Set_Interface_Type(SC6_uart_helper, Uart_Interface_Max3160_485);
 
-    if (__HAL_UART_GET_FLAG(psc6Uart, UART_FLAG_ORE) != RESET)
-    {
-        log_i("SC6_....ORE");
+    //  传输
+    UART_HELPER_Setup_Trans_mode(  SC6_uart_helper, Uart_Trans_DMA);
+    // UART_HELPER_Setup_Rcv_mode( SC6_uart_helper, Uart_Trans_IT );
+    UART_HELPER_Set_enable_idle(  SC6_uart_helper, Uart_IDLE_IT_ENABLE);
 
-        __HAL_UART_CLEAR_FLAG(psc6Uart, UART_FLAG_ORE);
-    }
-    if (__HAL_UART_GET_FLAG(psc6Uart, UART_FLAG_FE) != RESET)
-    {
-        log_i("SC6_....FE");
+    //  回调GPIO 操作 数据操作
+    UART_HELPER_Set_trans_GPIO(  SC6_uart_helper, SC6_Trans_GPIO );  // enbale rcv
+    UART_HELPER_Set_trans_cplt_GPIO( SC6_uart_helper, SC6_Trans_Cplt_GPIO );
 
-        __HAL_UART_CLEAR_FLAG(psc6Uart, UART_FLAG_FE);
-    }
-    if (__HAL_UART_GET_FLAG(psc6Uart, UART_FLAG_PE) != RESET)
-    {
-        log_i("SC6_....PE");
+    UART_HELPER_Set_Callback( SC6_uart_helper,&sc6, SC6_CallBack );
 
-        __HAL_UART_CLEAR_FLAG(psc6Uart, UART_FLAG_PE);
-    }
-    HAL_UART_IRQHandler(psc6Uart);
-}
+    // 设置 Buf
+    UART_HELPER_Set_Rcv_Buf(SC6_uart_helper, SC6_RCV_BUF, sizeof(SC6_RCV_BUF));
+    UART_HELPER_Set_Trans_Buf( SC6_uart_helper, SC6_TRANS_BUF, sizeof(SC6_TRANS_BUF) );
 
-int SC6_copy(SC6_TypeDef *sc6 ,uint16_t size)
-{
-    log_i( "*** SC6_  copy  state %d   size :%d    size_rcv  %d ", sc6->state,size,sc6->size_received );
-    // log_i( "SC6_ idle copy  %02x %02x %02x %02x ", SC6_Rcv_Buf[0], SC6_Rcv_Buf[1], SC6_Rcv_Buf[11], SC6_Rcv_Buf[size-1]);
-    if ( sc6->state == MODULE_SC6_STATE_CHECK_DATA  )
+    //  GPIO 操作
+    switch (SC6_uart_helper->interface_type)
     {
-    __disable_irq();
-        memcpy(sc6->SC6_Data_Buf , sc6->uarthelper->receive_buf, size);
-    __enable_irq();
-        sc6->size_received = sc6->size_received + size;
-            log_w("SC6_. copy after  %02X %02X  %02X  %02X %d    %d"
-            ,  sc6->SC6_Data_Buf[0],  sc6->SC6_Data_Buf[12], sc6->SC6_Data_Buf[13],  sc6->SC6_Data_Buf[sc6->size_received-1]
-            , size,sc6->size_received);
-        return 0;
+        case Uart_Interface_Default:
+            break;
+        case Uart_Interface_485:
+            usart6_send_enable();   
+            break;
+        case Uart_Interface_Max3160_232:
+            SC6_MAX3160_232();
+            break;
+        case Uart_Interface_Max3160_485:
+            max3160_485_receive_mode();
+            break;    
+        default:
+            break;
     }
-    return 0;
+    sc6.state = SC6_State_Waiting;
+    sc6.timebase_ticks = osKernelGetTickCount( );
 }
 
-void SC6_Set_State( MODULE_SC6_WORK_STATE state  )
+void SC6_Port( )
 {
-    // log_i( "Set_State...sc6->state .%d ", sc6->state);
-      sc6->state = state;
+    SC6_Handle = osThreadNew( SC6_Task, NULL, &SC6_attributes );
+    // SC6_EventHandle = osEventFlagsNew(&SC6_Event_attributes);
 }
 
-uint8_t SC6_Init()
+int SC6_Test( )
 {
+    sc6.state = SC6_State_Test;  // 操作状态
+    return 0;
+}
 
-    sc6 = (SC6_TypeDef *)malloc(sizeof(SC6_TypeDef));
-
-    UartInterface_TypeDef *interface    = UartInterface_Init( );
-    UartHelper_TypeDef *uarthelper      = UartHelper_Init();
-
-    SC6_Set_Uarthelper( sc6,  uarthelper );
-    SC6_Set_Interface( sc6,  interface );
-    SC6_Set_Huart( sc6, psc6Uart );
- 
-    /* set_GPIO  UartInterface */
-    UartInterface_Set_Sel_GPIO_Pin( sc6->uarthelper->interface, mysc6.sel_gpio, mysc6.sel_pin );
-    UartInterface_Set_Dplx_GPIO_Pin( sc6->uarthelper->interface, mysc6.dplx_gpio, mysc6.dplx_pin );
-    UartInterface_Set_DE485_GPIO_Pin( sc6->uarthelper->interface, mysc6.de_gpio, mysc6.de_pin );
-
-    /* interface type */
-    SC6_Set_Interface_Type( sc6, mysc6.interface_type );
-    SC6_Set_RsMode_232_485 ( sc6, mysc6.mode_232_485 ); //  max3160 的232  485选择
-    SC6_Set_Trans_Type( sc6, mysc6.trans_type ) ;
-    SC6_Set_Rcv_Type ( sc6, mysc6.rcv_type ) ;
-    SC6_Set_Idle_Enable (sc6, mysc6.idle_enable_disable ) ;
-    // UartHelper_Setup_Interface_type( sc6 ,mysc6.interface_type); 
+void SC6_Start( )
+{
+    sc6.state = SC6_State_Start;  // 操作状态
  
-    //  check  
-    if ( sc6->uarthelper->huart == psc6Uart ){
-        log_i ( "sc6 set huart ok. trans_type -> %d  rcv_type -> %d  ( 0 :polling, 1: IT  2: DMA) ",sc6->trans_type ,sc6->rcv_type ) ;
-        log_i( " interface->   %d  %d (0:default, 1:485, 2:3160) " ,sc6->uarthelper->interface_type  ,sc6->uarthelper->interface->interface_type );  
-        log_i( "sc6 232_485 ->   %d  %d (0:232 ,1: 485)   " ,sc6->uarthelper->mode_232_485, sc6->uarthelper->interface->mode_232_485  );  
-    }else{
-        log_e ( "sc6 set huart failure "  ) ;
-    }
-        
-    // sc6 send rcv buf 是动态的
-    SC6_Set_Timeout( sc6, 1000 );
-    // SC6_Set_Sendbuf( sc6,  SC6_SND_Buf, 8 );
-    // SC6_Set_Rcvbuf(  sc6,  SC6_RCV_Buf, sizeof(SC6_RCV_Buf) );
-
-    // set paras;
-    sc6->timebase        = 0;
-    // sc6->timeout_ms    = 1000;
-    sc6->send_status     = Uart_Status_Ready;
-    sc6->send_flag       = 0;
-    sc6->command_seq     = 4;
-    // sc6->mode            = 2;
-    // sc6->data_begin_flag = 0;
-    sc6->state           = MODULE_SC6_STATE_WAIT;
-    return 0;
 }
 
-void SC6_Port()
+void SC6_Stop( )
 {
-    sc6Handle = osThreadNew(SC6_Task, (void*)(&sc6->state), &SC6_attributes);
+    sc6.state = SC6_State_Stop;
+    // TODO stop  task？
 }
 
-void SC6_Task(void* argument)
+void SC6_Task( )
 {
-    MODULE_SC6_WORK_STATE *state = argument;
-    // FLAG   发送后进入 busy,  接收sn后就rcved_flag
-    for (;;)
-    {
-        // log_i( " SC6_ state   %d   " , *state );
-        switch (*state)
+   // memset(  SC6_RCV_Buf, 0, 2*SC6_Rcv_Buf_Size );  /* ph*3 ph *2 否则内存泄漏 */
+    sc6.event_flag = 0;
+    static uint64_t  ticks;
+    static int err_con = 0;
+    static int st;
+    for ( ; ; )
+    {  
+        switch (sc6.state)
         {
-        case MODULE_SC6_STATE_WAIT:
+        case SC6_State_Waiting:
+            log_i( " SC6_ task..... : %d    %d " , sc6.state , sc6.state );
+            osDelay(20);
             break;
-        case MODULE_SC6_STATE_START:
-            log_i( " SC6_Task start   %d   " , *state );
-                sc6->timebase = osKernelGetTickCount();
-                sc6->flag |= SC6_FLAG_MASK_BUSY;
-                sc6->uarthelper->huart->gState = HAL_UART_STATE_READY;
-                HAL_UART_DMAStop(sc6->uarthelper->huart );
-                memset(SC6_Rcv_Buf, 0, sizeof(SC6_Rcv_Buf));
-                UartHelper_Set_rcv_buf(sc6->uarthelper , SC6_Rcv_Buf, sizeof(SC6_Rcv_Buf));
-                sc6->size_received = 0;
-                sc6->index_SC6_LPT = 0;
-                UartHelper_Set_Trans_Buf( sc6->uarthelper , start_buf, sizeof(start_buf) );
-                // SC6_Begin_Rcv( sc6, sc6->uarthelper->receive_buf, 2 * sc6->uarthelper->receive_buf_half_len );
-                SC6_Begin_Rcv( sc6, SC6_Rcv_Buf, sizeof(SC6_Rcv_Buf) );
-                int st =SC6_Transmit(sc6, sc6->uarthelper->trans_buf, sc6->uarthelper ->trans_size);
-                log_w(" st :%d   %d" ,st , sc6->uarthelper->huart->gState),
-                *state=MODULE_SC6_STATE_CHECK_DATA; 
-            break; 
+
+        case SC6_State_Test:
+			log_d( " SC6_  test     ...   "  );
+			ticks = osKernelGetTickCount();
+			sc6.size_received = 0;
+			sc6.index_SC6_LPT = 0xFFFF;
+            sc6.state = SC6_State_Test_Data_Getting;
+			ticks = osKernelGetTickCount();
+	        UART_HELPER_Set_Trans_Buf( SC6_uart_helper, SC6_TRANS_BUF, sizeof(SC6_TRANS_BUF) );
+            SC6_Receive();
+            SC6_Transmit();
  
-        case MODULE_SC6_STATE_CHECK_DATA:
-            log_i( " SC6_Task check   %d   rcvsize  %d sc6->index_SC6_LPT  %d" , *state ,sc6->size_received,sc6->index_SC6_LPT);
-            log_i( " SC6_Task    %s   " , sc6->SC6_Data_Buf );
-            // find  SC6_LPT 
-            if ( sc6->index_SC6_LPT==0 && sc6->size_received > 2*SC6_Rcv_Buf_Size +SC6_RESUMED_Buf_Size) 
+            sc6.state = SC6_State_Test_Data_Getting;
+            continue;
+        case SC6_State_Test_Data_Getting:
+             if ( osKernelGetTickCount() - ticks > 2000 )
             {
-                sc6->error++;
-                if( sc6->error > 2)
+                err_con++;
+                if( err_con >3)
                 {
-                    HAL_UART_DMAStop(sc6->uarthelper ->huart );
-                    *state=MODULE_SC6_STATE_ERROR;;
-                    sc6->size_received = 0;
-                    sc6->index_SC6_LPT =0;
-                    sc6->error = 0;   
+                    log_w( " SC6_ Test data gettting ... error "  );
+                    sc6.state = SC6_State_Error;
+                }
+                sc6.state = SC6_State_Test;                
+            }
+            osDelay(1);
+            continue;
+
+        case SC6_State_Test_OK:
+			HAL_UART_DMAStop(SC6_uart_helper->huart );
+			sc6.state = SC6_State_Error;
+			sc6.size_received = 0;
+			sc6.index_SC6_LPT =0xFFFF;
+			err_con = 0;   		
+            sc6.state = SC6_State_Ready;                
+            continue;
+
+        case SC6_State_Ready:
+            osDelay(1);
+            continue;
+
+        case SC6_State_Start:
+			ticks = osKernelGetTickCount();
+			sc6.size_received = 0;
+			sc6.index_SC6_LPT = 0xFFFF;
+            sc6.state = SC6_State_Start_Trans;
+            continue;
+        case SC6_State_Start_Trans:
+            UART_HELPER_Set_Trans_Buf( SC6_uart_helper, SC6_TRANS_BUF, sizeof(SC6_TRANS_BUF) );
+            // HAL_UARTEx_ReceiveToIdle_DMA(&huart1, SC6_RCV_BUF,13);
+            // __HAL_UART_ENABLE_IT( &huart1, UART_IT_IDLE );
+            // HAL_UART_Receive_DMA( &huart1, SC6_RCV_BUF, 13 );
+            SC6_Receive();
+            SC6_Transmit();
+            ticks =  osKernelGetTickCount();
+            err_con = 0;
+            sc6.state = SC6_State_Check_Data;
+            continue;
+        // case SC6_State_Data_Getting:
+        //     if ( osKernelGetTickCount() - ticks > 2000 )
+        //     {
+        //         err_con++;
+        //         if( err_con >3)
+        //         {
+        //             log_w( " SC6_ gettting ... error "  );
+        //             sc6.state = SC6_State_Error;
+        //         }
+        //         sc6.state = SC6_State_Start_Trans;                
+        //     }
+        //     osDelay(1);
+        //     continue;
+        case SC6_State_Check_Data:
+			// log_d( " SC6_ _Check_Data   %d   size_received  %d  sc6.index_SC6_LPT site -> %d" , 
+			// 		sc6.state ,sc6.size_received, sc6.index_SC6_LPT );
+			// log_d( " SC6_Task    %s   " , sc6.SC6_Data_Buf );
+
+			// find begin tag   "SC6_LPT" ,index_SC6_LPT 为出现 "SC6_LPT" 的位置编号
+            if ( sc6.index_SC6_LPT==0xFFFF && sc6.size_received > 2*SC6_Rcv_Buf_Size +SC6_RESUMED_Buf_Size) 
+            {
+				log_d( " SC6_Task  check ....bytes overflow   "  );
+                err_con++;
+                if( err_con > 2)
+                {
+                    HAL_UART_DMAStop(SC6_uart_helper->huart );
+                    sc6.state = SC6_State_Error;
+                    sc6.size_received = 0;
+                    sc6.index_SC6_LPT =0xFFFF;
+                    err_con = 0;   
                     break;                     
                 }
                 // 重新测量
-                log_w( " SC6_ Get Data  Error %d,  Retrying...",sc6->error   );
-                HAL_UART_DMAStop(sc6->uarthelper ->huart );
+                log_w( " SC6_ Get Data  Error %d,  Retrying...", err_con   );
+                HAL_UART_DMAStop(SC6_uart_helper->huart );
             }
-            sc6->index_SC6_LPT = 0;
-            // if ( sc6->index_SC6_LPT==0 && sc6->size_received <= 2*SC6_Rcv_Buf_Size +SC6_RESUMED_Buf_Size && sc6->size_received!=0) 
-            if ( sc6->index_SC6_LPT==0   && sc6->size_received!=0) 
+            sc6.index_SC6_LPT = 0xFFFF;
+            // if ( sc6.index_SC6_LPT==0xFFFF && sc6.size_received <= 2*SC6_Rcv_Buf_Size +SC6_RESUMED_Buf_Size && sc6.size_received!=0) 
+            if ( sc6.index_SC6_LPT==0xFFFF   && sc6.size_received!=0 ) 
             {
-
-                for (size_t i = 0; i < sc6->size_received; i++)
+				// log_d( " SC6_Task  check ....  "  );
+                for (size_t i = 0; i < sc6.size_received; i++)
                 {
-                    if (sc6->SC6_Data_Buf[i]  == data_start_tag[0] ) 
+                    if (sc6.result_buf[i]  == data_start_tag[0] ) 
                     {
-                        log_i( " ....i   %d   %02X   %02X", i ,data_start_tag[0], sc6->SC6_Data_Buf[i] );
-                        if ( sc6->SC6_Data_Buf[i+1]  == data_start_tag[1] &&  sc6->SC6_Data_Buf[i+2]  == data_start_tag[2]
-                            &&  sc6->SC6_Data_Buf[i+3]  == data_start_tag[3] &&  sc6->SC6_Data_Buf[i+4]  == data_start_tag[4]
-                            &&  sc6->SC6_Data_Buf[i+5]  == data_start_tag[5] &&  sc6->SC6_Data_Buf[i+6]  == data_start_tag[6])
+                        // log_d( " ....i   %d   %02X   %02X", i ,data_start_tag[0], sc6.result_buf[i] );
+                        if ( sc6.result_buf[i+1]  == data_start_tag[1] && sc6.result_buf[i+2]  == data_start_tag[2]
+                            &&  sc6.result_buf[i+3]  == data_start_tag[3] &&  sc6.result_buf[i+4]  == data_start_tag[4]
+                            &&  sc6.result_buf[i+5]  == data_start_tag[5] &&  sc6.result_buf[i+6]  == data_start_tag[6])
                         {
-                            sc6->index_SC6_LPT = i;
+                            sc6.index_SC6_LPT = i;
                             break;
                         }
 
@@ -275,232 +252,180 @@ void SC6_Task(void* argument)
                 }
             }
 
-            if ( sc6->index_SC6_LPT!=0 ) 
+            if ( sc6.index_SC6_LPT!=0xFFFF ) 
             {
-                // log_w( "  SC6_LPT was found  %d  %d  %d  " ,sc6->size_received,sc6->index_SC6_LPT,SC6_Rcv_Buf_Size );
-                // log_w( "  SC6_LPT  %02X  %02X %02X %02X" 
-                //         ,sc6->SC6_Data_Buf[0] ,sc6->SC6_Data_Buf[12], sc6->SC6_Data_Buf[13],sc6->SC6_Data_Buf[309]);
-                // log_w( "  SC6_LPT  %02X  %02X %02X %02X" 
-                //         ,sc6->SC6_Data_Buf[306] ,sc6->SC6_Data_Buf[307], sc6->SC6_Data_Buf[308],sc6->SC6_Data_Buf[309]);
-                // TODO  拷贝后数据 。。。
-                if (  (sc6->size_received - sc6->index_SC6_LPT >= SC6_Result_Buf_Size) 
-                        && sc6->SC6_Data_Buf[sc6->index_SC6_LPT+SC6_Result_Buf_Size-1] == data_end_tag[1] )
+                // log_d( "  SC6_LPT was found  %d  %d  %d  " ,sc6.size_received,sc6.index_SC6_LPT,SC6_Rcv_Buf_Size );
+                // log_d( "  sc6.result_buf[sc6.index_SC6_LPT+SC6_Result_Buf_Size-1]  %02X  " ,sc6.result_buf[sc6.index_SC6_LPT+SC6_Result_Buf_Size-1] );
+ 
+                if (  (sc6.size_received - sc6.index_SC6_LPT >= SC6_Result_Buf_Size) 
+                        && sc6.result_buf[sc6.index_SC6_LPT+SC6_Result_Buf_Size-1] == data_end_tag[1] )
                 {
-                    log_w("SC6_ Get Data OK..." );
-                    HAL_UART_DMAStop(sc6->uarthelper ->huart );
-                    memset(SC6_Rcv_Buf, 0, sizeof(SC6_Rcv_Buf));
+                    log_i("SC6_ Get Data OK..." );
+                    HAL_UART_DMAStop(SC6_uart_helper ->huart );
+                    memset(SC6_RCV_BUF, 0, sizeof(SC6_RCV_BUF));
                     //  result  sn 
-                    memcpy( sc6->SC6_Result_Buf, sc6->SC6_Data_Buf[sc6->index_SC6_LPT], SC6_Result_Buf_Size);
-                    memcpy( sc6->sn_buf, sc6->SC6_Data_Buf[sc6->index_SC6_LPT+4], 4);
-                    sc6->size_received = 0;
-                    sc6->index_SC6_LPT =0;
-                    sc6->error = 0;
-                    UartHelper_Set_Trans_Buf( sc6->uarthelper , stop_buf, sizeof(stop_buf) );
-                    SC6_Transmit(sc6, sc6->uarthelper->trans_buf, sc6->uarthelper ->trans_size);
-                    *state = MODULE_SC6_STATE_OK; 
+                    memcpy( sc6.SC6_Result_Buf, sc6.result_buf[sc6.index_SC6_LPT], SC6_Result_Buf_Size);
+                    memcpy( sc6.SC6_sn_buf, sc6.result_buf[sc6.index_SC6_LPT+4], 4);
+                    sc6.size_received = 0;
+                    sc6.index_SC6_LPT =0xFFFF;
+                    err_con = 0;
+                    UART_HELPER_Set_Trans_Buf( SC6_uart_helper , SC6_stop_buf, sizeof(SC6_stop_buf) );
+					SC6_Receive();
+					SC6_Transmit();
+                    sc6.state = SC6_State_Stop; 
+					break;
                 }
             }
- 
- 
-            if( (osKernelGetTickCount()- sc6->timebase) >=4000){
-                log_w("SC6_ Get Data Timeout Failed %d,Retrying...",sc6->error);
-                *state=MODULE_SC6_STATE_ERROR;
+ 			if( (osKernelGetTickCount()- ticks) >=4000){
+                log_w("SC6_ Get Data Timeout Failed %d,Retrying...",err_con);
+                sc6.state=SC6_State_Error;
                 break;
-            }            
+            }  
+            // sc6.state = SC6_State_Stop;
+            osDelay(1); 
             break;
-        case MODULE_SC6_STATE_OK:
-        //     log_i( " SC6_Task ok   %d   " , *state );
-                HAL_UART_DMAStop(sc6->uarthelper ->huart );
-                memset(SC6_Rcv_Buf, 0, sizeof(SC6_Rcv_Buf));
-                sc6->size_received = 0;
-                UartHelper_Set_Trans_Buf(sc6->uarthelper , stop_buf, sizeof(stop_buf));
-            break;
-        case MODULE_SC6_STATE_ERROR:
-            log_e( " SC6_Task   error    "  );
-                SC6_clean_flag( sc6 ,SC6_FLAG_MASK_BUSY);
-                HAL_UART_DMAStop(sc6->uarthelper ->huart );
-                memset(SC6_Rcv_Buf, 0, sizeof(SC6_Rcv_Buf));
-                sc6->size_received = 0;
-            *state=MODULE_SC6_STATE_WAIT;
-            break;   
-        case MODULE_SC6_STATE_STOP:
-            break;
-        default:
-            SC6_clean_flag( sc6 ,SC6_FLAG_MASK_BUSY);
-            *state=MODULE_SC6_STATE_WAIT;
+
+ 
+        case SC6_State_Stop:
+            // log_d("  SC6_ stop, aftetr deal, wait to change status....");
+            osDelay(10); 
+            continue;
+ 
+        case SC6_State_Timeout:
+            log_e( " SC6_ timeout ..... "  );
+            sc6.state = SC6_State_Waiting ;
+            // TODO 停止DMA
+            if (SC6_uart_helper->rcv_mode == Uart_Trans_DMA)
+            {
+            HAL_UART_DMAStop( SC6_uart_helper->huart );
+            }
+            osDelay(5); 
             break;
+        case SC6_State_Error:
+            log_e( " SC6_ error ..... "  );
+            sc6.state = SC6_State_Waiting ;
+            // TODO 停止DMA
+            if (SC6_uart_helper->rcv_mode == Uart_Trans_DMA)
+            {
+            HAL_UART_DMAStop( SC6_uart_helper->huart );
+            }
+            osDelay(5); 
+            break;  
         }
-
-        osDelay(300);
+        osDelay(20); 
     }
 }
 
-/******************         接口           *******************/
-void SC6_Set_Uarthelper(SC6_TypeDef *sc6, UartHelper_TypeDef *uarthelper)
-{
-    sc6->uarthelper  = uarthelper;
-}
 
-void SC6_Set_Interface(SC6_TypeDef *sc6, UartInterface_TypeDef *interface)
-{
-    sc6->uarthelper->interface = interface;
-}
-void SC6_Set_Huart( SC6_TypeDef * sc6,  UART_HandleTypeDef * huart  )
+void SC6_Trans_GPIO(void) 
 {
-    sc6->uarthelper->huart = huart;
+    // HAL_GPIO_WritePin(R_W_GPIO_Port,R_W_Pin, SET);
+    // HAL_GPIO_WritePin(NULL,0, SET);
+    HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, SET);
+    HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, RESET);
+    HAL_GPIO_WritePin(DE485_GPIO_Port, DE485_Pin, SET);
 }
 
-void SC6_Set_Interface_Type( SC6_TypeDef *sc6,    Uart_Interface_Type_Typedef interface_type  )
+void SC6_Trans_Cplt_GPIO(void) 
 {
-    sc6->interface_type = interface_type;  
-    sc6->uarthelper->interface_type = interface_type; 
-    UartInterface_Setup_Interface_type( sc6->uarthelper->interface ,sc6->interface_type); 
-}
+    // HAL_GPIO_WritePin(R_W_GPIO_Port,R_W_Pin, RESET);
+    // HAL_GPIO_WritePin(NULL,0, RESET);
+    HAL_GPIO_WritePin(SEL_232_485_GPIO_Port,SEL_232_485_Pin, SET);
+    HAL_GPIO_WritePin(HDPLX_GPIO_Port,HDPLX_Pin, SET);
+    HAL_GPIO_WritePin(DE485_GPIO_Port, DE485_Pin, RESET);
+} 
 
-void SC6_Set_RsMode_232_485(SC6_TypeDef *sc6, Uart_RS_Mode_TypeDef rs_232_485)
+int SC6_Transmit()
 {
-    //  TODO理清逻辑
-    sc6->mode_232_485 = rs_232_485; 
-    sc6->uarthelper->mode_232_485 = rs_232_485; 
-       UartInterface_Setup_Mode_232_485( sc6->uarthelper->interface, rs_232_485 );
-}
-void SC6_Set_Trans_Type( SC6_TypeDef *sc6,  Uart_Transmode_TypeDef trans_type  )
-{
-    sc6->trans_type = trans_type; 
-}
-void SC6_Set_Rcv_Type( SC6_TypeDef *sc6,  Uart_Transmode_TypeDef rcv_type  )
-{
-    sc6->rcv_type = rcv_type; 
-    
-}
-void SC6_Set_Idle_Enable( SC6_TypeDef *sc6,  Uart_IDLE_Enable_TypeDef idle_enable_disable  )
-{
-    sc6->idle_enable_disable = idle_enable_disable; 
-
-}
-void SC6_Set_TransMode( SC6_TypeDef *sc6,  Uart_Transmode_TypeDef trans_mode  )
-{
-    sc6->trans_type = trans_mode; 
-    sc6->rcv_type = trans_mode; 
-
-}
- 
-void SC6_Set_Timeout( SC6_TypeDef *sc6,    uint16_t timeout_ms )
-{
-    sc6->timeout_ms = timeout_ms; 
-    sc6->timeout_enable = 1;
-
-}
-void SC6_Set_Sendbuf( SC6_TypeDef *sc6,  uint8_t * buf, uint16_t size )
-{
- 
-    sc6->send_buf = buf;
-    sc6->size_send = size;
-}
-void SC6_Set_Rcvbuf( SC6_TypeDef *sc6,  uint8_t * buf, uint16_t size )
-{
-    sc6->rcv_buf = buf;
-    sc6->size_rcv = size;
-
-}
-
-int SC6_Get_Timeout(SC6_TypeDef *sc6)
-{
-    if ((osKernelGetTickCount() - sc6->timebase) > sc6->timeout_ms)
-        return 1;
-    return 0;
-}
-
-int SC6_Transmit(SC6_TypeDef *sc6, uint8_t *buf, uint16_t size)
-{
-
-    if (sc6->timeout_enable == 1)
+    //  TODO 结合队列
+    sc6.size_received =0;
+    if( SC6_uart_helper->transferring == 0)
     {
-        sc6->timebase = osKernelGetTickCount();
+        return UART_HELPER_Trans(SC6_uart_helper, SC6_uart_helper->trans_record->buf, SC6_uart_helper->trans_record->size );
     }
-    return UartHelper_Transmit(sc6->uarthelper , buf, size);
-}
-
-int SC6_Begin_Rcv(SC6_TypeDef *sc6, uint8_t *buf, uint16_t size)
-{
-    return UartHelper_Begin_Rcv(sc6->uarthelper , buf, size);
-}
-
-Uart_Status_TypeDef SC6_Get_UartHelper_Status(SC6_TypeDef *sc6)
-{
-    return sc6->uarthelper ->status;
-}
-int SC6_Set_UartHelper_Status(SC6_TypeDef *sc6, Uart_Status_TypeDef status)
-{
-    sc6->uarthelper ->status = status;
     return 0;
 }
 
-int SC6_Init_Ok()
-{
-    // uint64_t timebase = osKernelGetTickCount( );
-    // while (1)
-    // {
-    //     log_i(  " flag :  %d  %d ",sc6->flag , (sc6->flag & SC6_FLAG_MASK_RECVED_WL));
-    //     if (count > 50)  break;
-    //     if (  sc6->flag & SC6_FLAG_MASK_RECVED_WL != 0   ) return 0;
-    //     osDelay ( 20 );
-    //     count++;
-    // }
-    // return -1;
-    
-}
-
-int SC6_Get_Data_OK(SC6_TypeDef *sc6)
-{
-    return sc6->data_ok;
-}
-void SC6_Set_Send_Flag(SC6_TypeDef *sc6)
+int SC6_Receive()
 {
-    // vPortEnterCritical();
-    sc6->send_flag = 1;
-    sc6->command_seq = 0;
-    sc6->data_ok = 0;
-    // vPortExitCritical( );
+    return UART_HELPER_Start_Rcv(SC6_uart_helper, SC6_uart_helper->rcv_buf, SC6_uart_helper->rcv_size);
+    // return UART_HELPER_Start_Rcv(SC6_uart_helper, SC6_RCV_BUF, 13);
+    // return 0;
 }
 
-
-void SC6_callback(SC6_TypeDef *sc6, uint8_t *buf, uint16_t size)
+void SC6_Set_Timeout_ms(    uint64_t ms_ticks )
 {
+    sc6.timeout_ticks = ms_ticks;
 }
 
-void SC6_Set_GPIO_For_TC_Cplt(SC6_TypeDef *sc6)
+int SC6_Validate(   )
 {
-    // sc6->status = 2;
-    UartHelper_Set_GPIO_For_Trans_Cplt(sc6->uarthelper );
+    return CRC16_Check(sc6.result_buf ,sc6.size_received);
 }
 
 
-void SC6_clean_flag(SC6_TypeDef *sc6,uint8_t mask)
-{
-    sc6->flag&=~mask;
-}
- 
-uint8_t SC6_get_flag(SC6_TypeDef *sc6,uint8_t mask)
-{
-    return sc6->flag&mask;
-}
-
-uint16_t SC6_get_serial_number(SC6_TypeDef * sc6 )
+int SC6_CallBack( SC6_TypeDef *pPH, uint8_t *buf, uint16_t size )
 {
-    // if((sc6->flag&SC6_FLAG_MASK_RECVED_SN)==0){
-    //     return 0xffff;
-    // }
-    // return sc6->sn;
-}
-
-
-void SC6_Error(SC6_TypeDef *sc6, char *str)
-{
-    log_e(str);
-    while (1)
-        ;
+    log_d( " SC6_CallBack  -- state %d  size %d" , sc6.state, size);
+    uint16_t size_tmp;
+    size_tmp =size;
+    switch (sc6.state)
+    {
+        case SC6_State_Test_Data_Getting:
+            if (size>0) 
+            {
+                sc6.state++;
+            }
+            break;
+        case SC6_State_Check_Data:
+            if (size == 0)  return 0;
+            if ((size + sc6.size_received) >= sizeof(sc6.result_buf) )
+            {
+                size_tmp = sizeof(sc6.result_buf) - sc6.size_received;
+            }
+            memcpy( (uint32_t)(sc6.result_buf+sc6.size_received), SC6_uart_helper->rcv_buf, size_tmp );
+            sc6.size_received = sc6.size_received+size_tmp;
+	
+
+            // if ( SC6_uart_helper->enable_idle_it == 0 )
+            // {
+            //     // Modbus 长度校验，拷贝数据？
+            //     if( sc6.size_received == ( sc6.result_buf[2]+ 5 ) )
+            //     {
+            //         sc6.state++;
+            //     }
+            //     return 0;
+            // }
+            // if ( SC6_uart_helper->enable_idle_it == 1 )
+            // {
+            //     // 长度校验，拷贝数据？
+            //     if( sc6.size_received == ( sc6.result_buf[2]+ 5 ) )
+            //     {
+            //         sc6.state++;
+            //     }
+            //     return 0;
+            // }   
+            break;  
+        default:
+            break;
+    }
+    return 0;
 }
 
-
-#endif
+// CRCValue = HAL_CRC_Calculate(&hcrc, (uint32_t *)dataBuffer, BUFFER_SIZE);
+
+// void SC6_Set_Interface( SC6_TypeDef *ph,  UartInterface_TypeDef * interface  )
+// {
+//     UartHelper_Set_Interface( sc6.uarthelper,   interface );
+// }
+// void SC6_Set_Huart( SC6_TypeDef *ph,  UART_HandleTypeDef * huart  )
+// {
+//     sc6.uarthelper->huart = huart;
+//     // UartHelper_Set_Huart( sc6.uarthelper,    huart  );
+// }
+// void SC6_Set_Interface_Type( SC6_TypeDef *ph,    Uart_Interface_Type_Typedef interface_type  )
+// {
+//     sc6.interface_type = interface_type;  
+//     sc6.uarthelper->interface_type = interface_type; 
+//     UartInterface_Setup_Interface_type( sc6.uarthelper->interface ,sc6.interface_type); 
+// }

device/Src/uart_helper.c

@@ -1,315 +0,0 @@
-#include "uart_helper.h"
-#include "elog.h"
-
-
-UartHelper_TypeDef * UartHelper_Init( )
-{
-    UartHelper_TypeDef *Handle = (UartHelper_TypeDef *)malloc(sizeof(UartHelper_TypeDef));
-    if (Handle == NULL)
-    {
-        return NULL;
-    }
- 
-	// Handle->interface = UartInterface_Init();
-	Handle->interface = UartInterface_Init();
-	// Handle->interface_type = 0;
- 
-    Handle->interface_type = 0; /* 0: common, 1: 485 ,2:3160*/
-	Handle->mode_232_485 = 0; /* 0: common, 1: 485  */
-    Handle->trans_type = 2;   /* 0 :polling, 1: IT  2: DMA*/
-    Handle->rcv_type = 2;  /* 0 :polling, 1: IT  2: DMA*/
-    Handle->idle_enable_disable = 1;    /* 0 不开启空闲中断 ， 1 开启空闲中断 */
-	Handle->trans_mode = 2;         /* 0 :polling, 1: IT  2: DMA*/
-	Handle->status = Uart_Status_Ready;         /* 0 :polling, 1: IT  2: DMA*/
-	Handle->huart = NULL;  
-	Handle->obj = NULL;  
-	Handle->callback = NULL;  
-    // Handle->timeout_enable = 0;        
-    // Handle->timeout_ms = 0;        
-    // Handle->timebase_ticks = 0;        
-    return Handle;
-
-}
-
-void UartHelper_Set_Interface( UartHelper_TypeDef *uarthelper,  UartInterface_TypeDef * interface )
-{
-    uarthelper->interface = interface;
-}
-void UartHelper_Set_Huart( UartHelper_TypeDef *uarthelper,  UART_HandleTypeDef * huart  )
-{
-    uarthelper->huart = huart;
-}
-void UartHelper_Set_Interface_Type( UartHelper_TypeDef *uarthelper,   Uart_Interface_Type_Typedef interface_type  )
-{
-    uarthelper->interface_type = interface_type;
-}
-void UartHelper_Set_Trans_Type( UartHelper_TypeDef *uarthelper,  Uart_Transmode_TypeDef trans_type  )
-{
-    uarthelper->trans_type = trans_type;
-}
-void UartHelper_Set_Rcv_Type( UartHelper_TypeDef *uarthelper,  Uart_Transmode_TypeDef rcv_type  )
-{
-    uarthelper->rcv_type = rcv_type;
-}
-void UartHelper_Set_Idle_Enable( UartHelper_TypeDef *uarthelper,  Uart_IDLE_Enable_TypeDef idle_enable_disable  )
-{
-    uarthelper->idle_enable_disable = idle_enable_disable;
-}
-void UartHelper_Set_TransMode( UartHelper_TypeDef *uarthelper,  Uart_Transmode_TypeDef trans_mode  )
-{
-    uarthelper->trans_mode = trans_mode;
-}
-void UartHelper_Set_RsMode_232_485( UartHelper_TypeDef *uarthelper,  Uart_RS_Mode_TypeDef mode_232_485  )
-{
-    uarthelper->mode_232_485 = mode_232_485;
-    UartInterface_Setup_Mode_232_485( uarthelper->interface, uarthelper->mode_232_485);
-}
-
-// void UartHelper_Set_timeout( UartHelper_TypeDef *uarthelper,  uint32_t timeout_ms  )
-// {
-//     uarthelper->timeout_ms = timeout_ms;
-//     uarthelper->timeout_enable = 1;
-// }
-
-int UartHelper_Set_callback_func_obj( UartHelper_TypeDef *uarthelper,   void * obj,  it_callback callback )
-{
-    if(uarthelper==NULL || callback==NULL || obj==NULL){
-        return -1;
-    }
-    uarthelper->callback    =callback;
-    uarthelper->obj =obj;
-    return 0;
-}
-
-void UartHelper_Set_rcv_buf( UartHelper_TypeDef *uarthelper, uint8_t *buf, uint32_t buf_size )
-{
-    uarthelper->receive_buf = buf;
-    uarthelper->receive_buf_half_len = buf_size/2;
-}
-
-void UartHelper_Set_Trans_Buf( UartHelper_TypeDef *uarthelper, uint8_t *buf, uint32_t buf_size )
-{
-    uarthelper->trans_buf = buf;
-    uarthelper->trans_size = buf_size;
-}
-
-int UartHelper_Transmit( UartHelper_TypeDef *uarthelper,  uint8_t * buf, uint16_t size)
-{
-    // log_i( "SensorSend  size_   "   );
-    // set gpio
-    UartInterface_Set_GPIO_For_Transmit( uarthelper->interface );
-    // it idle  start
-    // if ( uarthelper->idle_enable_disable == 1 )    
-    // {
-    //     log_i( "start idle .... ");
-    //     __HAL_UART_ENABLE_IT(uarthelper->huart, UART_IT_IDLE);
-    // }
-
-    /* 开启 transmit */
-    if (buf!=NULL  )
-    {
-        uarthelper->status  = Uart_Status_Sending;
-        if ( uarthelper->trans_type == 0 )
-            return HAL_UART_Transmit( uarthelper->huart,  buf,  size ,0x0FFF);
-        if ( uarthelper->trans_type == 1 )
-            return HAL_UART_Transmit_IT( uarthelper->huart,  buf,  size );
-        if ( uarthelper->trans_type == 2 )
-            return HAL_UART_Transmit_DMA( uarthelper->huart,  buf,  size );
-    }
-    if (buf==NULL  && uarthelper->trans_buf !=NULL)
-    {
-        uarthelper->status  = Uart_Status_Sending;
- 
-        if ( uarthelper->trans_type == 0 )
-            return HAL_UART_Transmit( uarthelper->huart, uarthelper->trans_buf, uarthelper->trans_size ,0x0FFF);
-        if ( uarthelper->trans_type == 1 )
-            return HAL_UART_Transmit_IT( uarthelper->huart, uarthelper->trans_buf, uarthelper->trans_size);
-        if ( uarthelper->trans_type == 2 )
-            return HAL_UART_Transmit_DMA( uarthelper->huart, uarthelper->trans_buf, uarthelper->trans_size);
-    }
-    return -1;
-}
-
-
-int UartHelper_Begin_Rcv(UartHelper_TypeDef *uarthelper,  uint8_t * buf, uint16_t size)
-{
-    /* 是否开启空闲中断*/
-    if ( uarthelper->idle_enable_disable == 1 )
-    {
-        __HAL_UART_ENABLE_IT( uarthelper->huart, UART_IT_IDLE );
-    }
- 
-    if ( uarthelper->rcv_type == 0 )
-    {
-        // TODO  发生错误怎么处理
-        HAL_UART_Receive( uarthelper->huart,  buf,  size ,0X0FFF);
-    }
-
-    if ( uarthelper->rcv_type == 1 )
-    {
-        HAL_UART_Receive_IT( uarthelper->huart,  buf,  size);
-    }
-
-    if ( uarthelper->rcv_type == 2 )
-    {
-        // log_i( "start dma rcv.... . ");
-        HAL_UART_Receive_DMA( uarthelper->huart,  buf,  size);
-    }
-}
-
-
-void UartHelper_Set_GPIO_For_Trans_Cplt(  UartHelper_TypeDef *uarthelper )
-{
-    uarthelper->status      = Uart_Status_Ready;
-    // log_i(" UartHelper_Set_GPIO_For_Trans_Cplt ...  %d   %d", uarthelper->interface_type, uarthelper->mode_232_485);
-    if (uarthelper->interface_type != Uart_Interface_Default && uarthelper->mode_232_485 ==Uart_RSMODE_485)
-    {
-        // log_i(" UartHelper_Set_GPIO_For_Trans_Cplt ... 111111");
-        UartHelper_Set_GPIO_For_Trans_Cplt( uarthelper->interface  );
-    }
-}
-
-void UartHelper_Rcv_Cplt_Callback( UartHelper_TypeDef *uarthelper  )
-{
-    // TODO 超时 --> 尽量用空闲中断代替  接收指定长度完成中断
-
-    // TODO 拷贝数据
- 
-}
-
-void UartHelper_Rcv_Idle_Callback( UartHelper_TypeDef *uarthelper  )
-{
-    /* 搬运 数据到 kfifo*/
- 
-        log_i("SC6....huart3 IDLE....");
-
-        uint16_t count = __HAL_DMA_GET_COUNTER( uarthelper->huart->hdmarx );
-         uint16_t data_length  = 2*uarthelper->receive_data_size - count; 
-
-        // if (count != 0 && data_length != 0)
-        if ( data_length != 0 )
-        {
-            // TODO 拷贝数据  最后一位  datalenth-1
-            HAL_UART_DMAStop( uarthelper->huart );
-            uarthelper->callback( uarthelper->obj, uarthelper->receive_buf, data_length);
-
-        }
- 
-}
-
-void UartHelper_Rcv_DMA_Half_Callback( UartHelper_TypeDef *uarthelper  )
-{
-    /* 循环模式才有  半满中断 */
-}
- 
-
-int UartHelper_copy(UartHelper_TypeDef *uarthelper,uint8_t *buf,uint32_t buf_size)
-{
-    int data_len;
-    if(uarthelper==NULL || buf==NULL){
-        return -1;
-    }
-    data_len = uarthelper->receive_data_size;
-    if(buf_size<data_len){
-        return -2;
-    }
-    if(data_len!=0){
-        // TODO
-        // memcpy(buf,uart_get_receive_buff(uart_buf),data_len);
-        uarthelper->receive_data_size=0;
-    }
-    return data_len;
-
-}
-int UartHelper_isbusy(UartHelper_TypeDef *uarthelper )
-{
-    if (uarthelper->status==Uart_Status_Sending)
-        return 1;
-    return 0;
-}
-void UartHelper_error(UartHelper_TypeDef *uarthelper )
-{
-     while(1);  
-}
-
-uint16_t Get_Crc16(const char *buf, uint16_t len)
-{
-    int crc = 0xffff;
-    for (int i = 0; i < len; i++)
-    {
-        crc ^= buf[i];
-        for (int j = 0; j < 8; j++)
-        {
-            if (crc & 1 == 1)
-            {
-                crc >>= 1;
-                crc ^= 0xa001;
-            }
-            else
-            {
-                crc >>= 1;
-            }
-        }
-    }
-    uint8_t cs1 = crc & 0xff; // 校验码的低字节
-    uint8_t cs2 = (crc & 0xff00) >> 8; // 校验码的高字节
-    return crc;
-};
- 
-
-uint8_t Check_Crc16(uint8_t *buf, uint16_t length){   
-    uint16_t len = length-2;
-      int crc = 0xffff;
-    for (int i = 0; i < len; i++)
-    {
-        crc ^= buf[i];
-        for (int j = 0; j < 8; j++)
-        {
-            if (crc & 1 == 1)
-            {
-                crc >>= 1;
-                crc ^= 0xa001;
-            }
-            else
-            {
-                crc >>= 1;
-            }
-        }
-    }
-    uint8_t cs1 = crc & 0xff; // 校验码的低字节
-    uint8_t cs2 = (crc & 0xff00) >> 8; // 校验码的高字节
-    log_i( "  %d  %d  %d ",crc ,cs1, cs2  )  ;
-    log_i( "  %d  %d  %d ",crc ,buf[length-2], buf[length-1]  )  ;
-
-    if ( (crc & 0xff) == buf[length-2] && ((crc & 0xff00) >> 8) == buf[length-1])
-    {
-        return 1;
-    }
-    else   
-    {
-         return 0;       
-    } 
-}
-
-
-        //     //  HAL_UART_DMAStop  HAL_UART_Receive_DMA 成对使用，可从指定指针开始
-        //     //  HAL_UART_DMAPause HAL_UART_DMAResume 成对使用
-        //     HAL_UART_DMAStop( sc6->huart );
-        //     memcpy(sc6->SC6_Data_Buf, sc6->SC6_Raw_Buf, data_length);
-        //     sc6->size_received = data_length;
-        //     log_i("  IDLE.... count  %d   data_length %d   ",count,data_length );
-        //     log_i("  IDLE....   -> %02X %02X %02X %02X ", sc6->SC6_Data_Buf[0] , sc6->SC6_Data_Buf[1], sc6->SC6_Data_Buf[2] , sc6->SC6_Data_Buf[3]);
-        //     log_i("  IDLE....   -> %02X %02X %02X %02X  ",
-        //          sc6->SC6_Data_Buf[data_length] , sc6->SC6_Data_Buf[data_length-1], sc6->SC6_Data_Buf[data_length-2] , sc6->SC6_Data_Buf[data_length-3]);
-        //     log_i("  IDLE....   -> %s ", sc6->SC6_Data_Buf );
-        //     //  TODO数据清零 DMA指针指向开始的地方  或双缓冲 
-        //     // memset(sc6->SC6_Data_Buf, 0, sizeof(sc6->SC6_Data_Buf));
-        //     memset(sc6->SC6_Raw_Buf, 0, sizeof(sc6->SC6_Raw_Buf));
-        // // HAL_UART_DMAStop( sc6->myuart->huart );
-        //             // SC6_Begin_Rcv( sc6,  sc6->SC6_Raw_Buf, sizeof(sc6->SC6_Raw_Buf));
-        //         __HAL_UART_ENABLE_IT( sc6->huart, UART_IT_IDLE);
-        //         HAL_UART_Receive_DMA( sc6->huart,  sc6->SC6_Raw_Buf, sizeof(sc6->SC6_Raw_Buf));
-        //     // HAL_UART_DMAResume( sc6->myuart->huart );
-
-        /* 再次开启DMA接收 重新接收 */
-        // HAL_UART_Receive_DMA(&UartHandle, UartHandle.pRxBuffPtr, UartHandle.RxXferSize);

device/Src/uart_interface.c

@@ -1,241 +0,0 @@
-#include "uart_interface.h"
-#include "elog.h"
-
-UartInterface_TypeDef * UartInterface_Init( )
-{
-    UartInterface_TypeDef *Handle = (UartInterface_TypeDef *)malloc(sizeof(UartInterface_TypeDef));
-    if (Handle == NULL)
-    {
-        return NULL;
-    }
- 
-	// Handle->send_status = 0;
-	Handle->interface_type = 0;
- 
-#if MAX485_ENABLE
-	Handle->de485_gpio = NULL;
-	Handle->interface_type = 1;
-#endif
-
-#if MAX3160_ENABLE
-    Handle->de485_gpio = NULL;
-	Handle->sel_gpio = NULL;
-	Handle->dplx_gpio = NULL;
-	Handle->interface_type = 2;
-#endif
-
-    return Handle;
-}
-
-/**
- * @brief interface->   0:default, 1:485, 2:3160 
- * @param [in] myuart 
- * @param [in] interface 
- * @return int 
- * 
- * @details 
- */
-int UartInterface_Setup_Interface_type( UartInterface_TypeDef * interface, Uart_Interface_Type_Typedef interface_type )
-{
-	interface->interface_type = interface_type;
-	return 0;    
-}
- 
-int UartInterface_Setup_Mode_232_485( UartInterface_TypeDef * interface, Uart_RS_Mode_TypeDef mode_232_485 )
-{
-	interface->mode_232_485 = mode_232_485;
-    if (interface->interface_type == 0)
-        UartInterface_Set_232( interface);
-    if (interface->interface_type == 1)
-        UartInterface_Set_485( interface);
-    if (interface->interface_type ==2 && interface->mode_232_485 ==Uart_RSMODE_232)
-        UartInterface_Set_232( interface);
-    if (interface->interface_type ==2 && interface->mode_232_485 ==Uart_RSMODE_485)
-        UartInterface_Set_485( interface);
-
-	return 0;          
-}
-void UartInterface_Set_Sel_GPIO_Pin(UartInterface_TypeDef * interface, GPIO_TypeDef *gpio, uint16_t pin)
-{
-    if (gpio!=NULL && pin>=0)
-    {
-#if MAX3160_ENABLE
-        interface->sel_gpio = gpio;
-        interface->sel_pin = pin;  
-#endif     
-    }
- 
-}
-
-void UartInterface_Set_Dplx_GPIO_Pin(UartInterface_TypeDef * interface, GPIO_TypeDef *gpio, uint16_t pin)
-{
-    if (gpio!=NULL && pin>=0)
-    {
-#if MAX3160_ENABLE
-        interface->dplx_gpio = gpio;
-        interface->dplx_pin = pin;   
-#endif   
-    }
-// #if MAX3160_ENABLE
-//     interface->dplx_gpio = gpio;
-//     interface->dplx_pin = pin;
-// #endif
-}
-
-void UartInterface_Set_DE485_GPIO_Pin(UartInterface_TypeDef * interface, GPIO_TypeDef *gpio, uint16_t pin)
-{
-    if (gpio!=NULL && pin>=0)
-    {
-#if MAX3160_ENABLE
-        interface->de485_gpio = gpio;
-        interface->de485_pin = pin;   
-#endif  
-#if MAX485_ENABLE
-        interface->de485_gpio = gpio;
-        interface->de485_pin = pin;   
-#endif               
-    }
-    // interface->de485_gpio = gpio;
-    // interface->de485_pin = pin;
-}
-
-void UartInterface_Set_232(UartInterface_TypeDef * interface)
-{
-    interface->mode_232_485 = Uart_RSMODE_232;
-#if MAX3160_ENABLE
-    if (interface->sel_gpio != NULL)
-        HAL_GPIO_WritePin(interface->dplx_gpio, interface->dplx_pin , DUPLEX_FULL);
-    interface->sel = SEL_232;
-    if (interface->sel_gpio != NULL)
-        HAL_GPIO_WritePin( interface->sel_gpio, interface->sel_pin,  interface->sel );
-#endif
-//     interface->mode_232_485 = 0;
-}
-
-void UartInterface_Set_485(UartInterface_TypeDef * interface)
-{
-    interface->mode_232_485 = Uart_RSMODE_485;
-
-    // log_i(".......set 485   ");
-
-#if MAX3160_ENABLE
-    interface->sel = SEL_485;
-    if (interface->sel_gpio != NULL)
-        // log_i(".......set 485   set dplx ");
-        HAL_GPIO_WritePin(interface->dplx_gpio, interface->dplx_pin , DUPLEX_HALF);
-    if (interface->de485_gpio != NULL)
-        // log_i(".......set 485   set de ");
-        HAL_GPIO_WritePin( interface->de485_gpio, interface->de485_pin, DISABLE_485_SEND );
-    if (interface->sel_gpio != NULL)
-        // log_i(".......set 485   set sel... ");
-        HAL_GPIO_WritePin( interface->sel_gpio, interface->sel_pin, interface->sel );
-    // log_i(" UartInterface_Set_485  222  interface->sel : %d   duplex: %d ",interface->sel , HAL_GPIO_ReadPin(interface->dplx_gpio,interface->dplx_pin)  );
-#endif
-
-#if MAX485_ENABLE
-    if (interface->de485_gpio != NULL)
-        // log_i(".......set 485   set de ");
-        HAL_GPIO_WritePin( interface->de485_gpio, interface->de485_pin, DISABLE_485_SEND );
- 
-#endif
-
-}
-
-
-/**
- * @brief 发送前操作 GPIO
- * @param [in] myuart 
- * @return int 
- * 
- * @details 
- */
-int UartInterface_Set_GPIO_For_Transmit( UartInterface_TypeDef * interface )
-// int UartInterface_Send_TxPrepare_Callback( UartInterface_TypeDef * interface )
-{
-#if MAX3160_ENABLE
-    if (interface->mode_232_485 == 0) 
-    {
-        HAL_GPIO_WritePin(interface->dplx_gpio, interface->dplx_pin , DUPLEX_FULL);
-
-    };
-    if ( interface->interface_type ==  2 && interface->mode_232_485 == 1 )
-    {
-        // log_i( " ----   UartInterface_Set_GPIO_For_Transmit " );
-        HAL_GPIO_WritePin(interface->dplx_gpio, interface->dplx_pin ,  DUPLEX_FULL);  // 全双工启动发送
-        HAL_GPIO_WritePin(interface->de485_gpio, interface->de485_pin, ENABLE_485_SEND);   
-        return 0;     
-    }    
-
-#endif
-#if MAX485_ENABLE
-    if (interface->interface_type ==  1)
-    {
-        HAL_GPIO_WritePin(interface->de485_gpio, interface->de485_pin, ENABLE_485_SEND);           
-    }
-#endif
-    return 0;
-
-// #if MAX3160_ENABLE
-//     if (interface->interface_type == 2 && )
-//     {
-//         switch  (interface->sel)
-//         {
-//             case SEL_232:
-//                 HAL_GPIO_WritePin(interface->dplx_gpio, interface->dplx_pin , DUPLEX_FULL);
-//                 // return  __UartInterface_Send(myuart,buf,size);
-//                 break;
-//             case SEL_485:
-//                 log_i(" 485 mode writepin...... ");
-//                 HAL_GPIO_WritePin(interface->dplx_gpio, interface->dplx_pin ,  DUPLEX_FULL);    
-//                 HAL_GPIO_WritePin( interface->de485_gpio, interface->de485_pin, ENABLE_485_SEND);
-//                 // return  __UartInterface_Send(myuart,buf,size);
-//                 break;
-//             default:
-//                 break;
-//         }
-//     }
-
-// #endif
- 
-// #if MAX485_ENABLE
-//     if (interface->interface_type == 1)
-//     {
-//         HAL_GPIO_WritePin(interface->dplx_gpio, interface->dplx_pin ,  DUPLEX_FULL);
-//         HAL_GPIO_WritePin( interface->de485_gpio, interface->de485_pin, ENABLE_485_SEND);        // return  __Max3160_Send(max3160,buf,size);
-//     }
-// #endif    
-}
-
-/**
- * @brief 发送完成后操作 GPIO
- * @param [in] myuart 
- * @return int 
- * 
- * @details 
- */
-// 接收完成，切换到接收状态， 全双工接收
-int UartInterface_Set_GPIO_For_Trans_Cplt( UartInterface_TypeDef * interface )
-{
-    // interface->send_status = 0;
- 
-#if MAX3160_ENABLE
-    if ( interface->interface_type ==  2 && interface->mode_232_485 == 1)
-    {
-        HAL_GPIO_WritePin(interface->dplx_gpio, interface->dplx_pin ,  DUPLEX_HALF);  // 半双工接收
-        HAL_GPIO_WritePin(interface->de485_gpio, interface->de485_pin, DISABLE_485_SEND);   
-        return 0;     
-    }    
-    if (interface->mode_232_485 == 0) return -1;
-#endif 
-#if MAX485_ENABLE
-    if (interface->interface_type ==  1)
-    {
-        HAL_GPIO_WritePin(interface->de485_gpio, interface->de485_pin, DISABLE_485_SEND);           
-        return 0;
-    }
-    if (interface->mode_232_485 == 0) return -1;
-#endif
-
-    return 0;
-}
-

device/Src/wh_lte_7s4_v2_2.c

@@ -1,737 +0,0 @@
-/**
- * @file wh_lte_7s4_v2.c
- * @author Chen Jihang (embedded@eseaoptics.com)
- * @brief WH LTE 7S4 V2驱动
- * @version 0.1
- * @date 2022-07-18
- * 
- * @copyright ESEA (c) 2020
- * 
- */
-#include "wh_lte_7s4_v2.h"
-// #include "convert.h"
-#include "string.h"
-#include "usart.h"
-
-WH_LTE_7S4_Typedef *wh_lte_7s4;
-
-
-void wh_lte_7s4_port( )
-{
-    wh_lte_7s4 = wh_lte_7s4_init();
-    // Oscar_Set_myuart( wh_lte_7s4, NULL );
-    // Oscar_Set_Timeout( oscar, 1000 );
-    // Oscar_Set_Sendbuf( oscar, Oscar_sendbuf, sizeof(Oscar_sendbuf) );
-    // Oscar_Set_Rcvbuf( oscar, Oscar_rcvbuf, sizeof(Oscar_rcvbuf) );
-
-    wh_lte_7s4->myuart =   Myuart_Init();
-    // MYUART_TypeDef *myuart_handle = Myuart_Init();
-    Myuart_Set_Huart( wh_lte_7s4->myuart, &huart3);
-    Myuart_Set_Sel_GPIO_Pin( wh_lte_7s4->myuart, SEL_232_485_GPIO_Port, SEL_232_485_Pin );
-    Myuart_Set_DE485_GPIO_Pin( wh_lte_7s4->myuart, DE_485_GPIO_Port, DE_485_Pin );
-    Myuart_Set_Dplx_GPIO_Pin( wh_lte_7s4->myuart, DUPLEX_GPIO_Port, DUPLEX_Pin );
-    log_i( "myuart->sel : %d   interface  %d ",wh_lte_7s4->myuart->sel , wh_lte_7s4->myuart->interface_type );
-    Myuart_Set_232( wh_lte_7s4->myuart );
-
-    /* DMA 模式*/
-    Myuart_Setup_Transmod( wh_lte_7s4->myuart, 2);
-
-    /* ppp */
-    wh_lte_7s4_install( wh_lte_7s4);
-
-}
-
-/*  定义要发送的命令，及返回值长度不固定  ?????? */
-void wh_lte_7s4_install_task( )
-{
-    /* Polling 模式*/
-    Myuart_Setup_Transmod( wh_lte_7s4->myuart, 2);
-    wh_lte_7s4->step = 0;
-
-    /* 超时  回退上一步状态
-    ppp             a      
-    a               +ok   
-    workmode        AT+WKMOD=NET\r\n (网络透传模式)   OK\r\n
-    sockasl         AT+SOCKASL=LONG\r\n  SocketA 设置为长连接   OK\r\n
-    sockeaen        AT+SOCKAEN=ON\r\n SocketA 使能      OK\r\n
-    socka           AT+SOCKA=TCP,test.usr.cn,2317 设置 SocketA 的远程 IP 和端口  OK\r\n
-    reboot          AT+Z\r\n 重启模块，参数生效  OK\r\n
-    可选:
-    gettime         AT+CCLK\r\n 
-    apn
-    */
-
-    wh_lte_7s4_ppp( wh_lte_7s4);
-    __wh_lte_7s4_receive( wh_lte_7s4, wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-
-    for ( ; ; )
-    {  
-        /*  ppp  */
-        if ( wh_lte_7s4->step == 0 )
-        {
-            wh_lte_7s4_ppp( wh_lte_7s4);
-            __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-            wh_lte_7s4->timebase = HAL_GetTick();
-            wh_lte_7s4->step++;
-            continue;
-        };
-
-        /*  ppp -> a  */
-        if ( wh_lte_7s4->step == 1 &&   wh_lte_7s4->receive_a_flag == 0 )
-        {
-            /* 未收到a , 是否超时 */
-            if ( (HAL_GetTick() - wh_lte_7s4->timebase) > wh_lte_7s4->timeout)
-            {
-                // wh_lte_7s4_ppp( wh_lte_7s4 ,wh_lte_7s4);
-                // __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-                wh_lte_7s4->step == 0;
-                wh_lte_7s4->timebase = HAL_GetTick();
-            }
-            continue;
-        }
-        if ( wh_lte_7s4->step == 1 &&  wh_lte_7s4->receive_a_flag == 1)
-        {
-            /* 已经接收到a */
-            wh_lte_7s4_a( wh_lte_7s4 );
-            __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-            wh_lte_7s4->receive_a_flag == 0;
-            wh_lte_7s4->step++;
-            continue;
-        }
-
-        /*  +ok -> workmode  */
-        if ( wh_lte_7s4->step == 2 &&  wh_lte_7s4->receive_ok_flag == 0 )
-        {
-            /* 未收到+ok  , 是否超时 */
-            if ( (HAL_GetTick() - wh_lte_7s4->timebase) > wh_lte_7s4->timeout)
-            {
-                /* 超时，从ppp 开始*/
-                // wh_lte_7s4_ppp( wh_lte_7s4 );
-                // __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-                wh_lte_7s4->step == 0;
-                wh_lte_7s4->timebase = HAL_GetTick();
-            }
-            continue;
-        }
-        if ( wh_lte_7s4->step == 2 &&  wh_lte_7s4->receive_ok_flag == 1)
-        {
-            /* 已经接收到+ok */
-            wh_lte_7s4_at_set_workmode(wh_lte_7s4 ,WH_LTE_7S4_CMD_WORK_MODE_NET);
-            __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-            wh_lte_7s4->step++;
-            continue;
-        }
-
-        /*  OK -> Sockasl set long  */
-        if ( wh_lte_7s4->step == 3 &&  wh_lte_7s4->receive_ok_flag == 0 )
-        {
-            /* 未收到OK, 是否超时  */
-            if ( (HAL_GetTick() - wh_lte_7s4->timebase) > wh_lte_7s4->timeout)
-            {
-                // wh_lte_7s4_a( wh_lte_7s4 );
-                wh_lte_7s4_at_set_workmode(wh_lte_7s4 ,WH_LTE_7S4_CMD_WORK_MODE_NET);
-                __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-                wh_lte_7s4->timebase = HAL_GetTick();
-            }
-            continue;
-        }
-        if ( wh_lte_7s4->step == 3 &&  wh_lte_7s4->receive_ok_flag == 1)
-        {
-            /* 已经接收到 OK */
-            wh_lte_7s4_at_set_sockasl( wh_lte_7s4 ,WH_LTE_7S4_CMD_SOCKASL_LONG );
-            __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-            wh_lte_7s4->step++;
-            continue;
-        }
-
-        /*  OK -> SockaEN , socketa enable  */
-        if ( wh_lte_7s4->step == 4 &&  wh_lte_7s4->receive_ok_flag == 0 )
-        {
-            /* 未收到OK, 是否超时  */
-            if ( (HAL_GetTick() - wh_lte_7s4->timebase) > wh_lte_7s4->timeout)
-            {
-                wh_lte_7s4_at_set_workmode(wh_lte_7s4 ,WH_LTE_7S4_CMD_WORK_MODE_NET);
-                __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-                wh_lte_7s4->timebase = HAL_GetTick();
-            }
-            continue;
-        }
-        if ( wh_lte_7s4->step == 4 &&  wh_lte_7s4->receive_ok_flag == 1)
-        {
-            /* 已经接收到 OK */
-            wh_lte_7s4_at_set_socka_en(wh_lte_7s4 ,WH_LTE_7S4_CMD_STATE_ON);
-            __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-            wh_lte_7s4->step++;
-            continue;
-        }
-
-        /*  OK -> Socka ip port , socketa enable  */
-        if ( wh_lte_7s4->step == 5 &&  wh_lte_7s4->receive_ok_flag == 0 )
-        {
-            /* 未收到OK, 是否超时  */
-            if ( (HAL_GetTick() - wh_lte_7s4->timebase) > wh_lte_7s4->timeout)
-            {
-                wh_lte_7s4_at_set_socka_en(wh_lte_7s4 ,WH_LTE_7S4_CMD_STATE_ON);
-                __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-                wh_lte_7s4->timebase = HAL_GetTick();
-            }
-            continue;
-        }
-        if ( wh_lte_7s4->step == 5 &&  wh_lte_7s4->receive_ok_flag == 1)
-        {
-            /* 已经接收到 OK */
-
-            // wh_lte_7s4_at_set_socka(&wh_lte_7s4_buf,WH_LTE_7S4_CMD_PROTOCOL_TCP,buf,len,config.tcp.server_port);
-            __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-            wh_lte_7s4->step++;
-            continue;
-        }
-
-        /*  OK -> other   APN  CCLk .... wh_lte_7s4_at_get_cclk(); */
-        /*  OK -> other   APN  CCLk ....  */
-
-        /*  OK -> Socka reboot z , socketa enable  */
-        if ( wh_lte_7s4->step == 6 &&  wh_lte_7s4->receive_ok_flag == 0 )
-        {
-            /* 未收到OK, 是否超时  */
-            if ( (HAL_GetTick() - wh_lte_7s4->timebase) > wh_lte_7s4->timeout)
-            {
-
-                // wh_lte_7s4_at_set_socka(&wh_lte_7s4_buf,WH_LTE_7S4_CMD_PROTOCOL_TCP,buf,len,config.tcp.server_port);
-                __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-                wh_lte_7s4->timebase = HAL_GetTick();
-            }
-            continue;
-        }
-        if ( wh_lte_7s4->step == 6 &&  wh_lte_7s4->receive_ok_flag == 1)
-        {
-            /* 已经接收到 OK */
-            wh_lte_7s4_at_z(wh_lte_7s4);
-            __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-            wh_lte_7s4->step++;
-            continue;
-        }
-
-        /*  OK -> Socka reboot z , socketa enable  */
-        if ( wh_lte_7s4->step == 6 &&  wh_lte_7s4->receive_ok_flag == 0 )
-        {
-            /* 未收到OK, 是否超时  */
-            if ( (HAL_GetTick() - wh_lte_7s4->timebase) > wh_lte_7s4->timeout)
-            {
-                wh_lte_7s4_at_z(wh_lte_7s4);
-                __wh_lte_7s4_receive( wh_lte_7s4 ,wh_lte_7s4->receive_buf, sizeof(wh_lte_7s4->receive_buf) ) ;
-                wh_lte_7s4->timebase = HAL_GetTick();
-            }
-            continue;
-        }
-        if ( wh_lte_7s4->step == 7 &&  wh_lte_7s4->receive_ok_flag == 1)
-        {
-            /* 已经接收到 OK */
-            wh_lte_7s4->step++;
-            break;
-        }
-
-        /*  OK -> error  */
-        if ( wh_lte_7s4->receive_err_code == 1 )
-        {
-            wh_lte_7s4->step = 0;
-            wh_lte_7s4->receive_ok_flag = 0;
-            break;
-        }
-        osDelay(20);
-    }
-}
-
-/*   发送字节数 >0  发送 */
-void wh_lte_7s4_task( )
-{
-    Myuart_Setup_Transmod( wh_lte_7s4->myuart, 2 );   /* 2  DMA */
-    for ( ; ; )
-    {  
-        osDelay(2000);
-    }
-}
-
-const static char *wh_lte_7s4_cmd_state_table[]={"OFF","ON"};
-const static char *wh_lte_7s4_cmd_work_mode_table[]={"NET","HTTPD","UDC"};
-const static char *wh_lte_7s4_cmd_uart_parity_table[]={"NONE","ODD","EVEN"};
-const static char *wh_lte_7s4_cmd_sockasl_table[]={"SHORT","LONG"};
-const static char *wh_lte_7s4_cmd_protocol_table[]={"TCP","UDP"};
-
-WH_LTE_7S4_Typedef *wh_lte_7s4_init( )
-{
-    WH_LTE_7S4_Typedef *Handle = (WH_LTE_7S4_Typedef *)malloc(sizeof(WH_LTE_7S4_Typedef));
-    if (Handle == NULL)
-    {
-        return NULL;
-    }
-    Handle->receive_a_flag=0;
-    Handle->receive_err_code=0;
-    Handle->receive_ok_flag=0;
-    Handle->receive_para_num=0;
-    return Handle;
-}
-
-int __wh_lte_7s4_send(WH_LTE_7S4_Typedef *wh_lte_7s4, uint8_t *buf, uint16_t size)
-{
-    return Myuart_Send( wh_lte_7s4->myuart, buf, size);
-    // return 0;
-}
-
-int __wh_lte_7s4_receive(WH_LTE_7S4_Typedef *wh_lte_7s4, uint8_t *buf, uint16_t size)
-{
-    return Myuart_Start_Rcv( wh_lte_7s4->myuart, buf, size);
-    // return 0;
-}
-
-void  wh_lte_7s4_receive_callback( WH_LTE_7S4_Typedef *wh_lte_7s4 )
-{
-    /*接收回调 判断 a */
-    if( wh_lte_7s4->receive_buf[0] == 'a' )
-    {
-        wh_lte_7s4->receive_a_flag = 1;
-    }
-    if( wh_lte_7s4->receive_buf[0] == '+' )
-    {
-        if( wh_lte_7s4->receive_buf[1] == 'o' &&   wh_lte_7s4->receive_buf[2] == 'k' )
-            wh_lte_7s4->receive_ok_flag = 1;
-    }
-    if( wh_lte_7s4->receive_buf[0] == 'O' )
-    {
-        if( wh_lte_7s4->receive_buf[1] == 'K' )
-            wh_lte_7s4->receive_ok_flag = 1;
-    }
-    // return Myuart_Start_Rcv( wh_lte_7s4->myuart, buf, size);
-    // return 0;
-}
-
-void  wh_lte_7s4_receive_error_callback(WH_LTE_7S4_Typedef *wh_lte_7s4 )
-{
-    /*接收发生错误回调*/
-    wh_lte_7s4->receive_err_code = 1;
-}
-
-int wh_lte_7s4_ppp(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    __wh_lte_7s4_send(wh_lte_7s4,"+++",3);
-    return 0;
-}
-int wh_lte_7s4_a(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    __wh_lte_7s4_send(wh_lte_7s4,"a",1);
-    return 0;
-}
-int wh_lte_7s4_at(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    __wh_lte_7s4_send(wh_lte_7s4,"AT\r",3);
-    return 0;
-}
-int wh_lte_7s4_test(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size)
-{
-    __wh_lte_7s4_send(wh_lte_7s4,"AT+",3);
-    __wh_lte_7s4_send(wh_lte_7s4,cmd,size);
-    __wh_lte_7s4_send(wh_lte_7s4,"?\r\n",3);
-    return 0;
-}
-int wh_lte_7s4_inquire(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size)
-{
-    __wh_lte_7s4_send(wh_lte_7s4,"AT+",3);
-    __wh_lte_7s4_send(wh_lte_7s4,cmd,size);
-    __wh_lte_7s4_send(wh_lte_7s4,"=?\r\n",4);
-    return 0;
-}
-int wh_lte_7s4_run(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t size)
-{
-    __wh_lte_7s4_send(wh_lte_7s4,"AT+",3);
-    __wh_lte_7s4_send(wh_lte_7s4,cmd,size);
-    __wh_lte_7s4_send(wh_lte_7s4,"\r\n",2);
-    return 0;
-}
-int wh_lte_7s4_set(WH_LTE_7S4_Typedef *wh_lte_7s4,char *cmd,uint32_t cmd_size,char *args,uint32_t args_size)
-{
-    __wh_lte_7s4_send(wh_lte_7s4,"AT+",3);
-    __wh_lte_7s4_send(wh_lte_7s4,cmd,cmd_size);
-    __wh_lte_7s4_send(wh_lte_7s4,"=",1);
-    __wh_lte_7s4_send(wh_lte_7s4,args,args_size);
-    __wh_lte_7s4_send(wh_lte_7s4,"\r\n",2);
-    return 0;
-}
-int wh_lte_7s4_at_help(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"H",1);
-}
-int wh_lte_7s4_at_z(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"Z",1);
-}
-int wh_lte_7s4_at_reboot(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"REBOOT",6);
-}
-int wh_lte_7s4_at_get_echo(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_test(wh_lte_7s4,"E",1);
-}
-int wh_lte_7s4_at_set_echo(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state echo_state)
-{
-    return wh_lte_7s4_set(wh_lte_7s4,"E",1,(char*)wh_lte_7s4_cmd_state_table[echo_state],strlen(wh_lte_7s4_cmd_state_table[echo_state]));
-}
-int wh_lte_7s4_at_entm(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_test(wh_lte_7s4,"ENTM",4);
-}
-int wh_lte_7s4_at_set_workmode(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_work_mode work_mode)
-{
-    return wh_lte_7s4_set(wh_lte_7s4,"WKMOD",5,(char*)wh_lte_7s4_cmd_work_mode_table[work_mode],strlen(wh_lte_7s4_cmd_work_mode_table[work_mode]));
-}
-int wh_lte_7s4_at_get_workmode(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_test(wh_lte_7s4,"WKMOD",5);
-}
-int wh_lte_7s4_at_get_csq(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"CSQ",3);
-}
-int wh_lte_7s4_at_get_system_info(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SYSINFO",7);
-}
-int wh_lte_7s4_at_reload(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"RELD",4);
-}
-int wh_lte_7s4_at_clear(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"CLEAR",5);
-}
-int wh_lte_7s4_at_get_sn(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SN",2);
-}
-int wh_lte_7s4_at_get_iccid(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"ICCID",5);
-}
-int wh_lte_7s4_at_get_imei(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"IMEI",4);
-}
-int wh_lte_7s4_at_get_local_ip(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"LOCIP",5);
-}
-int wh_lte_7s4_at_get_uart(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"UART",4);
-}
-int wh_lte_7s4_at_set_uart(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t baud,uint8_t data,uint8_t stop,enum wh_lte_7s4_cmd_uart_parity parity)
-{
-    int i=0;
-    i+=convert_u_2_s(baud,&wh_lte_7s4->send_args_buf[i],64-i);
-    wh_lte_7s4->send_args_buf[i++]=',';
-    i+=convert_u_2_s(data,&wh_lte_7s4->send_args_buf[i],64-i);
-    wh_lte_7s4->send_args_buf[i++]=',';
-    i+=convert_u_2_s(stop,&wh_lte_7s4->send_args_buf[i],64-i);
-    wh_lte_7s4->send_args_buf[i++]=',';
-    strcpy(&wh_lte_7s4->send_args_buf[i],wh_lte_7s4_cmd_uart_parity_table[parity]);
-    i+=strlen(wh_lte_7s4_cmd_uart_parity_table[parity]);
-    wh_lte_7s4->send_args_buf[i++]=',';
-    strcpy(&wh_lte_7s4->send_args_buf[i],"NFC");
-    i+=3;
-    return wh_lte_7s4_set(wh_lte_7s4,"UART",4,wh_lte_7s4->send_args_buf,i);
-}
-int wh_lte_7s4_at_get_uartft(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"UARTFT",6);
-}
-int wh_lte_7s4_at_set_uartft(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t ft)
-{
-    int i=0;
-    i+=convert_u_2_s(ft,&wh_lte_7s4->send_args_buf[i],64-i);
-    return wh_lte_7s4_set(wh_lte_7s4,"UARTFT",6,wh_lte_7s4->send_args_buf,i);
-}
-int wh_lte_7s4_at_get_uartfl(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"UARTFL",6);
-}
-int wh_lte_7s4_at_set_uartfl(WH_LTE_7S4_Typedef *wh_lte_7s4,uint32_t len)
-{
-    int i=0;
-    i+=convert_u_2_s(len,&wh_lte_7s4->send_args_buf[i],64-i);
-    return wh_lte_7s4_set(wh_lte_7s4,"UARTFL",6,wh_lte_7s4->send_args_buf,i);
-}
-int wh_lte_7s4_at_get_socka(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SOCKA",5);
-}
-/**
- * @brief 
- * 
- * @param wh_lte_7s4 
- * @param protocol 
- * @param remote_ip  char * 
- * @param remote_ip_size 
- * @param port 
- * @return int 
- */
-int wh_lte_7s4_at_set_socka(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port)
-{
-    int i=0;
-    memcpy(&wh_lte_7s4->send_args_buf[i],wh_lte_7s4_cmd_protocol_table[protocol],3);
-    i+=3;
-    wh_lte_7s4->send_args_buf[i++]=',';
-    memcpy(&wh_lte_7s4->send_args_buf[i],remote_ip,remote_ip_size);
-    i+=remote_ip_size;
-    wh_lte_7s4->send_args_buf[i++]=',';
-    i+=convert_u_2_s(port,&wh_lte_7s4->send_args_buf[i],64-i);
-    return wh_lte_7s4_set(wh_lte_7s4,"SOCKA",5,wh_lte_7s4->send_args_buf,i);
-}
-int wh_lte_7s4_at_get_sockb(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SOCKB",5);
-}
-/**
- * @brief 
- * 
- * @param wh_lte_7s4 
- * @param protocol 
- * @param remote_ip 
- * @param remote_ip_size 
- * @param port 
- * @return int 
- */
-int wh_lte_7s4_at_set_sockb(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port)
-{
-    int i=0;
-    memcpy(&wh_lte_7s4->send_args_buf[i],wh_lte_7s4_cmd_protocol_table[protocol],3);
-    i+=3;
-    wh_lte_7s4->send_args_buf[i++]=',';
-    memcpy(&wh_lte_7s4->send_args_buf[i],remote_ip,remote_ip_size);
-    i+=remote_ip_size;
-    wh_lte_7s4->send_args_buf[i++]=',';
-    i+=convert_u_2_s(port,&wh_lte_7s4->send_args_buf[i],64-i);
-    return wh_lte_7s4_set(wh_lte_7s4,"SOCKB",5,wh_lte_7s4->send_args_buf,i);
-}
-int wh_lte_7s4_at_get_socka_en(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SOCKAEN",7);
-}
-int wh_lte_7s4_at_set_socka_en(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state)
-{
-    return wh_lte_7s4_set(wh_lte_7s4,"SOCKAEN",7,(char*)wh_lte_7s4_cmd_state_table[state],strlen(wh_lte_7s4_cmd_state_table[state]));
-}
-int wh_lte_7s4_at_get_sockb_en(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SOCKBEN",7);
-}
-int wh_lte_7s4_at_set_sockb_en(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state)
-{
-    return wh_lte_7s4_set(wh_lte_7s4,"SOCKBEN",7,(char*)wh_lte_7s4_cmd_state_table[state],strlen(wh_lte_7s4_cmd_state_table[state]));
-}
-int wh_lte_7s4_at_get_sockasl(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SOCKASL",7);
-}
-int wh_lte_7s4_at_set_sockasl(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type)
-{
-    return wh_lte_7s4_set(wh_lte_7s4,"SOCKASL",7,(char*)wh_lte_7s4_cmd_sockasl_table[type],strlen(wh_lte_7s4_cmd_sockasl_table[type]));
-}
-int wh_lte_7s4_at_get_sockbsl(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SOCKBSL",7);
-}
-int wh_lte_7s4_at_set_sockbsl(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type)
-{
-    return wh_lte_7s4_set(wh_lte_7s4,"SOCKBSL",7,(char*)wh_lte_7s4_cmd_sockasl_table[type],strlen(wh_lte_7s4_cmd_sockasl_table[type]));
-}
-int wh_lte_7s4_at_get_sockalk(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SOCKALK",7);
-}
-int wh_lte_7s4_at_get_sockblk(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SOCKBLK",7);
-}
-int wh_lte_7s4_at_get_sdpen(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"SDPEN",5);
-}
-int wh_lte_7s4_at_set_sdpen(WH_LTE_7S4_Typedef *wh_lte_7s4,enum wh_lte_7s4_cmd_state new_state)
-{
-    return wh_lte_7s4_set(wh_lte_7s4,"SDPEN",5,(char*)wh_lte_7s4_cmd_state_table[new_state],strlen(wh_lte_7s4_cmd_state_table[new_state]));
-}
-int wh_lte_7s4_at_get_cclk(WH_LTE_7S4_Typedef *wh_lte_7s4)
-{
-    return wh_lte_7s4_run(wh_lte_7s4,"CCLK",4);
-}
-void wh_lte_7s4_receive_unpack(WH_LTE_7S4_Typedef *wh_lte_7s4, char *buf, uint32_t size)
-{
-    int state;
-    int i=0;
-    int j=0;
-    while(i<size){
-        state=0;
-        uint32_t size_tmp=size+wh_lte_7s4->receive_size>1024?1024-wh_lte_7s4->receive_size:size;
-        memcpy(&wh_lte_7s4->receive_buf[wh_lte_7s4->receive_size],buf,size_tmp);
-        wh_lte_7s4->receive_size+=size_tmp;
-        while(i<size){
-            switch(state){
-            case 0:
-                if(buf[i]=='a'){
-                    wh_lte_7s4->receive_a_flag=1;
-                    state=0;
-                    i++;
-                    continue;
-                }
-                if(buf[i]=='\r'){
-                    state=1;
-                    break;
-                }
-                if(buf[i]=='+'){
-                    state=9;
-                    break;
-                }
-                if(buf[i]=='A'){
-                    state=11;
-                    break;
-                }
-                break;
-            case 1:
-                if(buf[i]=='\n'){
-                    state=2;
-                    break;
-                }
-                i--;
-                state=0;
-                break;
-            case 2:
-                if(buf[i]=='O'){
-                    state=3;
-                    break;
-                }
-                if(buf[i]=='+'){
-                    state=6;
-                    break;
-                }
-                i--;
-                state=0;
-                break;
-            case 3:
-                if(buf[i]=='K'){
-                    state=4;
-                    break;
-                }
-                i--;
-                state=0;
-                break;
-            case 4:
-                if(buf[i]=='\r'){
-                    state=5;
-                    break;
-                }
-                i--;
-                state=0;
-                break;
-            case 5:
-                if(buf[i]=='\n'){
-                    wh_lte_7s4->receive_ok_flag=1;
-                    state=0;
-                    i++;
-                    continue;
-                }
-                i--;
-                state=0;
-                break;
-            case 6:
-                if(buf[i]==':'){
-                    state=7;
-                    break;
-                }
-                break;
-            case 7:
-                if(buf[i]==','){
-                    j=0;
-                    wh_lte_7s4->receive_para[wh_lte_7s4->receive_para_num][j++]='\0';
-                    wh_lte_7s4->receive_para_num++;
-                    break;
-                }
-                if(buf[i]=='\r')
-                {
-                    wh_lte_7s4->receive_para_num++;
-                    state=8;
-                    break;
-                }
-                if(j>=32 || wh_lte_7s4->receive_para_num>=8){
-                    wh_lte_7s4->receive_para_num=0;
-                    state=0;
-                    break;
-                }
-                wh_lte_7s4->receive_para[wh_lte_7s4->receive_para_num][j++]=buf[i];
-                break;
-            case 8:
-                if(buf[i]=='\n')
-                {
-                    state=0;
-                    break;
-                }
-                wh_lte_7s4->receive_para_num=0;
-                break;
-            case 9:
-                if(buf[i]=='o'){
-                    state=10;
-                    break;
-                }
-                i--;
-                state=0;
-                break;
-            case 10:
-                if(buf[i]=='k'){
-                    wh_lte_7s4->receive_ok_flag=1;
-                    state=0;
-                    i++;
-                    continue;
-                }
-                i--;
-                state=0;
-                break;
-            case 11:
-                if(buf[i]=='T'){
-                    state=2;
-                    break;
-                }
-                i--;
-                state=0;
-                break;
-            }
-            i++;
-        }
-    }
-    
-}
-
-/**
- * @brief 将unsigned数据转换为字符串
- * 
- * @param integer 要转换的数据
- * @param str 字符串指针
- * @param length 字符串长度
- * @return unsigned 转换的字符串长度
- */
-unsigned convert_u_2_s(unsigned integer,char *str,unsigned length)
-{
-    unsigned i;
-    unsigned j=length-1;
-    while(j<length){
-        str[j]=integer%10+'0';
-        integer/=10;
-        if(integer==0)
-            break;
-        j--;
-    }
-    if(integer!=0)
-        return 0;
-    for(i=0;j<length;i++,j++){
-        str[i]=str[j];
-    }
-    return i;
-}

device/Src/wh_lte_utils.c

@@ -0,0 +1,301 @@
+#include "wh_lte_7s4_v2.h"
+#include "wh_lte_7s4_v2.h"
+
+const static char *wh_lte_7s4_cmd_state_table[]={"OFF","ON"};
+const static char *wh_lte_7s4_cmd_work_mode_table[]={"NET","HTTPD","UDC"};
+const static char *wh_lte_7s4_cmd_uart_parity_table[]={"NONE","ODD","EVEN"};
+const static char *wh_lte_7s4_cmd_sockasl_table[]={"SHORT","LONG"};
+const static char *wh_lte_7s4_cmd_protocol_table[]={"TCP","UDP"};
+const static char *wh_lte_7s4_procedure_table[]={
+    "+++",  "a",    "WKMOD",    "SOCKASL", "SOCKAEN",   "SOCKA","CCLK", "Z" };
+const static char *wh_lte_7s4_procedure_rcv_table[]={
+    "a",  "+ok",  "OK",       "OK",       "OK",       "OK",   "+CCLK:", "OK" };
+
+extern int WH_LTE_Send( WH_LTE_TypeDef * wh_lte_7s4,  uint8_t * buf, uint16_t size );
+extern int wh_lte_7s4_ppp(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_a(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_test(WH_LTE_TypeDef *wh_lte_7s4,char *cmd,uint32_t size);
+extern int wh_lte_7s4_inquire(WH_LTE_TypeDef *wh_lte_7s4,char *cmd,uint32_t size);
+extern int wh_lte_7s4_run(WH_LTE_TypeDef *wh_lte_7s4,char *cmd,uint32_t size);
+extern int wh_lte_7s4_set(WH_LTE_TypeDef *wh_lte_7s4,char *cmd,uint32_t cmd_size,char *args,uint32_t args_size);
+extern int wh_lte_7s4_at_help(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_z(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_reboot(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_echo(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_echo(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_state echo_state);
+extern int wh_lte_7s4_at_entm(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_workmode(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_work_mode work_mode);
+extern int wh_lte_7s4_at_get_workmode(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_csq(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_system_info(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_reload(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_clear(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_sn(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_iccid(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_imei(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_local_ip(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_uart(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_uart(WH_LTE_TypeDef *wh_lte_7s4,uint32_t buad,uint8_t data,uint8_t stop,enum wh_lte_7s4_cmd_uart_parity parity);
+extern int wh_lte_7s4_at_get_uartft(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_uartft(WH_LTE_TypeDef *wh_lte_7s4,uint32_t ft);
+extern int wh_lte_7s4_at_get_uartfl(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_uartfl(WH_LTE_TypeDef *wh_lte_7s4,uint32_t len);
+extern int wh_lte_7s4_at_get_socka(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_socka(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port);
+extern int wh_lte_7s4_at_get_sockb(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_sockb(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port);
+extern int wh_lte_7s4_at_get_socka_en(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_socka_en(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state);
+extern int wh_lte_7s4_at_get_sockb_en(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_sockb_en(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state);
+extern int wh_lte_7s4_at_get_sockasl(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_sockasl(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type);
+extern int wh_lte_7s4_at_get_sockbsl(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_sockbsl(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type);
+extern int wh_lte_7s4_at_get_sockalk(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_sockblk(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_get_sdpen(WH_LTE_TypeDef *wh_lte_7s4);
+extern int wh_lte_7s4_at_set_sdpen(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_state new_state);
+extern int wh_lte_7s4_at_get_cclk(WH_LTE_TypeDef *wh_lte_7s4);
+
+int WH_LTE_Send( WH_LTE_TypeDef * wh_lte_7s4,  uint8_t * buf, uint16_t size )
+{
+    return UART_HELPER_Trans(WH_LTE_uart_helper, buf, size);
+}
+
+int wh_lte_7s4_ppp(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    // WH_LTE_Send( wh_lte_7s4,"+++",3);
+    WH_LTE_Send( wh_lte_7s4, (uint8_t*)"+++",3);
+    return 0;
+}
+int wh_lte_7s4_a(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"a",1);
+    return 0;
+}
+int wh_lte_7s4_at(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"AT\r",3);
+    return 0;
+}
+int wh_lte_7s4_test(WH_LTE_TypeDef *wh_lte_7s4,char *cmd,uint32_t size)
+{
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"AT+",3);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)cmd,size);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"?\r\n",3);
+    return 0;
+}
+int wh_lte_7s4_inquire(WH_LTE_TypeDef *wh_lte_7s4,char *cmd,uint32_t size)
+{
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"AT+",3);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)cmd,size);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"=?\r\n",4);
+    return 0;
+}
+int wh_lte_7s4_run(WH_LTE_TypeDef *wh_lte_7s4,char *cmd,uint32_t size)
+{
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"AT+",3);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)cmd,size);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"\r\n",2);
+    return 0;
+}
+int wh_lte_7s4_set(WH_LTE_TypeDef *wh_lte_7s4,char *cmd,uint32_t cmd_size,char *args,uint32_t args_size)
+{
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"AT+",3);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)cmd, cmd_size);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"=",1);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)args,args_size);
+    WH_LTE_Send( wh_lte_7s4,(uint8_t*)"\r\n",2);
+    return 0;
+}
+
+int wh_lte_7s4_at_help(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"H",1);
+}
+int wh_lte_7s4_at_z(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"Z",1);
+}
+int wh_lte_7s4_at_reboot(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"REBOOT",6);
+}
+int wh_lte_7s4_at_get_echo(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_test(wh_lte_7s4,"E",1);
+}
+int wh_lte_7s4_at_set_echo(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_state echo_state)
+{
+    return wh_lte_7s4_set(wh_lte_7s4,"E",1,(char*)wh_lte_7s4_cmd_state_table[echo_state],strlen(wh_lte_7s4_cmd_state_table[echo_state]));
+}
+int wh_lte_7s4_at_entm(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_test(wh_lte_7s4,"ENTM",4);
+}
+int wh_lte_7s4_at_set_workmode(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_work_mode work_mode)
+{
+    return wh_lte_7s4_set(wh_lte_7s4,"WKMOD",5,(char*)wh_lte_7s4_cmd_work_mode_table[work_mode],strlen(wh_lte_7s4_cmd_work_mode_table[work_mode]));
+}
+int wh_lte_7s4_at_get_workmode(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_test(wh_lte_7s4,"WKMOD",5);
+}
+int wh_lte_7s4_at_get_csq(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"CSQ",3);
+}
+int wh_lte_7s4_at_get_system_info(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SYSINFO",7);
+}
+int wh_lte_7s4_at_reload(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"RELD",4);
+}
+int wh_lte_7s4_at_clear(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"CLEAR",5);
+}
+int wh_lte_7s4_at_get_sn(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SN",2);
+}
+int wh_lte_7s4_at_get_iccid(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"ICCID",5);
+}
+int wh_lte_7s4_at_get_imei(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"IMEI",4);
+}
+int wh_lte_7s4_at_get_local_ip(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"LOCIP",5);
+}
+int wh_lte_7s4_at_get_uart(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"UART",4);
+}
+int wh_lte_7s4_at_set_uart(WH_LTE_TypeDef *wh_lte_7s4,uint32_t buad,uint8_t data,uint8_t stop,enum wh_lte_7s4_cmd_uart_parity parity)
+{
+    int i=0;
+    i+=convert_u2s(buad,&wh_lte_7s4->send_args_buf[i],64-i);
+    wh_lte_7s4->send_args_buf[i++]=',';
+    i+=convert_u2s(data,&wh_lte_7s4->send_args_buf[i],64-i);
+    wh_lte_7s4->send_args_buf[i++]=',';
+    i+=convert_u2s(stop,&wh_lte_7s4->send_args_buf[i],64-i);
+    wh_lte_7s4->send_args_buf[i++]=',';
+    strcpy(&wh_lte_7s4->send_args_buf[i],wh_lte_7s4_cmd_uart_parity_table[parity]);
+    i+=strlen(wh_lte_7s4_cmd_uart_parity_table[parity]);
+    wh_lte_7s4->send_args_buf[i++]=',';
+    strcpy(&wh_lte_7s4->send_args_buf[i],"NFC");
+    i+=3;
+    return wh_lte_7s4_set(wh_lte_7s4,"UART",4,wh_lte_7s4->send_args_buf,i);
+}
+int wh_lte_7s4_at_get_uartft(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"UARTFT",6);
+}
+int wh_lte_7s4_at_set_uartft(WH_LTE_TypeDef *wh_lte_7s4,uint32_t ft)
+{
+    int i=0;
+    i+=convert_u2s(ft,&wh_lte_7s4->send_args_buf[i],64-i);
+    return wh_lte_7s4_set(wh_lte_7s4,"UARTFT",6,wh_lte_7s4->send_args_buf,i);
+}
+int wh_lte_7s4_at_get_uartfl(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"UARTFL",6);
+}
+int wh_lte_7s4_at_set_uartfl(WH_LTE_TypeDef *wh_lte_7s4,uint32_t len)
+{
+    int i=0;
+    i+=convert_u2s(len,&wh_lte_7s4->send_args_buf[i],64-i);
+    return wh_lte_7s4_set(wh_lte_7s4,"UARTFL",6,wh_lte_7s4->send_args_buf,i);
+}
+int wh_lte_7s4_at_get_socka(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SOCKA",5);
+}
+int wh_lte_7s4_at_set_socka(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port)
+{
+    int i=0;
+    memcpy(&wh_lte_7s4->send_args_buf[i],wh_lte_7s4_cmd_protocol_table[protocol],3);
+    i+=3;
+    wh_lte_7s4->send_args_buf[i++]=',';
+    memcpy(&wh_lte_7s4->send_args_buf[i],remote_ip,remote_ip_size);
+    i+=remote_ip_size;
+    wh_lte_7s4->send_args_buf[i++]=',';
+    i+=wh_lte_convert_u2s(port,&wh_lte_7s4->send_args_buf[i],64-i);
+    return wh_lte_7s4_set(wh_lte_7s4,"SOCKA",5,wh_lte_7s4->send_args_buf,i);
+}
+int wh_lte_7s4_at_get_sockb(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SOCKB",5);
+}
+int wh_lte_7s4_at_set_sockb(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_protocol protocol,char *remote_ip,uint32_t remote_ip_size,uint16_t port)
+{
+    int i=0;
+    memcpy(&wh_lte_7s4->send_args_buf[i],wh_lte_7s4_cmd_protocol_table[protocol],3);
+    i+=3;
+    wh_lte_7s4->send_args_buf[i++]=',';
+    memcpy(&wh_lte_7s4->send_args_buf[i],remote_ip,remote_ip_size);
+    i+=remote_ip_size;
+    wh_lte_7s4->send_args_buf[i++]=',';
+    i+=wh_lte_convert_u2s(port,&wh_lte_7s4->send_args_buf[i],64-i);
+    return wh_lte_7s4_set(wh_lte_7s4,"SOCKB",5,wh_lte_7s4->send_args_buf,i);
+}
+int wh_lte_7s4_at_get_socka_en(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SOCKAEN",7);
+}
+int wh_lte_7s4_at_set_socka_en(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state)
+{
+    return wh_lte_7s4_set(wh_lte_7s4,"SOCKAEN",7,(char*)wh_lte_7s4_cmd_state_table[state],strlen(wh_lte_7s4_cmd_state_table[state]));
+}
+int wh_lte_7s4_at_get_sockb_en(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SOCKBEN",7);
+}
+int wh_lte_7s4_at_set_sockb_en(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_state state)
+{
+    return wh_lte_7s4_set(wh_lte_7s4,"SOCKBEN",7,(char*)wh_lte_7s4_cmd_state_table[state],strlen(wh_lte_7s4_cmd_state_table[state]));
+}
+int wh_lte_7s4_at_get_sockasl(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SOCKASL",7);
+}
+int wh_lte_7s4_at_set_sockasl(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type)
+{
+    return wh_lte_7s4_set(wh_lte_7s4,"SOCKASL",7,(char*)wh_lte_7s4_cmd_sockasl_table[type],strlen(wh_lte_7s4_cmd_sockasl_table[type]));
+}
+int wh_lte_7s4_at_get_sockbsl(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SOCKBSL",7);
+}
+int wh_lte_7s4_at_set_sockbsl(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_sockasl type)
+{
+    return wh_lte_7s4_set(wh_lte_7s4,"SOCKBSL",7,(char*)wh_lte_7s4_cmd_sockasl_table[type],strlen(wh_lte_7s4_cmd_sockasl_table[type]));
+}
+int wh_lte_7s4_at_get_sockalk(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SOCKALK",7);
+}
+int wh_lte_7s4_at_get_sockblk(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SOCKBLK",7);
+}
+int wh_lte_7s4_at_get_sdpen(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"SDPEN",5);
+}
+int wh_lte_7s4_at_set_sdpen(WH_LTE_TypeDef *wh_lte_7s4,enum wh_lte_7s4_cmd_state new_state)
+{
+    return wh_lte_7s4_set(wh_lte_7s4,"SDPEN",5,(char*)wh_lte_7s4_cmd_state_table[new_state],strlen(wh_lte_7s4_cmd_state_table[new_state]));
+}
+int wh_lte_7s4_at_get_cclk(WH_LTE_TypeDef *wh_lte_7s4)
+{
+    return wh_lte_7s4_run(wh_lte_7s4,"CCLK",4);
+}

device/Src/wk2xxx.c

@@ -1,870 +0,0 @@
-/*
- * wk2xxx.c
- */
-
-#include "wk2xxx.h"
-
-// #define WK2124 
-#define WK2114 
-
-///                            移植修改区域
-
-#define WK2124_RST1_GPIO_Port 	GPIOA
-#define WK2124_RST1_Pin 		GPIO_PIN_15
-#define WK2124_CS1_GPIO_Port 	GPIOA
-#define WK2124_CS1_Pin 			GPIO_PIN_15
-// 拉低RST引脚
-#define WK_GPIO_RST_L()    HAL_GPIO_WritePin( WK2124_RST1_GPIO_Port, WK2124_RST1_Pin, GPIO_PIN_RESET )
-// 拉高RST引脚
-#define WK_GPIO_RST_H()    HAL_GPIO_WritePin( WK2124_RST1_GPIO_Port, WK2124_RST1_Pin, GPIO_PIN_SET )
-
-#ifdef WK2124
-#include "spi.h"
-#define WK_SPI_Handle ( &hspi2 )
-#endif 
- 
-#ifdef WK2114
-#include "usart.h"
-#define WK_Uart_Handle ( &huart2 )
-#endif 
- 
-// 片选引脚 拉低 拉高
-#ifdef WK2124 
-#define WK_GPIO_SEL_L()   HAL_GPIO_WritePin( WK2124_CS1_GPIO_Port, WK2124_CS1_Pin, GPIO_PIN_RESET ) 
-#define WK_GPIO_SEL_H()   HAL_GPIO_WritePin( WK2124_CS1_GPIO_Port, WK2124_CS1_Pin, GPIO_PIN_SET ) 
-#endif 
- 
-#ifdef WK2114
-#define WK_GPIO_SEL_L()    
-#define WK_GPIO_SEL_H()    
-#endif
-
-
-static void wk_delay_ms(uint32_t nms)
-{
-    HAL_Delay(nms);
-}
-
-static uint8_t WK_SPI_ReadWriteByte(uint8_t TxData)
-{
-    uint8_t RxData = 0X00;
-#ifdef WK2124
-    if ( HAL_SPI_TransmitReceive(WK_SPI_Handle, &TxData, &RxData, 1, 10) != HAL_OK )
-    {
-        RxData = 0XFF;
-    }
-#endif
-#ifdef WK2114
-	/*  ????  */
-    if ( HAL_Uart_Transmit(WK_Uart_Handle, &TxData, 1, 10) != HAL_OK )
-    {
-        RxData = 0XFF;
-    }
-    if ( HAL_UART_Receive(WK_Uart_Handle, &RxData, 1, 100) != HAL_OK )
-    {
-        RxData = 0XFF;
-    }	
-#endif
-    return RxData;
-}
-
-///                            驱动程序代码
-
-void WK_Port(void)
-{
-	/* Hard Reset */
-	WK_Rst();
-
-	/* uart 需要自适应串口, spi无需此操作*/
-	WK_SPI_ReadWriteByte( 0x55 );
-	
-	// init ports
-	WK_PortInit(1, 11059200, 9600);  // 晶振 = 11.0592MHz ，这个值根据实际进行修改
-	WK_PortInit(2, 11059200, 9600);
-	WK_PortInit(3, 11059200, 9600);
-	WK_PortInit(4, 11059200, 9600);
-
-}
-
-/// 硬件复位（拉低复位引脚最低10毫秒进行复位）
-void WK_Rst(void)
-{
-	WK_GPIO_RST_L( );
-	wk_delay_ms( 50 );
-	WK_GPIO_RST_H( );
-	wk_delay_ms( 50 );
-}
-
-void WK_WriteGReg( uint8_t reg, uint8_t value )
-{
-	WK_GPIO_SEL_L( );
-	WK_SPI_ReadWriteByte( reg );
-	WK_SPI_ReadWriteByte( value );
-	WK_GPIO_SEL_H( );
-}
-
-uint8_t WK_ReadGReg( uint8_t reg )
-{
-	uint8_t value = 0X00;
-	WK_GPIO_SEL_L( );
-	WK_SPI_ReadWriteByte( 0X40 | reg );
-	value = WK_SPI_ReadWriteByte( 0X00 );
-	WK_GPIO_SEL_H( );
-	return value;
-}
-
-void WK_WriteSReg( uint8_t port, uint8_t reg, uint8_t value )
-{
-	WK_GPIO_SEL_L( );
-	WK_SPI_ReadWriteByte( ((port - 1) << 4) | reg );
-	WK_SPI_ReadWriteByte( value );
-	WK_GPIO_SEL_H( );
-}
-
-uint8_t WK_ReadSReg( uint8_t port, uint8_t reg )
-{
-	uint8_t value = 0X00;
-	WK_GPIO_SEL_L( );
-	WK_SPI_ReadWriteByte(0X40 | ((port - 1) << 4) | reg);
-	value = WK_SPI_ReadWriteByte( 0X00 );
-	WK_GPIO_SEL_H( );
-	return value;
-}
-
-void WK_WriteFIFO( uint8_t port, const void* buf, uint16_t len )
-{
-	const uint8_t* p = (const uint8_t *)buf;
-	WK_GPIO_SEL_L( );
-	WK_SPI_ReadWriteByte(0X80 | ((port - 1) << 4));
-	while (len--)
-	{
-		WK_SPI_ReadWriteByte(*p++);
-	}
-	WK_GPIO_SEL_H( );
-}
-
-void WK_ReadFIFO( uint8_t port, void* buf, uint16_t len )
-{
-	uint8_t* p = (uint8_t *)buf;
-	WK_GPIO_SEL_L( );
-	WK_SPI_ReadWriteByte(0XC0 | ((port - 1) << 4));
-	while (len--)
-	{
-		*p++ = WK_SPI_ReadWriteByte(0X00);
-	}
-	WK_GPIO_SEL_H( );
-}
-
-void WK_PortCalcBaudrate( uint32_t fosc, uint32_t baudrate, uint8_t* BAUD0, uint8_t* BAUD1, uint8_t* PRES )
-{
-	float value = (float)fosc / (float)(baudrate << 4);
-	*BAUD0 = (((uint32_t)value) - 1) & 0XFF;
-	*BAUD1 = ((((uint32_t)value) - 1) >> 8) & 0XFF;
-	*PRES  = ((uint32_t)(value * 10)) % 10;
-}
-
-uint16_t WK_PortSendData( uint8_t port, const void* buf, uint16_t len )
-{
-	uint8_t  state = 0;
-	uint16_t nsend = 0;
-	state = WK_ReadSReg( port, WK2XXX_FSR );
-	if (state & WK2XXX_TFULL)                    // 发送FIFO满
-	{
-		nsend = 0;
-	} else
-	{
-		state = WK_ReadSReg( port, WK2XXX_TFCNT ); // 读取发送FIFO已用空间
-		nsend = 256 - state;
-		nsend = nsend >= len ? len : nsend;
-		WK_WriteFIFO(port, buf, nsend);          // 将待发送的数据写入FIFO
-	}
-	return nsend;                                // 返回实际发送成功的数据量
-}
-
-uint16_t WK_PortRecvData( uint8_t port, void* buf, uint16_t len )
-{
-	uint8_t state = 0;
-	uint8_t nread = 0;
-	state = WK_ReadSReg( port, WK2XXX_FSR );
-	if ( state & WK2XXX_RDAT )                      // 接收FIFO非空
-	{
-		nread = WK_ReadSReg( port, WK2XXX_RFCNT );  // 查询FIFO中的数据量 ?恰好256个？
-		if ( nread == 0 )
-		{
-			nread= 256;
-		}else{
-			nread = len >= nread ? nread : len;			
-		}
-		WK_ReadFIFO( port, buf, nread );            // 读取FIFO中的数据
-	}
-	return nread;                                 // 返回实际读取到的数据量
-}
-
-void WK_PortInit( uint8_t port, uint32_t fosc, uint32_t baudrate )
-{
-	uint8_t BAUD0 = 0, BAUD1 = 0, PRES = 0, value = 0, ret = 0;
-
-	/* 使能子串口时钟 */ 
-	value = WK_ReadGReg( WK2XXX_GENA );
-	value |= (1 << (port - 1));
-	WK_WriteGReg( WK2XXX_GENA, value );
-	ret = WK_ReadGReg( WK2XXX_GENA );
-
-	/* 软件复位子串口 */ 
-	value = WK_ReadGReg( WK2XXX_GRST );
-	value |= (1 << (port - 1));
-	WK_WriteGReg( WK2XXX_GRST, value );
-	ret = WK_ReadGReg( WK2XXX_GRST );
-
-	/*  使能子串口总中断 */ 
-	value = WK_ReadGReg( WK2XXX_GIER );
-	value |= (1 << (port - 1));
-	WK_WriteGReg( WK2XXX_GIER, value );
-	ret = WK_ReadGReg( WK2XXX_GIER );
-
-	/* 使能子串口FIFO相关中断 */ 
-	value = WK_ReadSReg( port, WK2XXX_SIER );
-	value |= WK2XXX_RFTRIG_IEN;                  // 接收FIFO触点中断
-//	value |= WK2XXX_TFTRIG_IEN;                  // 发送FIFO触点中断
-//	value |= WK2XXX_RXOUT_IEN;                   // 接收FIFO超时中断
-	WK_WriteSReg( port, WK2XXX_SIER, value );
-	ret = WK_ReadSReg( port, WK2XXX_SIER );
-
-	/* 设置FCR寄存器 */ 
-	value = 0;
-	value |= (1 << 0);  // 复位接收FIFO
-	value |= (1 << 1);  // 复位发送FIFO
-	value |= (1 << 2);  // 使能接收FIFO(这一步必须)
-	value |= (1 << 3);  // 使能发送FIFO(这一步必须)
-	value |= (0 << 4);  // 设置接收FIFO触点固定为8字节
-	value |= (0 << 6);  // 设置发送FIFO触点固定为8字节
-	WK_WriteSReg( port, WK2XXX_FCR, value );
-	ret = WK_ReadSReg( port, WK2XXX_FCR );
-
-	/* 切换到 page1 设置中断触点和波特率 */ 
-	WK_WriteSReg( port, WK2XXX_SPAGE, 1 );
-	ret = WK_ReadSReg( port, WK2XXX_SPAGE );
-
-	WK_WriteSReg( port, WK2XXX_RFTL, 10 );      // 设置接收触点为10个字节
-	ret = WK_ReadSReg( port, WK2XXX_RFTL );
-
-	WK_WriteSReg( port, WK2XXX_TFTL, 10 );      // 设置发送触点为10个字节
-	ret = WK_ReadSReg( port, WK2XXX_TFTL );
-
-	WK_PortCalcBaudrate( fosc, baudrate, &BAUD0, &BAUD1, &PRES );  // 计算波特率
-
-	WK_WriteSReg( port, WK2XXX_BAUD1, BAUD1 );  // 设置BAUD1
-	ret = WK_ReadSReg( port, WK2XXX_BAUD1 );
-
-	WK_WriteSReg( port, WK2XXX_BAUD0, BAUD0 );  // 设置BAUD0
-	ret = WK_ReadSReg( port, WK2XXX_BAUD0 );
-
-	WK_WriteSReg( port, WK2XXX_PRES, PRES );    // 设置PRES
-	ret = WK_ReadSReg( port, WK2XXX_PRES );
-
-	/* 切换回page0 */ 
-	WK_WriteSReg( port, WK2XXX_SPAGE, 0 );
-	ret = WK_ReadSReg( port, WK2XXX_SPAGE );
-
-	/* 使能子串口收发 */ 
-	value = WK_ReadSReg( port, WK2XXX_SCR );
-	value |= WK2XXX_TXEN;
-	value |= WK2XXX_RXEN;
-	WK_WriteSReg( port, WK2XXX_SCR, value );
-	ret = WK_ReadSReg( port, WK2XXX_SCR );
-}
-
-
-// 如果irq引脚接入了单片机的外部中断引脚，将该函数放入外部中断处理函数内。
-// 对于WK2124所开启的中断可以这么处理：
-void WK_IRQHandler( void )
-{
-	int i = 0;
-	uint8_t GIFR = 0, SIFR = 0;
-
-	/* 读取子串口全局中断寄存器  , 返回子串口 
-		GIFR : Global Interupt Flag Register,
-	 */
-	GIFR = WK_ReadGReg( WK2XXX_GIFR );
-
-	// 查询4个子串口是否发生中断
-	for (i = 0; i < 4; i++)
-	{
-		if ((GIFR >> i) & 0X01)
-		{
-			/* 子串口中断标志寄存器
-				SIFR ： Sub Uart Interupt Flag Register
-			*/
-			SIFR = WK_ReadSReg((i + 1), WK2XXX_SIFR);
-
-			// 有接收FIFO触点中断， 置位，接收非空
-			if ( SIFR & WK2XXX_RFTRIG_INT )
-			{
-				/* 调用WK_PortRecvData接收数据, 映射到指定的buff ,  */ 
-			}
-
-			// 有接收FIFO超时中断， 接收超时
-			if ( SIFR & WK2XXX_RXOVT_INT )
-			{
-
-			}
-
-			// 有发送FIFO触点中断， 置位子串口标记有发送
-			if ( SIFR & WK2XXX_TFTRIG_INT )
-			{
-
-			}
-
-			// 有发送FIFO空中断，置位子串口标记
-			if ( SIFR & WK2XXX_TFEMPTY_INT )
-			{
-
-			}
-
-			/*  有接收FIFO数据错误中断， 置位子串口标记
-				重新发送对应串口操作 ？  需要子串口类记录上次发生
-				子串口，要能调用父串口操作发送FIFO
-			*/
-			if ( SIFR & WK2XXX_FERR_INT )
-			{
-
-			}
-		}
-	}
-}
-
-/*************************************************************************/
-// 函数功能: 	此函数主要是通过读写wk2xxx的寄存器来判断主接口的通信时序是否有问题
-// 参数： 		无
-// 返回值：		rv表示返回值，0成功  
-/*************************************************************************/
-uint8_t Wk2xxx_Test(void)
-{
-	uint8_t rec_data,rv;
-	//主接口为SPI	
-	rec_data = WK_ReadSReg( WK2XXX_GPORT, WK2XXX_GENA );
-	if ( rec_data == 0x30 )
-		return rv;
-	else
-	{
-		rv = 1;
-		return rv;
-	}
-}
-
-
-/* 初始化
-int main()
-{
-	int nrecv = 0;
-	uint8_t buffer[256];
-	
-	// 硬件复位一下
-	WK_Rst();
-	
-	// 初始化四个端口
-	WK_PortInit(1, 11059200, 9600);  // WK2124晶振我用的是11.0592MHz的，这个值根据实际进行修改
-	WK_PortInit(2, 11059200, 9600);
-	WK_PortInit(3, 11059200, 9600);
-	WK_PortInit(4, 11059200, 9600);
-	
-	// 发送数据
-	WK_PortSendData(1, "helloworld\r\n", 12);
-	WK_PortSendData(2, "helloworld\r\n", 12);
-	WK_PortSendData(3, "helloworld\r\n", 12);
-	WK_PortSendData(4, "helloworld\r\n", 12);
-	
-	// 接收数据，轮询方式
-	nrecv = WK_PortRecvData(1, buffer, sizeof(buffer));
-	
-	if(nrecv != 0)
-	{
-		// 处理数据
-	}
-}
-*/
-
-
-
-// /***************************************************************************/
-// //本文件为WK2XXX系列串口扩展芯片的设备驱动程序,作为驱动参开demo。使用者可以根据自身的情况加以修改，完善。
-
-// /***************************************************************************/
-// #include "wk2xxx.h"
-// // #include "spi.h"
-// // #include "usart.h"
-// // #include "delay.h"
-
-
-// void WK2XXX_RST_Init(void)
-// {
-// 	GPIO_InitTypeDef  GPIO_InitStructure;
-// 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	 //使能PA,PD端口时钟
-// 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;				 //PA.3 端口配置
-// 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 //推挽输出
-// 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 //IO口速度为50MHz
-// 	GPIO_Init(GPIOA, &GPIO_InitStructure);					 //根据设定参数初始化GPIOA.3
-// 	GPIO_SetBits(GPIOA,GPIO_Pin_3);						 //PA.3 输出高	
-// }
-
-// void WK2XXX_Reset_Init(void)
-// {
-// 	GPIO_SetBits(GPIOA,GPIO_Pin_3);//1
-// 	GPIO_ResetBits(GPIOA,GPIO_Pin_3);//0
-// 	delay_ms(10);
-// 	GPIO_SetBits(GPIOA,GPIO_Pin_3);//1	
-// 	delay_ms(100);
-		
-// }
-// /*************************************************************************/
-// //函数功能：初始化SPI片选信号CS,并把CS的默认状态设置为高电平
-// //
-// //
-// /*************************************************************************/
-// void SPI_CS_Init(void)
-// {
-//  GPIO_InitTypeDef  GPIO_InitStructure;
-//  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	 //使能PA,PD端口时钟
-//  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4|GPIO_Pin_3;	//PA.4 端口配置
-//  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 //推挽输出
-//  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 //IO口速度为50MHz
-//  GPIO_Init(GPIOA, &GPIO_InitStructure);					 //根据设定参数初始化GPIOA.4
-//  GPIO_SetBits(GPIOA,GPIO_Pin_4);						 //PA.4 输出高	
-// }
-// /*************************************************************************/
-// //函数功能：初始化SPI总线，设置SPI总线为0模式
-// /*************************************************************************/
-// void SPI_BUS_Init(void)
-// {
-
-// 	SPI1_Init();		   //初始化SPI
-// 	SPI1_SetSpeed(SPI_BaudRatePrescaler_8);	//设置为10M时钟,高速模式
-// }
-// /*************************************************************************/
-// //函数功能：设置CS信号为高电平
-// /*************************************************************************/
-// void SPI_CS_H(void)
-// {
-// 	GPIO_SetBits(GPIOA,GPIO_Pin_4);
-// }
-// /*************************************************************************/
-// //函数功能：设置CS信号为低电平
-// /*************************************************************************/
-// void SPI_CS_L(void)
-// {
-// 	GPIO_ResetBits(GPIOA,GPIO_Pin_4);
-// }
-// /*************************************************************************/
-// //函数功能：初始化SPI接口
-// /*************************************************************************/
-// void WK2XXX_SPI_Init(void)
-// {
-// 	SPI_CS_Init();
-// 	SPI_BUS_Init();
-	
-	
-// }
-
-// /*************************************************************************/
-// //函数功能：写寄存器函数（前提是该寄存器可写，某些寄存器如果你写1，可能会自动置1，具体见数据手册)
-// //参数：port:为子串口的数(C0C1)
-// //      reg:为寄存器的地址(A3A2A1A0)
-// //      dat:为写入寄存器的数据
-// //注意：在子串口被打通的情况下，向FDAT写入的数据会通过TX引脚输出
-// //*************************************************************************/
-// void Wk2xxxWriteReg(unsigned char port,unsigned char reg,unsigned char dat)
-// {	 
-// 	 SPI_CS_L();//片选使能
-// 	 SPI1_ReadWriteByte(((port-1)<<4)+reg); //写控制字节
-// 	 SPI1_ReadWriteByte(dat); //写数据
-// 	 SPI_CS_H();//片选无效
-
-// }
-
-
-// /*************************************************************************/
-// //函数功能：读寄存器函数
-// //参数：port:为子串口的数(C0C1)
-// //      reg:为寄存器的地址(A3A2A1A0)
-// //      rec_data:为读取到的寄存器值
-// //注意：在子串口被打通的情况下，读FDAT，实际上就是读取uart的rx接收的数据
-// /*************************************************************************/
-// unsigned char Wk2xxxReadReg(unsigned char port,unsigned char reg)
-// {	
-// 	unsigned char rec_data; 
-// 	SPI_CS_L();	//片选使能
-// 	SPI1_ReadWriteByte(0x40+((port-1)<<4)+reg);//写控制字节，控制命令构成见数据手册
-// 	rec_data=SPI1_ReadWriteByte(0);//接收返回的数据
-// 	SPI_CS_H();	//片选无效	
-// 	return rec_data;
-// }
-// /**************************** Wk2xxxWriteFifo*********************************************/
-// //函数功能：该函数为写FIFO函数，通过该函数写入的数据会直接进入子串口的发送FIFO，然后通过TX引脚发送
-// //参数：port：为子串口的端口号(C0\C1)
-// //      *wbuf:写入数据部分
-// //      len：  写入数据长度
-// //
-// /*************************************************************************/
-// void Wk2xxxWriteFifo(unsigned char port,unsigned char *wbuf,unsigned int len)
-// {	 unsigned char n;
-// 	 SPI_CS_L(); // 片选有效
-// 	 SPI1_ReadWriteByte(0x80+((port-1)<<4)); //写FIFO控制指令
-// 	  for(n=0;n<len;n++)
-// 	    {
-// 	     SPI1_ReadWriteByte(*(wbuf+n));
-// 		} 
-// 	 SPI_CS_H();	//片选无效
-
-// }
-
-// /**************************** Wk2xxxReadFifo*********************************************/
-// //函数功能：该函数为读FIFO函数，通过该函数可以一次读出多个接收FIFO中的数据，最多256个字节
-// //参数：port：为子串口的端口号(C0\C1)
-// //      *rbuf:写入数据部分
-// //      len：  写入数据长度
-// //
-// /*************************************************************************/
-// void Wk2xxxReadFifo(unsigned char port,unsigned char *rbuf,unsigned int len)
-// {	 unsigned char n;
-// 	 SPI_CS_L();//片选有效
-// 	 SPI1_ReadWriteByte(0xc0+((port-1)<<4));	//写读fifo控制指令
-// 	 for(n=0;n<len;n++)
-// 	   {
-// 		*(rbuf+n)=SPI1_ReadWriteByte(0); 
-// 	   }
-// 	 SPI_CS_H();//片选无效										
-// 	 //return 0;
-// }
-
-// /*************************************************************************/
-// //函数功能:此函数主要是通过读写wk2xxx的寄存器来判断主接口的通信时序是否有问题
-// //参数：无
-// //返回值：rv表示返回值，0成功  
-// /*************************************************************************/
-//  unsigned char Wk2xxxTest(void)
-//  {
-// 	unsigned char rec_data,rv;
-// //主接口为SPI	
-// 	rec_data=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GENA);
-// 	if(rec_data==0x30)
-// 		return rv;
-// 	else
-// 		{
-// 			rv=1;
-// 			return rv;
-// 		}
-
-//  }
-// /******************************Wk2xxxInit*******************************************/
-// //函数功能：本函数主要会初始化一些芯片基本寄存器；
-// /*********************************************************************************/
-// void Wk2xxxInit(unsigned char port)
-// {
-//     unsigned char gena,grst,gier,sier,scr;
-// 	//使能子串口时钟
-//     gena=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GENA); 
-// 	switch (port)
-//     {
-//           case 1://使能子串口1的时钟
-//               gena|=WK2XXX_UT1EN;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
-//               break;
-// 		  case 2://使能子串口2的时钟
-//               gena|=WK2XXX_UT2EN;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
-//               break;
-// 		   case 3://使能子串口3的时钟
-//               gena|=WK2XXX_UT3EN;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
-//               break;
-// 		   case 4://使能子串口4的时钟
-//               gena|=WK2XXX_UT4EN;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
-//               break;
-// 	 }	
-// 	//软件复位子串口
-// 	grst=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GRST); 
-// 	switch (port)
-//     {
-//           case 1://软件复位子串口1
-//               grst|=WK2XXX_UT1RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
-//               break;
-// 		  case 2://软件复位子串口2
-//               grst|=WK2XXX_UT2RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
-//               break;
-// 		   case 3://软件复位子串口3
-//               grst|=WK2XXX_UT3RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
-//               break;
-// 		   case 4://软件复位子串口4
-//              grst|=WK2XXX_UT4RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
-//               break;
-// 	 }	
-//   //使能子串口中断，包括子串口总中断和子串口内部的接收中断，和设置中断触点
-// 	gier=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GIER); 
-// 	switch (port)
-//     {
-//           case 1://软件复位子串口1
-//               gier|=WK2XXX_UT1RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GIER,gier);
-//               break;
-// 		  case 2://软件复位子串口2
-//               gier|=WK2XXX_UT2RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GIER,gier);
-//               break;
-// 		   case 3://软件复位子串口3
-//               gier|=WK2XXX_UT3RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GIER,gier);
-//               break;
-// 		   case 4://软件复位子串口4
-//               gier|=WK2XXX_UT4RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GIER,gier);
-//               break;
-// 	 }	 
-// 	 //使能子串口接收触点中断和超时中断
-// 	 sier=Wk2xxxReadReg(port,WK2XXX_SIER); 
-// 	 sier |= WK2XXX_RFTRIG_IEN|WK2XXX_RXOVT_IEN;
-// 	 Wk2xxxWriteReg(port,WK2XXX_SIER,sier);
-// 	 // 初始化FIFO和设置固定中断触点
-// 	 Wk2xxxWriteReg(port,WK2XXX_FCR,0XFF);
-// 	 //设置任意中断触点，如果下面的设置有效，那么上面FCR寄存器中断的固定中断触点将失效
-// 	 Wk2xxxWriteReg(port,WK2XXX_SPAGE,1);//切换到page1
-// 	 Wk2xxxWriteReg(port,WK2XXX_RFTL,0X40);//设置接收触点为64个字节
-// 	 Wk2xxxWriteReg(port,WK2XXX_TFTL,0X10);//设置发送触点为16个字节
-// 	 Wk2xxxWriteReg(port,WK2XXX_SPAGE,0);//切换到page0 
-// 	 //使能子串口的发送和接收使能
-// 	 scr=Wk2xxxReadReg(port,WK2XXX_SCR); 
-// 	 scr|=WK2XXX_TXEN|WK2XXX_RXEN;
-// 	 Wk2xxxWriteReg(port,WK2XXX_SCR,scr);
-// }
-
-// /******************************Wk2xxxClose*******************************************/
-// //函数功能：本函数会关闭当前子串口，和复位初始值；
-// /*********************************************************************************/
-
-// void Wk2xxxClose(unsigned char port)
-// {
-//     unsigned char gena,grst;
-// 	//复位子串口
-// 	grst=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GRST); 
-// 	switch (port)
-//     {
-//           case 1://软件复位子串口1
-//               grst|=WK2XXX_UT1RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
-//               break;
-// 		  case 2://软件复位子串口2
-//               grst|=WK2XXX_UT2RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
-//               break;
-// 		   case 3://软件复位子串口3
-//               grst|=WK2XXX_UT3RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
-//               break;
-// 		   case 4://软件复位子串口4
-//               grst|=WK2XXX_UT4RST;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
-//               break;
-// 	 }	
-// 	//关闭子串口时钟
-//     gena=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GENA); 
-// 	switch (port)
-//     {
-//           case 1://使能子串口1的时钟
-//               gena&=~WK2XXX_UT1EN;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
-//               break;
-// 		  case 2://使能子串口2的时钟
-//               gena&=~WK2XXX_UT2EN;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
-//               break;
-// 		   case 3://使能子串口3的时钟
-//               gena&=~WK2XXX_UT3EN;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
-//               break;
-// 		   case 4://使能子串口4的时钟
-//               gena&=~WK2XXX_UT4EN;
-// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
-//               break;
-// 	 }	
-// }
-
-
-
-
-
-
-// /**************************Wk2xxxSetBaud*******************************************************/
-// //函数功能：设置子串口波特率函数、此函数中波特率的匹配值是根据11.0592Mhz下的外部晶振计算的
-// // port:子串口号
-// // baud:波特率大小.波特率表示方式，
-// //
-// /**************************Wk2xxxSetBaud*******************************************************/
-// void Wk2xxxSetBaud(unsigned char port,int baud)
-// {  
-// 	unsigned char baud1,baud0,pres,scr;
-// 	//如下波特率相应的寄存器值，是在外部时钟为11.0592的情况下计算所得，如果使用其他晶振，需要重新计算
-// 	switch (baud) 
-// 	{
-//       case 1:
-// 			baud1=0x4;
-// 			baud0=0x7f;
-// 			pres=0;
-//       break;
-//       case 2:
-// 			baud1=0x2;
-// 			baud0=0x3F;
-// 			pres=0;
-// 			break;
-//       case 3:
-// 			baud1=0x1;
-// 			baud0=0x1f;
-// 			pres=0;
-// 			break;
-//       case 4:
-// 			baud1=0x00;
-// 			baud0=0x8f;
-// 			pres=0;
-// 			break;
-//       case 5:
-// 			baud1=0x00;
-// 			baud0=0x47;
-// 			pres=0;
-// 			break;
-//       case 6:
-// 			baud1=0x00;
-// 			baud0=0x23;
-// 			pres=0;
-// 			break;
-//       case 7:
-// 			baud1=0x00;
-// 			baud0=0x11;
-// 			pres=0;
-// 			break;
-			
-//       case 8:
-// 			baud1=0x00;
-// 			baud0=0x08;
-// 			pres=0;
-// 			break; 
-       
-//       case 9:
-// 			baud1=0x01;
-// 			baud0=0x7f;
-// 			pres=0;
-// 			break;
-//       case 10:
-// 			baud1=0x00;
-// 			baud0=0xbf;
-// 			pres=0;
-// 			break;
-//       case 11:
-// 			baud1=0x00;
-// 			baud0=0x5f;
-// 			pres=0;
-// 			break;
-//       case 12:
-// 			baud1=0x00;
-// 			baud0=0x2f;
-// 			pres=0;
-// 			break;
-//       case 13:
-// 			baud1=0x00;
-// 			baud0=0x17;
-// 			pres=0;
-// 			break;
-//       case 14:
-// 			baud1=0x00;
-// 			baud0=0x0b;
-// 			pres=0;
-//       break;
-//       case 15:
-// 			baud1=0x00;
-// 			baud0=0x05;
-// 			pres=0;
-// 			break;
-//       case 16:
-// 			baud1=0x00;
-// 			baud0=0x02;
-// 			pres=0;
-// 			break;
-//       default:
-// 			baud1=0x00;
-// 			baud0=0x00;
-// 			pres=0;
-//     }
-// 	//关掉子串口收发使能
-// 	scr=Wk2xxxReadReg(port,WK2XXX_SCR); 
-// 	Wk2xxxWriteReg(port,WK2XXX_SCR,0);
-// 	//设置波特率相关寄存器
-// 	Wk2xxxWriteReg(port,WK2XXX_SPAGE,1);//切换到page1
-// 	Wk2xxxWriteReg(port,WK2XXX_BAUD1,baud1);
-// 	Wk2xxxWriteReg(port,WK2XXX_BAUD0,baud0);
-// 	Wk2xxxWriteReg(port,WK2XXX_PRES,pres);
-// 	Wk2xxxWriteReg(port,WK2XXX_SPAGE,0);//切换到page0 
-// 	//使能子串口收发使能
-// 	Wk2xxxWriteReg(port,WK2XXX_SCR,scr);
-	
-	
-// }
-// /*****************************Wk2xxxSendBuf****************************************/
-// //本函数为子串口发送数据的函数，发送数据到子串口的FIFO.然后通过再发送
-// //参数说明：port：子串口端口号
-// //          *sendbuf:需要发送的数据buf
-// //          len：需要发送数据的长度
-// // 函数返回值：实际成功发送的数据
-// //说明：调用此函数只是把数据写入子串口的发送FIFO，然后再发送。1、首先确认子串口的发送FIFO有多少数据，根据具体情况、
-// //确定写入FIFO数据的个数，
-// /*********************************************************************/
-// unsigned int Wk2xxxSendBuf(unsigned char port,unsigned char *sendbuf,unsigned int len)
-// {
-// 	 unsigned int ret,tfcnt,sendlen;
-// 	 unsigned char  fsr;
-	  
-// 	 fsr=Wk2xxxReadReg(port,WK2XXX_FSR);
-// 	 if(~fsr&WK2XXX_TFULL )//子串口发送FIFO未满
-// 	 {
-
-// 	     tfcnt=Wk2xxxReadReg(port,WK2XXX_TFCNT);//读子串口发送fifo中数据个数
-// 		 sendlen=256-tfcnt;//FIFO能写入的最多字节数
-		 
-// 		 if(sendlen<len)
-// 		 {
-// 			ret=sendlen; 
-// 			Wk2xxxWriteFifo(port,sendbuf,sendlen);
-// 		 }
-// 		 else
-// 		 {
-// 			 Wk2xxxWriteFifo(port,sendbuf,len);
-// 			 ret=len;
-// 		 }
-// 	  }
-	 
-// 	 return ret;
-// }
-
-// /*****************************Wk2xxxGetBuf****************************************/
-// //本函数为子串口接收数据函数
-// //参数说明：port：子串口端口号
-// //          *getbuf:接收到的数据buf
-// // 函数返回值：实际接收到的数据个数
-// /*********************************************************************/
-// unsigned int Wk2xxxGetBuf(unsigned char port,unsigned char *getbuf)
-// {
-// 	unsigned int ret=0,rfcnt;
-// 	unsigned char fsr;
-// 	fsr=Wk2xxxReadReg(port,WK2XXX_FSR);
-// 	if(fsr&WK2XXX_RDAT )//子串口接收FIFO未空
-// 	  {
-// 	     rfcnt=Wk2xxxReadReg(port,WK2XXX_RFCNT);//读子串口发送fifo中数据个数
-// 		 if(rfcnt==0)//当RFCNT寄存器为0的时候，有两种情况，可能是256或者是0，这个时候通过FSR来判断，如果FSR显示接收FIFO不为空，就为256个字节
-// 		 {rfcnt=256;}
-// 		 Wk2xxxReadFifo(port,getbuf,rfcnt);
-// 		 ret=rfcnt;
-// 	   }
-// 	 return ret;	
-// }
-