#include "stm32h7xx_hal.h"
#include "usart.h"
#include "usart7.h"
#include "CRC16.h"
#include "delay.h"
#include "timer123.h"
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
// 全局变量定义(串口1相关)
UART_HandleTypeDef UartHandle;
uint8_t ucTemp;
extern uint8_t Rxflag;
uart1_def rschuanko_1;
uint16_t byte_tmp[2];
uint8_t huichuan_buff[]={0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,
0x00
};
// 全局变量定义(4G模块相关)
int qi_ti_in[10]={0x00};
uint16_t zhuanhuan;
uint8_t a=0;
uint8_t ucTemp8;
UART_HandleTypeDef UartHandle8;
uart8_def rschuanko_8;
uint16_t byte_tmp8[2];
extern uint8_t Rxflag8;
uint8_t usRxCount8;
uint8_t ucaRxBuf8[13];
uint8_t chuanko8jiesho[2];
// 4G模块控制相关定义
#define EC20_UART &UartHandle8 // EC20模块使用UART8通信
#define DEBUG_UART &UartHandle // 调试串口改为串口1
#define APN "CMIOT" // 物联网卡APN
#define MQTT_BROKER "tcp://118.190.157.186:61613" // MQTT服务器地址
#define MQTT_TOPIC "A/XZRS/0/1705001" // MQTT主题
#define MQTT_USER "system" // MQTT用户名
#define MQTT_PWD "jsjc@2025" // MQTT密码
// 数据上报JSON模板
const char *mqtt_payload = "{\n"
"sensorDatas:\n"
" [\n"
" { sensorsId: 141705001,value:'1111'},\n"
" ]\n"
"}\n";
// 函数声明
void DEBUG_USART_Config(void); // 串口1配置函数
void USART1_IRQHandler(void);
void rschuanko_1_uart1_tx(void);
void rschuanko1_uart1_rx_timer_handle(void);
void rschuanko_1_uart1_rx_handle(void);
void DEBUG_USART_Config8(void);
void UART8_IRQHandler(void);
void rschuanko8_uart8_rx_timer_handle(void);
void EC20_SendAT(const char *at_cmd, uint32_t timeout);
uint8_t EC20_WaitResponse(const char *response, uint32_t timeout);
void EC20_Init(void);
void MQTT_Connect(void);
void MQTT_Publish(const char *topic, const char *payload);
void Debug_Print(const char *fmt, ...);
// 串口1配置
void DEBUG_USART_Config(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
DEBUG_USART_RX_GPIO_CLK_ENABLE();
DEBUG_USART_TX_GPIO_CLK_ENABLE();
/* 配置串口1时钟源*/
RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1;
RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);
/* 使能串口1时钟 */
DEBUG_USART_CLK_ENABLE();
/* 配置Tx引脚为复用功能 */
GPIO_InitStruct.Pin = DEBUG_USART_TX_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = DEBUG_USART_TX_AF;
HAL_GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStruct);
/* 配置Rx引脚为复用功能 */
GPIO_InitStruct.Pin = DEBUG_USART_RX_PIN;
GPIO_InitStruct.Alternate = DEBUG_USART_RX_AF;
HAL_GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStruct);
/* 配置串口1模式 */
UartHandle.Instance = DEBUG_USART;
UartHandle.Init.BaudRate = 9600;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
UartHandle.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED;
UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&UartHandle);
HAL_UART_Receive_IT(&UartHandle,&ucTemp,1);
/*串口1中断初始化 */
HAL_NVIC_SetPriority(DEBUG_USART_IRQ, 2, 1);
HAL_NVIC_EnableIRQ(DEBUG_USART_IRQ);
}
// UART8配置
void DEBUG_USART_Config8(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_UART8_CLK_ENABLE();
// TX引脚配置 PE1
GPIO_InitStruct.Pin = GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_UART8;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
// RX引脚配置 PE0
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Alternate = GPIO_AF8_UART8;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
// UART参数配置
UartHandle8.Instance = UART8;
UartHandle8.Init.BaudRate = 9600;
UartHandle8.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle8.Init.StopBits = UART_STOPBITS_1;
UartHandle8.Init.Parity = UART_PARITY_NONE;
UartHandle8.Init.Mode = UART_MODE_TX_RX;
UartHandle8.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle8.Init.OverSampling = UART_OVERSAMPLING_16;
UartHandle8.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED;
UartHandle8.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&UartHandle8);
// 中断配置
HAL_UART_Receive_IT(&UartHandle8, &ucTemp8, 1);
HAL_NVIC_SetPriority(UART8_IRQn, 4, 1);
HAL_NVIC_EnableIRQ(UART8_IRQn);
}
// 串口1中断服务函数
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&UartHandle);
}
// UART8中断服务函数
void UART8_IRQHandler(void)
{
HAL_UART_IRQHandler(&UartHandle8);
}
// 串口接收回调函数(统一处理)
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == DEBUG_USART) // 串口1
{
rschuanko_1_uart1_tx();
}
else if(huart->Instance == UART8) // UART8
{
rschuanko_8.rx8_data[rschuanko_8.rx8_num++] = ucTemp8;
rschuanko_8.rx8_delay = 30;
if(rschuanko_8.rx8_num >= sizeof(rschuanko_8.rx8_data))
rschuanko_8.rx8_num = 0;
HAL_UART_Receive_IT(&UartHandle8, &ucTemp8, 1);
}
}
// 串口1数据处理函数
void rschuanko_1_uart1_tx(void)
{
if(rschuanko_1.rx_complete_flag==0)
{
if(rschuanko_1.rx_num<15)
{
rschuanko_1.rx_data[rschuanko_1.rx_num] = ucTemp;
rschuanko_1.rx_num++;
rschuanko_1.rx_delay = 20;
}
else
{
rschuanko_1.rx_complete_flag=1;
}
}
HAL_UART_Receive_IT(&UartHandle,&ucTemp,1);
}
// 串口1接收逻辑处理函数
void rschuanko_1_uart1_rx_handle(void)
{
if(rschuanko_1.rx_complete_flag)
{
if(rschuanko_1.rx_num ==15)
{
byte_tmp[0]=CRC16_Get((uint8_t *)rschuanko_1.rx_data,13);
byte_tmp[0]=byte_tmp[0]+0x31;
if((rschuanko_1.rx_data[14]==(byte_tmp[0]>>8))&&(rschuanko_1.rx_data[13]==(byte_tmp[0]&0x00ff)))
{
// 方法1:强制类型转换
memcpy(rschuanko_1.tx_data, (uint8_t*)rschuanko_1.rx_data, 13);
// 方法2(备选):逐字节复制
// for(int i=0; i<13; i++) {
// rschuanko_1.tx_data[i] = rschuanko_1.rx_data[i];
// }
buff[5]=1;
}
}
rschuanko_1.rx_complete_flag=0;
rschuanko_1.rx_num=0;
rschuanko_1.rx_delay =0;
}
}
// 串口1定时器处理函数(10ms周期)
void rschuanko1_uart1_rx_timer_handle(void)
{
if(rschuanko_1.rx_delay)
{
rschuanko_1.rx_delay--;
if(rschuanko_1.rx_delay==0)
{
rschuanko_1.rx_complete_flag=1;
}
}
}
// UART8定时器处理函数(10ms周期)
void rschuanko8_uart8_rx_timer_handle(void)
{
if(rschuanko_8.rx8_delay)
{
rschuanko_8.rx8_delay--;
if(rschuanko_8.rx8_delay == 0)
rschuanko_8.rx8_complete_flag = 1;
}
}
// 调试信息打印函数(串口1输出)
///重定向c库函数printf到串口DEBUG_USART,重定向后可使用printf函数
//int fputc(int ch, FILE *f)
//{
// /* 发送一个字节数据到串口DEBUG_USART */
// HAL_UART_Transmit(DEBUG_UART, (uint8_t *)&ch, 1, 1000);
//
// return (ch);
//}
void Debug_Print(const char *fmt, ...)
{
char buf[256];
va_list args;
va_start(args, fmt);
vsnprintf(buf, sizeof(buf), fmt, args);
va_end(args);
strcat(buf, "\r\n");
HAL_UART_Transmit(DEBUG_UART, (uint8_t*)buf, strlen(buf), 1000);
}
// 发送AT指令
void EC20_SendAT(const char *at_cmd, uint32_t timeout)
{
HAL_UART_Transmit(EC20_UART, (uint8_t*)at_cmd, strlen(at_cmd), timeout);
Debug_Print("fa song zhi ling: %s", at_cmd);
}
// 等待EC20响应
uint8_t EC20_WaitResponse(const char *response, uint32_t timeout)
{
uint32_t tickstart = HAL_GetTick();
while((HAL_GetTick() - tickstart) < timeout)
{
if(rschuanko_8.rx8_complete_flag)
{
rschuanko_8.rx8_data[rschuanko_8.rx8_num] = '\0';
Debug_Print("mo kuai xiang ying: %s", rschuanko_8.rx8_data);
if(strstr((char*)rschuanko_8.rx8_data, response) != NULL)
{
memset(rschuanko_8.rx8_data, 0, sizeof(rschuanko_8.rx8_data));
rschuanko_8.rx8_num = 0;
rschuanko_8.rx8_complete_flag = 0;
return 1;
}
memset(rschuanko_8.rx8_data, 0, sizeof(rschuanko_8.rx8_data));
rschuanko_8.rx8_num = 0;
rschuanko_8.rx8_complete_flag = 0;
}
}
return 0;
}
// EC20模块初始化
void EC20_Init(void)
{
Debug_Print("kai shi chu shi hua...");
EC20_SendAT("AT\r\n", 1000);
if(!EC20_WaitResponse("OK", 2000))
{
Debug_Print("模块未响应AT指令!");
return;
}
char apn_cmd[32];
sprintf(apn_cmd, "AT+CGDCONT=1,\"IP\",\"%s\"\r\n", APN);
EC20_SendAT(apn_cmd, 1000);
if(!EC20_WaitResponse("OK", 2000))
{
Debug_Print("设置APN失败!");
return;
}
EC20_SendAT("AT+CGACT=1,1\r\n", 1000);
if(!EC20_WaitResponse("OK", 5000))
{
Debug_Print("激活PDP失败!");
return;
}
EC20_SendAT("AT+CREG?\r\n", 1000);
if(EC20_WaitResponse("0,1", 2000) || EC20_WaitResponse("0,5", 2000))
{
Debug_Print("网络注册成功!");
}
else
{
Debug_Print("网络注册失败!");
return;
}
Debug_Print("EC20模块初始化完成!");
}
// MQTT连接配置
void MQTT_Connect(void)
{
Debug_Print("开始连接MQTT服务器...");
char mqtt_server[64];
sprintf(mqtt_server, "AT+QMTCFG=\"broker\",0,\"%s\"\r\n", MQTT_BROKER);
EC20_SendAT(mqtt_server, 1000);
if(!EC20_WaitResponse("OK", 3000))
{
Debug_Print("设置MQTT服务器失败!");
return;
}
char mqtt_auth[64];
sprintf(mqtt_auth, "AT+QMTCFG=\"auth\",0,\"%s\",\"%s\"\r\n", MQTT_USER, MQTT_PWD);
EC20_SendAT(mqtt_auth, 1000);
if(!EC20_WaitResponse("OK", 3000))
{
Debug_Print("设置MQTT认证失败!");
return;
}
EC20_SendAT("AT+QMTOPEN=0\r\n", 1000);
if(!EC20_WaitResponse("+QMTOPEN: 0,0", 10000))
{
Debug_Print("MQTT连接失败!");
return;
}
EC20_SendAT("AT+QMTCONN=0,\"STM32_EC20_Client\"\r\n", 1000);
if(!EC20_WaitResponse("+QMTCONN: 0,0,0", 5000))
{
Debug_Print("MQTT客户端连接失败!");
return;
}
Debug_Print("MQTT服务器连接成功!");
}
// MQTT发布消息
void MQTT_Publish(const char *topic, const char *payload)
{
Debug_Print("发布MQTT消息...");
char publish_cmd[1024];
// 补充payload参数,格式为:AT+QMTPUB=0,0,0,主题长度,"主题","消息内容"\r\n
// 注意:主题长度可以用strlen(topic)获取
sprintf(publish_cmd, "AT+QMTPUB=0,0,0,%d,\"%s\",\"%s\"\r\n",
strlen(topic), // 主题长度
topic, // 第一个参数:主题
payload); // 第二个参数:消息内容
EC20_SendAT(publish_cmd, 1000);
if(EC20_WaitResponse(">", 2000))
{
HAL_UART_Transmit(EC20_UART, (uint8_t*)payload, strlen(payload), 5000);
HAL_UART_Transmit(EC20_UART, (uint8_t*)"\x1A", 1, 1000);
if(EC20_WaitResponse("+QMTPUB: 0,0,0", 5000))
{
Debug_Print("MQTT消息发布成功!");
}
else
{
Debug_Print("MQTT消息发布失败!");
}
}
}
//// 系统时钟配置函数
//void SystemClock_Config(void)
//{
// RCC_OscInitTypeDef RCC_OscInitStruct = {0};
// RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
// __HAL_RCC_PWR_CLK_ENABLE();
// __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
// RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
// RCC_OscInitStruct.HSEState = RCC_HSE_ON;
// RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
// RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
// RCC_OscInitStruct.PLL.PLLM = 25;
// RCC_OscInitStruct.PLL.PLLN = 400;
// RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
// RCC_OscInitStruct.PLL.PLLQ = 8;
// if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
// {
// Error_Handler();
// }
// RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
// |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
// RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
// RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
// RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
// RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
// if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
// {
// Error_Handler();
// }
//}
//// 错误处理函数
//void Error_Handler(void)
//{
// while(1)
// {
// HAL_Delay(500);
// }
//}
// 主函数
int main(void)
{
HAL_Init(); //初始化HAL库
Stm32_Clock_Init(); //设置时钟,400Mhz
// Stm32_Clock_Init(160,5,2,4); //设置时钟,400Mhz
delay_init(400);//延时初始化
// 初始化串口1(调试用)和UART8(EC20模块)
DEBUG_USART_Config();
DEBUG_USART_Config8();
// 定时器初始化(10ms中断)
timx_int_init123(50 - 1, 200- 1);
// 初始化变量
memset(&rschuanko_1, 0, sizeof(rschuanko_1));
memset(&rschuanko_8, 0, sizeof(rschuanko_8));
// printf("系统启动成功!");
// EC20模块初始化
EC20_Init();
// 连接MQTT服务器
MQTT_Connect();
// 主循环
while(1)
{
// 处理串口1接收数据
rschuanko_1_uart1_rx_handle();
// 每隔10秒发布MQTT消息
MQTT_Publish(MQTT_TOPIC, mqtt_payload);
HAL_Delay(10000);
}
}
//#ifdef USE_FULL_ASSERT
//void assert_failed(uint8_t *file, uint32_t line)
//{
//}
//#endif上面的错误调试信息一个字都没有在串口调试工具上显示,帮我修改一下,看是哪里的问题,串口一数据回显没有问题,不用printf,只用Debug_Print函数