gitea/g0b1vetx-board
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改驱动程序

Browse Source
This commit is contained in:
2584532475@qq.com committed 2023-05-19 18:02:00 +08:00
1 parent 063c3fcc07
commit a69c1a58d6
39 files changed
+1627 -641
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Board/di-board.c
+32 -32
View File
@@ -1,41 +1,41 @@
#include "main.h"
int DiReadChann(int chann)
int DiReadChann (int chann)
{
int ret = -1;
switch(chann)
switch (chann)
{
case 1:
{
ret = HAL_GPIO_ReadPin(DI1_GPIO_Port,DI1_Pin);
break;
}
case 2:
{
ret = HAL_GPIO_ReadPin(DI2_GPIO_Port,DI2_Pin);
break;
}
case 3:
{
ret = HAL_GPIO_ReadPin(DI3_GPIO_Port,DI4_Pin);
break;
}
case 4:
{
ret = HAL_GPIO_ReadPin(DI4_GPIO_Port,DI4_Pin);
break;
}
case 5:
{
ret = HAL_GPIO_ReadPin(DI5_GPIO_Port,DI5_Pin);
break;
}
case 6:
{
ret = HAL_GPIO_ReadPin(DI6_GPIO_Port,DI6_Pin);
break;
}
case 1:
{
ret = HAL_GPIO_ReadPin (DI1_GPIO_Port, DI1_Pin);
break;
}
case 2:
{
ret = HAL_GPIO_ReadPin (DI2_GPIO_Port, DI2_Pin);
break;
}
case 3:
{
ret = HAL_GPIO_ReadPin (DI3_GPIO_Port, DI4_Pin);
break;
}
case 4:
{
ret = HAL_GPIO_ReadPin (DI4_GPIO_Port, DI4_Pin);
break;
}
case 5:
{
ret = HAL_GPIO_ReadPin (DI5_GPIO_Port, DI5_Pin);
break;
}
case 6:
{
ret = HAL_GPIO_ReadPin (DI6_GPIO_Port, DI6_Pin);
break;
}
}
return ret;
}
Board/di-board.h
+3 -3
View File
@@ -1,9 +1,9 @@
#ifndef _DI_BOARD_H
#define _DI_BOARD_H
void DiInit(void);
int DiReadChann(int chann);
void DiInit (void);
int DiReadChann (int chann);
#endif
#endif
Board/eth-board.c
+207 -201
View File
@@ -7,11 +7,11 @@
// 尝试创建Socket
const char
const char
void EthMqttTick(void)
void EthMqttTick (void)
{
if (s_tx_timeout > 1)
s_tx_timeout--;
@@ -27,7 +27,8 @@ void EthMqttTick(void)
// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_SET);
//}
static enum {
static enum
{
DeviceReboot,
DeviceConfig,
DeviceGetPara,
@@ -35,13 +36,14 @@ static enum {
DeviceReset,
DeviceLink,
DeviceIdle,
}DeviceState = DeviceReboot ;
static enum {
} DeviceState = DeviceReboot ;
static enum
{
FistIn,
Runing,
End,
JumpUp
}s_run = FistIn;
} s_run = FistIn;
@@ -54,11 +56,11 @@ static enum {
// NetFunc.ReSubTopic = EthMqttReSubTopic;
// NetFunc.Task = EthMqttTask;
void EthMqttInit(void)
void EthMqttInit (void)
{
// char str[128];
// char addr_str[10];
// GPIO_InitTypeDef GPIO_InitStruct;
// GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
// GPIO_InitStruct.Pull = GPIO_PULLUP;
@@ -67,7 +69,7 @@ void EthMqttInit(void)
// GPIO_InitStruct.Pin = GPIO_PIN_1;
// HAL_GPIO_Init (GPIOB, &GPIO_InitStruct);
// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_SET);
// GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
// GPIO_InitStruct.Pull = GPIO_PULLUP;
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@@ -101,42 +103,42 @@ void EthMqttDisConnectd (void)
s_lost_timer = 0;
DisWriteNetSte (2, QUEUE);
DeviceState = DeviceReboot;
dbg_printf("Eth Device IsDisconnected \r\n");
dbg_printf ("Eth Device IsDisconnected \r\n");
}
int EthMqttReadData(char * buf,int length)
int EthMqttReadData (char * buf, int length)
{
int k =0;
if (UartInfoRxIsReady(uEth) == 1)
int k = 0;
if (UartInfoRxIsReady (uEth) == 1)
{
k = UartInfoReadData(uEth,(char *)buf,length);
dbg_printf("<<<<<<<<<<<<%d\r\n",k);
k = UartInfoReadData (uEth, (char *) buf, length);
dbg_printf ("<<<<<<<<<<<<%d\r\n", k);
s_lost_timer = 60000;
DisWriteNetSte (1, QUEUE);
}
return k;
}
int EthMqttIsReady(void)
int EthMqttIsReady (void)
{
if (DeviceState != DeviceIdle )
if (DeviceState != DeviceIdle)
{
return 0;
}
else
{
return UartInfoRxIsReady(uEth);
return UartInfoRxIsReady (uEth);
}
}
void EthMqttWriteData(char * data,int length)
void EthMqttWriteData (char * data, int length)
{
UartInfoWriteData(uEth,data,length);
UartInfoWriteData (uEth, data, length);
}
int EthMqttIsIdle(void)
int EthMqttIsIdle (void)
{
if (EthMqttIsConnect() == 0)
{
@@ -148,209 +150,213 @@ int EthMqttIsIdle(void)
}
int EthMqttIsConnect(void)
int EthMqttIsConnect (void)
{
if (HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_4) == GPIO_PIN_SET)
if (HAL_GPIO_ReadPin (GPIOC, GPIO_PIN_4) == GPIO_PIN_SET)
return 1;
else
else
return 0;
//return s_isconnect;
}
void EthMqttTask(void)
void EthMqttTask (void)
{
int rx_size;
char str[128];
//static pst_Work_Pragma pstWork_Pragma;
switch(DeviceState)
switch (DeviceState)
{
case DeviceReboot:
case DeviceReboot:
{
if (s_run == FistIn)
{
if (s_run == FistIn)
{
dbg_printf("EthDeviceReboot\r\n");
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_RESET);
s_run_timer = 500;
s_run = Runing;
}
else if (s_run == Runing)
{
if(s_run_timer == 1)
{
s_run_timer = 0;
s_run = End;
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_SET);
dbg_printf("Reboot Finsh\r\n");
s_run_timer = 5000;
}
}
else if (s_run == End){
if (s_run_timer == 1)
{
//dbg_printf("Reboot Finsh\r\n");
s_run = JumpUp;
s_run_timer = 0;
}
}
else{
s_run = FistIn ;
DeviceState = DeviceConfig;
}
break;
dbg_printf ("EthDeviceReboot\r\n");
HAL_GPIO_WritePin (GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
s_run_timer = 500;
s_run = Runing;
}
// 这里要等待3s
case DeviceConfig: // 进入配置模式
else if (s_run == Runing)
{
if(s_run == FistIn)
if (s_run_timer == 1)
{
dbg_printf("DeviceConfig\r\n");
UartInfoClearData (uEth) ;
UartInfoWriteData(uEth,"++++++++++",10);
s_run_timer = 0;
s_run = End;
HAL_GPIO_WritePin (GPIOB, GPIO_PIN_1, GPIO_PIN_SET);
dbg_printf ("Reboot Finsh\r\n");
s_run_timer = 5000;
}
}
else if (s_run == End)
{
if (s_run_timer == 1)
{
//dbg_printf("Reboot Finsh\r\n");
s_run = JumpUp;
s_run_timer = 0;
}
}
else
{
s_run = FistIn ;
DeviceState = DeviceConfig;
}
break;
}
// 这里要等待3s
case DeviceConfig: // 进入配置模式
{
if (s_run == FistIn)
{
dbg_printf ("DeviceConfig\r\n");
UartInfoClearData (uEth) ;
UartInfoWriteData (uEth, "++++++++++", 10);
s_run_timer = 50;
s_run = Runing;
}
else if (s_run == Runing)
{
if (s_run_timer == 1)
{
s_run_timer = 0;
UartInfoWriteData (uEth, "{\"Command\":\"config\"}", strlen ("{\"Command\":\"config\"}"));
dbg_printf ("Command\r\n");
s_run = End;
s_run_timer = 3000;
}
// 获取发送的数据
}
else if (s_run == End)
{
if (s_run_timer == 1)
{
s_run = JumpUp;
s_run_timer = 0;
}
}
else
{
s_run = FistIn;
DeviceState = DeviceGetPara;
}
break;
}
case DeviceGetPara:
{
if (UartInfoRxIsReady (uEth) == 1)
{
dbg_printf ("DeviceGetPara\r\n");
rx_size = UartInfoReadData (uEth, (char *) s_buffer, 1024);
dbg_printf ("(%d)[%d]\r\n", rx_size, s_buffer[0]) ;
DeviceState = DeviceSetPara;
}
break;
}
case DeviceSetPara:
{
if (s_run == FistIn)
{
memset (s_buffer, 0, 1024);
//dbg_printf("subtopic:%s\r\n",(char *)pstWork_Pragma->stExternPragma.stMQTTClient.SubTopic);
sprintf (s_buffer,
"{\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":%d,\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":\"%s\"}",
"Command", "config",
"RemoteHost", SysInfo.remoteAddr,
"RemotePort", SysInfo.remotePort,
"WorkMode", "MQTT",
"UserName", SysInfo.remoteuser,
"Password", SysInfo.remotepass,
"PubTopic", pub_topic,
"SubTopic", sub_topic
);
//SetParametersToData(pstWork_Pragma,(char *)s_buffer,1024);
dbg_printf ("%s\r\n", s_buffer);
UartInfoWriteData (uEth, s_buffer, strlen (s_buffer));
s_run_timer = 1000;
s_run = Runing;
}
else if (s_run == Runing)
{
if (s_run_timer == 1)
{
s_run_timer = 0;
UartInfoWriteData (uEth, "{\"Command\":\"exit\"}", strlen ("{\"Command\":\"exit\"}"));
dbg_printf ("Command\r\n");
s_run = End;
s_run_timer = 50;
s_run = Runing;
}
else if (s_run == Runing)
{
if(s_run_timer == 1)
{
s_run_timer = 0;
UartInfoWriteData(uEth,"{\"Command\":\"config\"}",strlen("{\"Command\":\"config\"}"));
dbg_printf("Command\r\n");
s_run = End;
s_run_timer = 3000;
}
// 获取发送的数据
}
else if (s_run == End)
{
if (s_run_timer == 1)
{
s_run = JumpUp;
s_run_timer = 0;
}
}
else
{
s_run = FistIn;
DeviceState = DeviceGetPara;
}
break;
// 获取发送的数据
}
case DeviceGetPara:
else if (s_run == End)
{
if (UartInfoRxIsReady(uEth) == 1)
if (s_run_timer == 1)
{
dbg_printf("DeviceGetPara\r\n");
rx_size = UartInfoReadData(uEth,(char *)s_buffer,1024);
dbg_printf("(%d)[%d]\r\n",rx_size,s_buffer[0]) ;
DeviceState = DeviceSetPara;
s_run = JumpUp;
s_run_timer = 0;
}
break;
}
case DeviceSetPara:
else
{
if(s_run == FistIn)
{
memset(s_buffer,0,1024);
//dbg_printf("subtopic:%s\r\n",(char *)pstWork_Pragma->stExternPragma.stMQTTClient.SubTopic);
sprintf(s_buffer,
"{\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":%d,\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":\"%s\"}",
"Command", "config",
"RemoteHost",SysInfo.remoteAddr,
"RemotePort",SysInfo.remotePort,
"WorkMode","MQTT",
"UserName",SysInfo.remoteuser,
"Password" ,SysInfo.remotepass,
"PubTopic",pub_topic,
"SubTopic",sub_topic
);
//SetParametersToData(pstWork_Pragma,(char *)s_buffer,1024);
dbg_printf("%s\r\n",s_buffer);
UartInfoWriteData(uEth,s_buffer,strlen(s_buffer));
s_run_timer = 1000;
s_run = Runing;
}
else if (s_run == Runing)
{
if(s_run_timer == 1)
{
s_run_timer = 0;
UartInfoWriteData(uEth,"{\"Command\":\"exit\"}",strlen("{\"Command\":\"exit\"}"));
dbg_printf("Command\r\n");
s_run = End;
s_run_timer = 50;
}
// 获取发送的数据
}
else if (s_run == End)
{
if (s_run_timer == 1)
{
s_run = JumpUp;
s_run_timer = 0;
}
}
else
{
s_run = FistIn;
DeviceState = DeviceReset;
}
break;
s_run = FistIn;
DeviceState = DeviceReset;
}
case DeviceReset:
break;
}
case DeviceReset:
{
if (s_run == FistIn)
{
if (s_run == FistIn)
{
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_RESET);
s_run_timer = 500;
s_run = Runing;
}
else if (s_run == Runing)
{
if(s_run_timer == 1)
{
s_run_timer = 0;
s_run = End;
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_SET);
dbg_printf("Reboot Finsh\r\n");
s_run_timer = 3000;
}
}
else if (s_run == End){
if (s_run_timer == 1)
{
dbg_printf("Reboot Finsh\r\n");
UartInfoClearData (uEth) ;
s_run = JumpUp;
s_run_timer = 0;
}
}
else{
s_run = FistIn ;
DeviceState = DeviceIdle;
}
break;
HAL_GPIO_WritePin (GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
s_run_timer = 500;
s_run = Runing;
}
case DeviceLink:// 检查上线
else if (s_run == Runing)
{
s_isconnect = 1;
if (s_run_timer == 1)
{
s_run_timer = 0;
s_run = End;
HAL_GPIO_WritePin (GPIOB, GPIO_PIN_1, GPIO_PIN_SET);
dbg_printf ("Reboot Finsh\r\n");
s_run_timer = 3000;
}
}
else if (s_run == End)
{
if (s_run_timer == 1)
{
dbg_printf ("Reboot Finsh\r\n");
UartInfoClearData (uEth) ;
s_run = JumpUp;
s_run_timer = 0;
}
}
else
{
s_run = FistIn ;
DeviceState = DeviceIdle;
break;
}
case DeviceIdle:
break;
}
case DeviceLink:// 检查上线
{
s_isconnect = 1;
DeviceState = DeviceIdle;
break;
}
case DeviceIdle:
{
if (s_lost_timer == 0)
{
if (s_lost_timer == 0)
if (EthMqttIsConnect())
{
if (EthMqttIsConnect())
{
EthMqttConnectd();
s_lost_timer = 60000;
}
// 第一次上线
EthMqttConnectd();
s_lost_timer = 60000;
}
break;
// 第一次上线
}
break;
}
}
if (s_lost_timer == 1)
{
@@ -358,17 +364,17 @@ void EthMqttTask(void)
s_run = FistIn ;
}
}
int EthMqttReSubTopic(char * topic)
int EthMqttReSubTopic (char * topic)
{
char addr_str[10];
memset(addr_str,0,10);
hexbyte_to_hex_str((char *)SysInfo.Addr,addr_str,4);
memset(sub_topic,0,64);
sprintf(sub_topic,"device/%s/tx/22000073%s",topic,addr_str);
memset(pub_topic,0,64);
sprintf(pub_topic,"device/%s/rx/22000073%s",topic,addr_str);
dbg_printf("EthMqttReSubTopic\r\n");
char addr_str[10];
memset (addr_str, 0, 10);
hexbyte_to_hex_str ( (char *) SysInfo.Addr, addr_str, 4);
memset (sub_topic, 0, 64);
sprintf (sub_topic, "device/%s/tx/22000073%s", topic, addr_str);
memset (pub_topic, 0, 64);
sprintf (pub_topic, "device/%s/rx/22000073%s", topic, addr_str);
dbg_printf ("EthMqttReSubTopic\r\n");
// memset(sub_topic,0,64);
// sprintf(sub_topic,"device/%s/tx/22000000%08x",topic,SysInfo.Addr);
// memset(pub_topic,0,64);
Board/eth-board.h
+10 -10
View File
@@ -1,27 +1,27 @@
#ifndef _ETH_BOARD_H
#define _ETH_BOARD_H µçѹ
void EthMqttTick(void);
void EthMqttTask(void);
void EthMqttInit(void);
void EthMqttTick (void);
void EthMqttTask (void);
void EthMqttInit (void);
int EthMqttReadData(char * buf,int length);
int EthMqttReadData (char * buf, int length);
int EthMqttIsReady(void);
int EthMqttIsReady (void);
void EthMqttWriteData(char * data,int length);
void EthMqttWriteData (char * data, int length);
int EthMqttIsIdle(void);
int EthMqttIsIdle (void);
int EthMqttIsConnect(void);
int EthMqttIsConnect (void);
int EthMqttReSubTopic(char * topic);
int EthMqttReSubTopic (char * topic);
#endif
#endif
Board/network/dtu-board.c
+101
View File
@@ -0,0 +1,101 @@
#include "main.h"
#include "os-app.h"
#include <stdio.h>
#include <rtthread.h>
#include <string.h>
#include "usart-board.h"
#if !defined(LOG_TAG)
#define LOG_TAG "dtu"
#endif
#include <elog.h>
ALIGN (RT_ALIGN_SIZE)
static char thread_stack[2048];
static struct rt_thread dtu_thread;
static struct
{
uint32_t isConnected; // 连接成功
} g_dtuDrv ;
static enum
{
netDrvInit = 0, // 初始化网络驱动
netDrvJoin = 1, // 等待网络注册成功
netDrvSend = 2, // 发送数据
netDrvRecv = 3, // 读取数据
netDrvIdle = 4, // 读取数据
} eDrvStatus;
static void net_data_rxdone(void)
{
rt_event_send(gUartEvents,EVENT_UART_ETH1_RX);
//rt_kprintf("net_data_rxdone\r\n");
}
static void thread_entry (void * argument)
{
// eDrvStatus = netDrvInit;
rt_kprintf ("%s was start!\r\n", __FILE__);
// gnetEvents = rt_event_create("gnetEvents", RT_IPC_FLAG_FIFO) ;
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(ETH_RST_GPIO_Port, ETH_RST_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(ETH_PW_GPIO_Port, ETH_PW_Pin, GPIO_PIN_SET);
g_ETH1Drv.rxdone = net_data_rxdone;
MX_UART_Init(&g_ETH1Drv);
// // 注册网络驱动
// 注册网络驱动
while (1)
{
//MX_UART_PutBuffer(&g_ETH1Drv,"20140524",8);
if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH1_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL ))
{
rt_kprintf("<<<<<<<<<<<<<<<<<<<<rx1:\r\n");
for(int i =0; i < g_ETH1Drv.rx_size;i++)
{
rt_kprintf("%02X ",g_ETH1Drv.rx_buffer[i]);
}
rt_kprintf("\r\n");
MX_UART_Clear(&g_ETH1Drv);
}
rt_thread_delay (100);
}
}
void DTUThreadStart (void)
{
/* 创建线程1，名称是thread1，入口是thread1_entry*/
rt_thread_init (&dtu_thread, "dtu_thread",
thread_entry, RT_NULL,
&thread_stack[0],
sizeof (thread_stack),
DTU_THREAD_PRIORITY, DTU_THREAD_TIMESLICE);
rt_thread_startup (&dtu_thread);
return ;
}
Board/network/dtu-board.h
+9
View File
@@ -0,0 +1,9 @@
#ifndef _DTU_BOARD_H
#define _DTU_BOARD_H
typedef struct {
}
#endif
Board/network/dtu2-board.c
+101
View File
@@ -0,0 +1,101 @@
#include "main.h"
#include "os-app.h"
#include <stdio.h>
#include <rtthread.h>
#include <string.h>
#include "usart-board.h"
#if !defined(LOG_TAG)
#define LOG_TAG "dtu2"
#endif
#include <elog.h>
ALIGN (RT_ALIGN_SIZE)
static char thread_stack[2048];
static struct rt_thread dtu2_thread;
static enum
{
netDrvInit = 0, // 初始化网络驱动
netDrvJoin = 1, // 等待网络注册成功
netDrvSend = 2, // 发送数据
netDrvRecv = 3, // 读取数据
netDrvIdle = 4, // 读取数据
} eDrvStatus;
static void net_data_rxdone(void)
{
rt_event_send(gUartEvents,EVENT_UART_ETH2_RX);
//rt_kprintf("net_data_rxdone\r\n");
}
static void thread_entry (void * argument)
{
// eDrvStatus = netDrvInit;
rt_kprintf ("%s was start!\r\n", __FILE__);
g_ETH2Drv.rxdone = net_data_rxdone;
MX_UART_Init(&g_ETH2Drv);
// // 注册网络驱动
// 注册网络驱动
while (1)
{
//MX_UART_PutBuffer(&g_ETH1Drv,"20140524",8);
if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH1_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL ))
{
rt_kprintf("<<<<<<<<<<<<<<<<<<<<rx1:\r\n");
for(int i =0; i < g_ETH1Drv.rx_size;i++)
{
rt_kprintf("%02X ",g_ETH1Drv.rx_buffer[i]);
}
rt_kprintf("\r\n");
MX_UART_Clear(&g_ETH1Drv);
}
if( RT_EOK == rt_event_recv( gUartEvents, EVENT_UART_ETH2_RX,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, RT_NULL ))
{
rt_kprintf("<<<<<<<<<<<<<<<<<<<<rx2:\r\n");
for(int i =0; i < g_ETH2Drv.rx_size;i++)
{
rt_kprintf("%02X ",g_ETH2Drv.rx_buffer[i]);
}
rt_kprintf("\r\n");
MX_UART_Clear(&g_ETH2Drv);
}
rt_thread_delay (100);
}
}
void DTU2ThreadStart (void)
{
/* 创建线程1，名称是thread1，入口是thread1_entry*/
rt_thread_init (&dtu2_thread, "dtu2_thread",
thread_entry, RT_NULL,
&thread_stack[0],
sizeof (thread_stack),
DTU2_THREAD_PRIORITY, DTU2_THREAD_TIMESLICE);
rt_thread_startup (&dtu2_thread);
return ;
}
Board/network/dtu2-board.h
+9
View File
@@ -0,0 +1,9 @@
#ifndef _DTU_BOARD_H
#define _DTU_BOARD_H
typedef struct {
}
#endif
Board/pwm-board.c
+13 -13
View File
@@ -4,8 +4,8 @@
void PwmInfoInit()
{
GPIO_InitTypeDef GPIO_InitStruct;
MX_TIM2_PWMInit(5); // PA15
GPIO_InitTypeDef GPIO_InitStruct;
MX_TIM2_PWMInit (5); // PA15
// // __HAL_RCC_GPIOA_CLK_ENABLE();
// // __HAL_RCC_GPIOB_CLK_ENABLE();
@@ -16,7 +16,7 @@ void PwmInfoInit()
//// GPIO_InitStruct.Pin = GPIO_PIN_15;
//// HAL_GPIO_Init (GPIOA, &GPIO_InitStruct);
//// HAL_GPIO_WritePin(GPIOA,GPIO_PIN_15,GPIO_PIN_RESET);
//
//
// //TIM2-CH2 PB3 GPIO_AF2_TIM2
// GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
// GPIO_InitStruct.Pull = GPIO_PULLUP;
@@ -26,7 +26,7 @@ void PwmInfoInit()
// GPIO_InitStruct.Pin = GPIO_PIN_3;
// HAL_GPIO_Init (GPIOB, &GPIO_InitStruct);
// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_SET);
//
//
// //TIM2-CH3 PB10 GPIO_AF2_TIM2
// GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
// GPIO_InitStruct.Pull = GPIO_PULLUP;
@@ -45,11 +45,11 @@ void PwmInfoInit()
// GPIO_InitStruct.Pin = GPIO_PIN_11;
// HAL_GPIO_Init (GPIOB, &GPIO_InitStruct);
// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_11,GPIO_PIN_SET);
//
//
//// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET);
//// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_10,GPIO_PIN_RESET);
//// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_11,GPIO_PIN_RESET);
////
////
//// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_SET);
//// HAL_Delay(10);
//// HAL_GPIO_WritePin(GPIOB,GPIO_PIN_10,GPIO_PIN_SET);
@@ -60,20 +60,20 @@ void PwmInfoInit()
// //PwmInfoStart(2);
// //PwmInfoStart(3);
// //PwmInfoStart(4);
PwmInfoSetDuty(1,100) ;// 全部默认100 占空比
PwmInfoSetDuty(2,100) ;// 全部默认100 占空比
PwmInfoSetDuty(3,100) ;// 全部默认100 占空比
PwmInfoSetDuty(4,100) ;// 全部默认100 占空比
PwmInfoSetDuty (1, 100) ; // 全部默认100 占空比
PwmInfoSetDuty (2, 100) ; // 全部默认100 占空比
PwmInfoSetDuty (3, 100) ; // 全部默认100 占空比
PwmInfoSetDuty (4, 100) ; // 全部默认100 占空比
}
// 占空比
void PwmInfoSetDuty(int index,int duty)
void PwmInfoSetDuty (int index, int duty)
{
MX_TIM2_PWMStart(index,duty);
MX_TIM2_PWMStart (index, duty);
}
//void PwmInfoStop(int index)
//{
// MX_TIM2_PWMStop(index);
// MX_TIM2_PWMStop(index);
//}
Board/pwm-board.h
+4 -4
View File
@@ -8,12 +8,12 @@
#define PWM_DIO 0//设置为普通IO空输出
#define PWM_PWM 1//设置为PWM输出
void PwmInfoInit(void);
void PwmInfoSetDuty(int index,int duty);
void PwmInfoStop(int index) ;
void PwmInfoInit (void);
void PwmInfoSetDuty (int index, int duty);
void PwmInfoStop (int index) ;
#endif
#endif
Board/relay-board.c
+18 -17
View File
@@ -2,9 +2,10 @@
RelayInfo_t RelayInfo = {
{GPIOB, GPIO_PIN_8, GPIO_MODE_OUTPUT_PP,GPIO_PULLUP, GPIO_SPEED_FREQ_VERY_HIGH, NULL}, //PB5
{GPIOB, GPIO_PIN_9, GPIO_MODE_OUTPUT_PP,GPIO_PULLUP, GPIO_SPEED_FREQ_VERY_HIGH, NULL}, //PB5
RelayInfo_t RelayInfo =
{
{GPIOB, GPIO_PIN_8, GPIO_MODE_OUTPUT_PP, GPIO_PULLUP, GPIO_SPEED_FREQ_VERY_HIGH, NULL}, //PB5
{GPIOB, GPIO_PIN_9, GPIO_MODE_OUTPUT_PP, GPIO_PULLUP, GPIO_SPEED_FREQ_VERY_HIGH, NULL}, //PB5
};
/********************************************
函数名称：UartInfoInit
@@ -12,42 +13,42 @@ RelayInfo_t RelayInfo = {
输出参数：NULL
功能描述：初始化一个串口
********************************************/
void RelayInfoInit(void)
void RelayInfoInit (void)
{
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Mode = RelayInfo.Relay1.mode;
GPIO_InitStruct.Pull = RelayInfo.Relay1.Pull;
GPIO_InitStruct.Speed = RelayInfo.Relay1.Speed;
GPIO_InitStruct.Pin = RelayInfo.Relay1.pin;
HAL_GPIO_Init (RelayInfo.Relay1.GPIOx, &GPIO_InitStruct);
HAL_GPIO_WritePin(RelayInfo.Relay1.GPIOx,RelayInfo.Relay1.pin,GPIO_PIN_RESET);
HAL_GPIO_WritePin (RelayInfo.Relay1.GPIOx, RelayInfo.Relay1.pin, GPIO_PIN_RESET);
GPIO_InitStruct.Mode = RelayInfo.Relay2.mode;
GPIO_InitStruct.Pull = RelayInfo.Relay2.Pull;
GPIO_InitStruct.Speed = RelayInfo.Relay2.Speed;
GPIO_InitStruct.Pin = RelayInfo.Relay2.pin;
HAL_GPIO_Init (RelayInfo.Relay2.GPIOx, &GPIO_InitStruct);
HAL_GPIO_WritePin(RelayInfo.Relay2.GPIOx,RelayInfo.Relay2.pin,GPIO_PIN_RESET);
HAL_GPIO_WritePin (RelayInfo.Relay2.GPIOx, RelayInfo.Relay2.pin, GPIO_PIN_RESET);
}
void RelayOpenDoor(void)
void RelayOpenDoor (void)
{
HAL_GPIO_WritePin(RelayInfo.Relay1.GPIOx,RelayInfo.Relay1.pin,GPIO_PIN_SET);
HAL_GPIO_WritePin (RelayInfo.Relay1.GPIOx, RelayInfo.Relay1.pin, GPIO_PIN_SET);
}
void RelayCloseDoor(void)
void RelayCloseDoor (void)
{
HAL_GPIO_WritePin(RelayInfo.Relay1.GPIOx,RelayInfo.Relay1.pin,GPIO_PIN_RESET);
HAL_GPIO_WritePin (RelayInfo.Relay1.GPIOx, RelayInfo.Relay1.pin, GPIO_PIN_RESET);
}
void RelayOpenK2(void)
void RelayOpenK2 (void)
{
HAL_GPIO_WritePin(RelayInfo.Relay2.GPIOx,RelayInfo.Relay2.pin,GPIO_PIN_SET);
HAL_GPIO_WritePin (RelayInfo.Relay2.GPIOx, RelayInfo.Relay2.pin, GPIO_PIN_SET);
}
void RelayCloseK2(void)
void RelayCloseK2 (void)
{
HAL_GPIO_WritePin(RelayInfo.Relay2.GPIOx,RelayInfo.Relay2.pin,GPIO_PIN_RESET);
HAL_GPIO_WritePin (RelayInfo.Relay2.GPIOx, RelayInfo.Relay2.pin, GPIO_PIN_RESET);
}
Board/relay-board.h
+7 -7
View File
@@ -11,15 +11,15 @@ typedef struct RelayInfo_t
GpioInfo_t Relay1; // 用于控制485的收发
GpioInfo_t Relay2; // 用于控制485的收发
}RelayInfo_t;
} RelayInfo_t;
void RelayInfoInit(void);
void RelayOpenDoor(void);
void RelayCloseDoor(void);
void RelayOpenK2(void);
void RelayCloseK2(void);
void RelayInfoInit (void);
void RelayOpenDoor (void);
void RelayCloseDoor (void);
void RelayOpenK2 (void);
void RelayCloseK2 (void);
#endif
#endif
Board/usart-board.c
+485 -44
View File
@@ -1,14 +1,148 @@
#include "usart-board.h"
#include "usart.h"
#define UART_LPUART1_BUFF_SIZE 256 // 4853
#define UART_LPUART2_BUFF_SIZE 2400 // gsm
#define UART_UART1_BUFF_SIZE 256 // 4852
#define UART_UART2_BUFF_SIZE 2048 // debbug
#define UART_UART3_BUFF_SIZE 256 // 4852
#define UART_UART4_BUFF_SIZE 2400 // eth1
#define UART_UART5_BUFF_SIZE 256 // 4851
#define UART_UART6_BUFF_SIZE 256 // view
static char s_lpuart1_buff[UART_LPUART1_BUFF_SIZE];
static char s_lpuart2_buff[UART_LPUART2_BUFF_SIZE];
static char s_uart1_buff[UART_UART1_BUFF_SIZE];
static char s_uart2_buff[UART_UART2_BUFF_SIZE];
static char s_uart3_buff[UART_UART3_BUFF_SIZE];
static char s_uart4_buff[UART_UART4_BUFF_SIZE];
static char s_uart5_buff[UART_UART5_BUFF_SIZE];
static char s_uart6_buff[UART_UART6_BUFF_SIZE];
extern UART_HandleTypeDef hlpuart1;
extern UART_HandleTypeDef hlpuart2;
extern UART_HandleTypeDef huart1;
extern UART_HandleTypeDef huart2;
extern UART_HandleTypeDef huart3;
extern UART_HandleTypeDef huart4;
extern UART_HandleTypeDef huart5;
extern UART_HandleTypeDef huart6;
UartDrv_t g_DebugDrv = { G0_UART2, 115200, PARITY_DATA_8N1, s_uart2_buff, 0, NULL, 0 }; // 调试串口驱动
UartDrv_t g_U4851Drv = { G0_UART5, 115200, PARITY_DATA_8N1, s_uart5_buff, 0, NULL, 0 }; // 4851 驱动
UartDrv_t g_U4852Drv = { G0_UART3, 115200, PARITY_DATA_8N1, s_uart3_buff, 0, NULL, 0 }; // 4852 驱动
UartDrv_t g_U4853Drv = { G0_UART1, 115200, PARITY_DATA_8N1, s_uart1_buff, 0, NULL, 0 }; // 4853 驱动
UartDrv_t g_ViewDrv = { G0_UART6, 115200, PARITY_DATA_8N1, s_uart6_buff, 0, NULL, 0 }; // view 驱动
UartDrv_t g_ETH1Drv = { G0_UART4, 115200, PARITY_DATA_8N1, s_uart4_buff, 0, NULL, 0 }; // 以太网通道1 驱动
UartDrv_t g_ETH2Drv = { G0_LPUART1, 115200, PARITY_DATA_8N1, s_lpuart1_buff, 0, NULL, 0 }; // 以太网通道2 驱动
UartDrv_t g_GSMDrv = { G0_LPUART2, 115200, PARITY_DATA_8N1, s_lpuart2_buff, 0, NULL, 0 }; // 4G模块 驱动
UartDrv_t g_LoRaDrv = { G0_UART3, 115200, PARITY_DATA_8N1, s_uart3_buff, 0, NULL, 0 }; // LoRa 模块驱动
void MX_UART_TickHandle (void)
{
// 调试串口
if (g_DebugDrv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_DebugDrv.rxdone != NULL)
{
g_DebugDrv.rxdone();// 接受回调函数处理
}
}
if (g_DebugDrv.rx_timer > 1)
g_DebugDrv.rx_timer--;
// 4851
if (g_U4851Drv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_U4851Drv.rxdone != NULL)
{
g_U4851Drv.rxdone();// 接受回调函数处理
}
}
if (g_U4851Drv.rx_timer > 1)
g_U4851Drv.rx_timer--;
// 4852
if (g_U4852Drv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_U4852Drv.rxdone != NULL)
{
g_U4852Drv.rxdone();// 接受回调函数处理
}
}
if (g_U4852Drv.rx_timer > 1)
g_U4852Drv.rx_timer--;
// 4853
if (g_U4853Drv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_U4853Drv.rxdone != NULL)
{
g_U4853Drv.rxdone();// 接受回调函数处理
}
}
if (g_U4853Drv.rx_timer > 1)
g_U4853Drv.rx_timer--;
// GSM
if (g_GSMDrv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_GSMDrv.rxdone != NULL)
{
g_GSMDrv.rxdone();// 接受回调函数处理
}
}
if (g_GSMDrv.rx_timer > 1)
g_GSMDrv.rx_timer--;
// ETH1
if (g_ETH1Drv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_ETH1Drv.rxdone != NULL)
{
g_ETH1Drv.rxdone();// 接受回调函数处理
}
}
if (g_ETH1Drv.rx_timer > 1)
g_ETH1Drv.rx_timer--;
// ETH2
if (g_ETH2Drv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_ETH2Drv.rxdone != NULL)
{
g_ETH2Drv.rxdone();// 接受回调函数处理
}
}
if (g_ETH2Drv.rx_timer > 1)
g_ETH2Drv.rx_timer--;
//VIEW
if (g_ViewDrv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_ViewDrv.rxdone != NULL)
{
g_ViewDrv.rxdone();// 接受回调函数处理
}
}
if (g_ViewDrv.rx_timer > 1)
g_ViewDrv.rx_timer--;
// LORA
if (g_LoRaDrv.rx_timer == 2) // 通过事件通知到业务app
{
if (g_LoRaDrv.rxdone != NULL)
{
g_LoRaDrv.rxdone();// 接受回调函数处理
}
}
if (g_LoRaDrv.rx_timer > 1)
g_LoRaDrv.rx_timer--;
}
UartDrv_t g_DebugDrv; // 调试串口驱动
UartDrv_t g_U4851Drv; // 4851 驱动
UartDrv_t g_U4852Drv; // 4852 驱动
UartDrv_t g_U4853Drv; // 4853 驱动
UartDrv_t g_ViewDrv; // View 驱动
UartDrv_t g_ETH1Drv; // 以太网通道1 驱动
UartDrv_t g_ETH2Drv; // 以太网通道1 驱动
UartDrv_t g_GSMDrv; // 以太网通道1 驱动
UartDrv_t g_LoRaDrv; // LoRa 模块驱动
/********************************************
函数名称：UartInfoInit
输入参数：串口句柄
@@ -17,46 +151,353 @@ UartDrv_t g_LoRaDrv; // LoRa ģ
********************************************/
void UartInfoInit()
void MX_UART_Init (UartDrv_t *drv)
{
}
void RelayInfoInit(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Mode = RelayInfo.Relay1.mode;
GPIO_InitStruct.Pull = RelayInfo.Relay1.Pull;
GPIO_InitStruct.Speed = RelayInfo.Relay1.Speed;
GPIO_InitStruct.Pin = RelayInfo.Relay1.pin;
HAL_GPIO_Init (RelayInfo.Relay1.GPIOx, &GPIO_InitStruct);
HAL_GPIO_WritePin(RelayInfo.Relay1.GPIOx,RelayInfo.Relay1.pin,GPIO_PIN_RESET);
GPIO_InitStruct.Mode = RelayInfo.Relay2.mode;
GPIO_InitStruct.Pull = RelayInfo.Relay2.Pull;
GPIO_InitStruct.Speed = RelayInfo.Relay2.Speed;
GPIO_InitStruct.Pin = RelayInfo.Relay2.pin;
HAL_GPIO_Init (RelayInfo.Relay2.GPIOx, &GPIO_InitStruct);
HAL_GPIO_WritePin(RelayInfo.Relay2.GPIOx,RelayInfo.Relay2.pin,GPIO_PIN_RESET);
}
void RelayOpenDoor(void)
{
HAL_GPIO_WritePin(RelayInfo.Relay1.GPIOx,RelayInfo.Relay1.pin,GPIO_PIN_SET);
}
void RelayCloseDoor(void)
{
HAL_GPIO_WritePin(RelayInfo.Relay1.GPIOx,RelayInfo.Relay1.pin,GPIO_PIN_RESET);
uint32_t Parity = NULL, WordLength = NULL;
// 检验位
if (drv->DataParity && PARITY_EVEN_MASK != 0)
{
Parity = UART_PARITY_EVEN;
}
else if (drv->DataParity && PARITY_ODD_MASK != 0)
{
Parity = UART_PARITY_ODD;
}
else
{
Parity = UART_PARITY_NONE;
}
// 数据位
if (drv->DataParity && DATA8_MASK != 0)
{
WordLength = UART_WORDLENGTH_7B;
}
else
{
WordLength = UART_WORDLENGTH_8B;
}
switch (drv->Id)
{
case G0_LPUART1: // ETH2
{
hlpuart1.Instance = LPUART1;
hlpuart1.Init.BaudRate = drv->BaudRate;
hlpuart1.Init.WordLength = WordLength;
hlpuart1.Init.Parity = Parity;
hlpuart1.Init.StopBits = UART_STOPBITS_1;
hlpuart1.Init.Mode = UART_MODE_TX_RX;
hlpuart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
hlpuart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
hlpuart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
hlpuart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
hlpuart1.FifoMode = UART_FIFOMODE_DISABLE;
if (HAL_UART_Init (&hlpuart1) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetTxFifoThreshold (&hlpuart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetRxFifoThreshold (&hlpuart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_DisableFifoMode (&hlpuart1) != HAL_OK)
{
Error_Handler();
}
__HAL_UART_ENABLE_IT (&hlpuart1, UART_IT_RXNE);
break;
}
case G0_LPUART2 : // GSM
hlpuart2.Instance = LPUART2;
hlpuart2.Init.BaudRate = drv->BaudRate;
hlpuart2.Init.WordLength = WordLength;
hlpuart2.Init.Parity = Parity;
hlpuart2.Init.StopBits = UART_STOPBITS_1;
hlpuart2.Init.Mode = UART_MODE_TX_RX;
hlpuart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
hlpuart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
hlpuart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
hlpuart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
hlpuart2.FifoMode = UART_FIFOMODE_DISABLE;
if (HAL_UART_Init (&hlpuart2) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetTxFifoThreshold (&hlpuart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetRxFifoThreshold (&hlpuart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_DisableFifoMode (&hlpuart2) != HAL_OK)
{
Error_Handler();
}
break;
case G0_UART1 : // 4853
huart1.Instance = USART1;
huart1.Init.BaudRate = drv->BaudRate;
huart1.Init.WordLength = WordLength;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = Parity;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init (&huart1) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetTxFifoThreshold (&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetRxFifoThreshold (&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_DisableFifoMode (&huart1) != HAL_OK)
{
Error_Handler();
}
break;
case G0_UART2: // debug
huart2.Instance = USART2;
huart2.Init.BaudRate = drv->BaudRate;
huart2.Init.WordLength = WordLength;
huart2.Init.StopBits = UART_STOPBITS_1;
huart2.Init.Parity = Parity;
huart2.Init.Mode = UART_MODE_TX_RX;
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart2.Init.OverSampling = UART_OVERSAMPLING_16;
huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
// 初始化串口
if (HAL_UART_Init (&huart2) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetTxFifoThreshold (&huart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetRxFifoThreshold (&huart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_DisableFifoMode (&huart2) != HAL_OK)
{
Error_Handler();
}
// 使能串口接受中断，用于接受数据
__HAL_UART_ENABLE_IT (&huart2, UART_IT_RXNE);
break;
case G0_UART3: // 4852
huart3.Instance = USART3;
huart3.Init.BaudRate = drv->BaudRate;
huart3.Init.WordLength = WordLength;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = Parity;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init (&huart3) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetTxFifoThreshold (&huart3, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_SetRxFifoThreshold (&huart3, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
{
Error_Handler();
}
if (HAL_UARTEx_DisableFifoMode (&huart3) != HAL_OK)
{
Error_Handler();
}
break;
case G0_UART4: // ETH1
huart4.Instance = USART4;
huart4.Init.BaudRate = drv->BaudRate;
huart4.Init.WordLength = WordLength;
huart4.Init.StopBits = UART_STOPBITS_1;
huart4.Init.Parity = Parity;
huart4.Init.Mode = UART_MODE_TX_RX;
huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart4.Init.OverSampling = UART_OVERSAMPLING_16;
huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init (&huart4) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART4_Init 2 */
__HAL_UART_ENABLE_IT (&huart4, UART_IT_RXNE);
break;
case G0_UART5: // 4851
huart5.Instance = USART5;
huart5.Init.BaudRate = drv->BaudRate;
huart5.Init.WordLength = WordLength;
huart5.Init.StopBits = UART_STOPBITS_1;
huart5.Init.Parity = Parity;
huart5.Init.Mode = UART_MODE_TX_RX;
huart5.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart5.Init.OverSampling = UART_OVERSAMPLING_16;
huart5.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart5.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart5.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init (&huart5) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART5_Init 2 */
__HAL_UART_ENABLE_IT (&huart5, UART_IT_RXNE);
break;
case G0_UART6: // View
huart6.Instance = USART6;
huart6.Init.BaudRate = drv->BaudRate;
huart6.Init.WordLength = WordLength;
huart6.Init.StopBits = UART_STOPBITS_1;
huart6.Init.Parity = Parity;
huart6.Init.Mode = UART_MODE_TX_RX;
huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart6.Init.OverSampling = UART_OVERSAMPLING_16;
huart6.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart6.Init.ClockPrescaler = UART_PRESCALER_DIV1;
huart6.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init (&huart6) != HAL_OK)
{
Error_Handler();
}
break;
default:
break;
}
}
void RelayOpenK2(void)
void MX_UART_IRQHandle (void)
{
HAL_GPIO_WritePin(RelayInfo.Relay2.GPIOx,RelayInfo.Relay2.pin,GPIO_PIN_SET);
uint8_t ret;
if (USART2->ISR & (1 << 5)) // 串口2
{
ret = USART2->RDR;
if( g_DebugDrv.rx_buffer != NULL)
{
g_DebugDrv.rx_buffer[g_DebugDrv.rx_size++] = ret;
g_DebugDrv.rx_timer = 30; // 30ms
if (g_DebugDrv.rx_size > UART_UART2_BUFF_SIZE)
g_DebugDrv.rx_size = 0;
}
}
if (USART4->ISR & (1 << 5))
{
ret = USART4->RDR;
if( g_ETH1Drv.rx_buffer != NULL)
{
g_ETH1Drv.rx_buffer[g_ETH1Drv.rx_size++] = ret;
g_ETH1Drv.rx_timer = 30; // 30ms
if (g_ETH1Drv.rx_size > UART_UART4_BUFF_SIZE)
g_ETH1Drv.rx_size = 0;
}
}
if (USART5->ISR & (1 << 5))
{
ret = USART5->RDR;
if( g_U4851Drv.rx_buffer != NULL)
{
g_U4851Drv.rx_buffer[g_U4851Drv.rx_size++] = ret;
g_U4851Drv.rx_timer = 30; // 30ms
if (g_U4851Drv.rx_size > UART_UART5_BUFF_SIZE)
g_U4851Drv.rx_size = 0;
}
}
if (LPUART1->ISR & (1 << 5))
{
ret = LPUART1->RDR;
if( g_ETH2Drv.rx_buffer != NULL)
{
g_ETH2Drv.rx_buffer[g_ETH2Drv.rx_size++] = ret;
g_ETH2Drv.rx_timer = 30; // 30ms
if (g_ETH2Drv.rx_size > UART_LPUART1_BUFF_SIZE)
g_ETH2Drv.rx_size = 0;
}
}
}
void RelayCloseK2(void)
void MX_UART_Clear (UartDrv_t * drv)
{
HAL_GPIO_WritePin(RelayInfo.Relay2.GPIOx,RelayInfo.Relay2.pin,GPIO_PIN_RESET);
drv->rx_size = 0;
drv->rx_timer = 0;
}
void MX_UART_PutChar (UartDrv_t * drv, char ch)
{
switch (drv->Id)
{
case G0_LPUART1:
HAL_UART_Transmit (&hlpuart1, (uint8_t *) &ch, 1, 1000);
break;
case G0_LPUART2:
HAL_UART_Transmit (&hlpuart2, (uint8_t *) &ch, 1, 1000);
break;
case G0_UART1:
HAL_UART_Transmit (&huart1, (uint8_t *) &ch, 1, 1000);
break;
case G0_UART2:
HAL_UART_Transmit (&huart2, (uint8_t *) &ch, 1, 1000);
break;
case G0_UART3:
HAL_UART_Transmit (&huart3, (uint8_t *) &ch, 1, 1000);
break;
case G0_UART4:
HAL_UART_Transmit (&huart4, (uint8_t *) &ch, 1, 1000);
break;
case G0_UART5:
HAL_UART_Transmit (&huart5, (uint8_t *) &ch, 1, 1000);
break;
case G0_UART6:
HAL_UART_Transmit (&huart6, (uint8_t *) &ch, 1, 1000);
break;
default:
break;
}
}
void MX_UART_PutBuffer (UartDrv_t * drv, char *buff, int size)
{
for (int i = 0; i < size; i++)
{
MX_UART_PutChar (drv, buff[i]);
}
}
#include <stdarg.h>
#include <stdio.h>
// 重定义fputc函数
int fputc (int ch, FILE *f)
{
HAL_UART_Transmit (&huart2, (uint8_t *) &ch, 1, 2000);
return ch;
}
Board/usart-board.h
+54 -24
View File
@@ -2,43 +2,73 @@
#define _UART_BOARD_H
#include <stdint.h>
typedef enum UartId_t
{
LpUart1,
LpUart2,
Uart1,
Uart2,
Uart3,
Uart4,
Uart5,
Uart6,
}UartId_t;
G0_LPUART1,
G0_LPUART2,
G0_UART1,
G0_UART2,
G0_UART3,
G0_UART4,
G0_UART5,
G0_UART6,
G0_UARTM
} UartId_t;
typedef enum UartPara_t{
_8N1,
_8E1,
_8O1,
_7O1,
_7E1,
_7N1,
}UartPara_t;
#define PARITY_EVEN_MASK 0X02
#define PARITY_ODD_MASK 0x04
#define PARITY_NONE_MASK 0x00
#define DATA8_MASK 0X00
#define DATA7_MASK 0X01
typedef struct UartDrv_t
#define PARITY_DATA_8N1 (DATA8_MASK | PARITY_NONE_MASK) // 00H
#define PARITY_DATA_7N1 (DATA7_MASK | PARITY_NONE_MASK) // 01H
#define PARITY_DATA_8E1 (DATA8_MASK | PARITY_EVEN_MASK) // 02H
#define PARITY_DATA_7E1 (DATA7_MASK | PARITY_EVEN_MASK) // 03H
#define PARITY_DATA_8O1 (DATA8_MASK | PARITY_ODD_MASK) // 04H
#define PARITY_DATA_7O1 (DATA7_MASK | PARITY_ODD_MASK) // 05H
typedef struct UartDrv_t
{
UartId_t Id;// 串口号
uint32_t BaudRate;// 波特率
UartPara_t Para; // 数据位
uint32_t DataParity; // 数据位
char * rx_buffer;
uint16_t rx_size;
uint32_t rx_ready;// 接受完成等待处理
}UartDrv_t;
void (*rxdone) (void); // 接受完成回调函数
uint32_t rx_timer;
} UartDrv_t;
extern UartDrv_t g_DebugDrv ;
extern UartDrv_t g_U4851Drv ;
extern UartDrv_t g_U4852Drv ;
extern UartDrv_t g_U4853Drv ;
extern UartDrv_t g_ViewDrv ;
extern UartDrv_t g_ETH1Drv ;
extern UartDrv_t g_ETH2Drv ;
extern UartDrv_t g_GSMDrv ;
extern UartDrv_t g_LoRaDrv ;
#endif
// function
extern void MX_UART_TickHandle (void);
extern void MX_UART_Init (UartDrv_t *drv);
extern void MX_UART_IRQHandle (void);
extern void MX_UART_Clear (UartDrv_t * drv);
extern void MX_UART_PutChar (UartDrv_t * drv, char ch);
extern void MX_UART_PutBuffer (UartDrv_t * drv, char *buff, int size);
#endif