develop
esea_info 2 years ago
parent 6869cb71fa
commit 03295ed99f
  1. 323
      device/Inc/wk2114.h
  2. 434
      device/Src/base.c
  3. 1668
      device/Src/wk2114.c
  4. 1903
      device/Src/wk2114_port.c

@ -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,36 +330,150 @@ int wk2114_sub_uart_set_inter(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t inter_fla
int wk2114_sub_uart_set_fifo_trigger(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t tx_trigger,uint8_t rx_trigger);
void wk2114_reg_recv_callback(WK2114_TypeDef *wk2114);
int wk2114_reset(WK2114_TypeDef *wk2114);
int wk2114_set_baud( WK2114_TypeDef *wk2114 );
int wk2114_test(WK2114_TypeDef *wk2114);
int wk2114_mainport_rcv(WK2114_TypeDef *wk2114, uint8_t *buf, uint16_t size);
int wk2114_set_uart(WK2114_TypeDef *wk2114,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits);
int wk2114_set_sub_uart(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t buad,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits);
int wk2114_set_sub_uart(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t baud,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits);
int wk2114_sub_uart_set_mode(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t mode);
int wk2114_sub_uart_set_fifo_mode(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t mode);
int wk2114_sub_uart_enable(WK2114_Sub_Uart_TypeDef*sub_uart);
int wk2114_sub_uart_disable(WK2114_Sub_Uart_TypeDef*sub_uart);
int wk2114_sub_uart_reset(WK2114_Sub_Uart_TypeDef*sub_uart);
WK2114_TypeDef * wk2114_init(WK2114_TypeDef *wk2114,uint32_t dev_clock_hz,void *send_class,wk2114_send_fun send_fun);
// WK2114_TypeDef * wk2114_init(WK2114_TypeDef *wk2114,uint32_t dev_clock_hz,void *send_class,wk2114_send_fun send_fun);
int wk2114_sub_uart_register(WK2114_TypeDef *wk2114,WK2114_Sub_Uart_TypeDef*sub_uart,enum wk2114_s_uart uart_addr,uint8_t *recv_buf,uint32_t recv_buf_size,void *recv_class,wk2114_sub_uart_recv_fun recv_fun);
int wk2114_sub_uart_init(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t buad,uint8_t mode,uint8_t fifo_mode,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits);
int wk2114_sub_uart_init(WK2114_Sub_Uart_TypeDef*sub_uart,uint32_t baud,uint8_t mode,uint8_t fifo_mode,enum wk2114_uart_parity party,enum wk2114_uart_stop_bits stop_bits);
int wk2114_sub_uart_chenge_recv_fun(WK2114_Sub_Uart_TypeDef*sub_uart,void *recv_class,wk2114_sub_uart_recv_fun recv_fun);
int wk2114_sub_uart_send(WK2114_Sub_Uart_TypeDef*sub_uart,uint8_t *buf,uint32_t size);
int wk2114_sub_uart_isbusy(WK2114_Sub_Uart_TypeDef*sub_uart);
void wk2114_recv_callback(WK2114_TypeDef *wk2114,uint8_t *buf,uint32_t size);
void wk2114_inter_callback(WK2114_TypeDef *wk2114);
// void wk2114_exti_callback(WK2114_TypeDef *wk2114);
void wk2114_send_completed_callback(WK2114_TypeDef *wk2114);
void wk2114_idle_callback(WK2114_TypeDef *wk2114,uint8_t *buf,uint32_t size);
void wk2114_get_it_type_by_it_source(WK2114_TypeDef *wk2114);
void wk2114_process_by_it_type(WK2114_TypeDef *wk2114, uint8_t it_type);
#endif
/*
#define WK2114_RST_Pin GPIO_PIN_6
#define WK2114_RST_GPIO_Port GPIOF
#define WK2114_IRQ_Pin GPIO_PIN_7
#define WK2114_IRQ_GPIO_Port GPIOF
__HAL_RCC_GPIOF_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = WK2114_RST_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
// 以下可以启动子串口的产生的 接收外部中断
GPIO_InitStruct.Pin = WK2114_IRQ_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(WK2114_IRQ_GPIO_Port, &GPIO_InitStruct);
// EXTI interrupt init
HAL_NVIC_SetPriority(EXTI9_5_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);
void EXTI9_5_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(WK2114_IRQ_Pin);
}
rtos中
*/
/*
7 6 5 4 3 2 1 0
[7] 0 reg读写 ; 1 FIFO读写
[6] 0 1
[5:4] 00
[3:0] FIFO模式
0x55 return 0x00
0x40 return 0xF0
0x55 ()
1 ,
write reg 0x00 0x01
write reg 0x01 0x01
write reg 0x10 0x01
write reg 0x03 0x01
write reg 0x04 0x00
write reg 0x05 0x4d(9600) 0505(115200)
write reg 0x06 0x01 0605
write reg 0x03 0x00
write reg 0x05 0x00
write reg 0x03 0x01
write reg 0x08 0x80
write reg 0x07 0x80
write reg 0x03 0x00
write reg 0x07 0x83
write reg 0x06 0x0c
write reg 0x04 0x03
//WK2xxx 初始化
if(0==WK2114_Init())
{
log_i("wk2114 Init Ok...");
}else{
log_i("wk2114 Init Failure...");
}
// 启动任务
WK2114_Port();
// 状态机初始化
wk2114->state= WK2114_WORK_STATE_START;
// 发送 , 调用wk2114_sub_uart_send函数, 装载子串口队列及buf
// wk2114_sub_uart_send启用子串口中断, 发送触点为空中断,调用wk2114_write_fifo 进行发送
// 注意: 发送fifo 256, 发送触点中断设置为128超过128 自动启动发送触点中断
wk2114_sub_uart_send(wk2114->sub_uart[0],send_buf,8);
8.3.1 FIFO数据错误中断
FIFO数据错误中断表明当前接收FIFO中有一个或以上的数据错误OE
FEPEBELine-Break错误
FIFO中有出错数据,FSR寄存器后
8.3.2 FIFO空中断 --
FIFO中没有数据
FIFO中的数据个数大于设定的发送FIFO触发点时
8.3.3 FIFO触发点中断
FIFO中的数据个数小于设定的发送FIFO触发点时
FIFO中的数据个数大于设定的发送FIFO触发点时
8.3.4FIFO超时中断
FIFO中数据个数小于设定的接收FIFO触发点并且RX引脚4个字节之内没有数据
FIFO中的数据被读走或者RX继续接收数据时
8.3.5 FIFO触发点中断
FIFO中的数据个数大于设定的发送FIFO触发点时
FIFO中的数据个数小于设定的发送FIFO触发点时
pH 使 1
pH里面回调函数 PH_Callback 1
wk2114_read_reg( wk2114, 0x00 ); [7:6] 0 1
1. 1
HAL_UART_DMAStop(pWK2114Uart);
HAL_UARTEx_ReceiveToIdle_DMA( pWK2114Uart, rcvbuf, 1024);
wk2114->cmd =0;
wk2114_read_reg( wk2114, 0x00 );
2. PH_callback
*/

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

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff
Loading…
Cancel
Save