代码收藏家 STM32 WIFI实现阿里云MQTT远程控制温湿度和继电器
一、功能描述
1.实现了温湿度采集、按键读取、控制继电器、蜂鸣器等功能
2.实现了串口上位机使用AT指令配置esp8266模块
3.实现了stm32单片机通过esp8266模块阿里云无线远程通信的功能
4.实现了温湿度阈值报警、继电器开关等逻辑功能
二、AT指令与阿里云
AT+RST //复位
AT+CWMODE=1 //SA模式
AT+CIPSNTPCFG=1,8,"ntp1.aliyun.com" //连接阿里云
AT+CWJAP="Mi11Ultra","/" //连接WiFi（是密码）不能使用5G频段
AT+MQTTUSERCFG=0,1,"NULL","ESP8266&k0p98TFTk3H","d34f56264dc58877374236dd9aed118d71a5b2c1348eec80ebd2c2c3e15c3bc6",0,0,"" //设置MQTT参数
AT+MQTTCLIENTID=0,"k0p98TFTk3H.ESP8266|securemode=2\,signmethod=hmacsha256\,timestamp=1703866363540|" //设置MQTT参数
AT+MQTTCONN=0,"iot-06z00f3sll2j0br.mqtt.iothub.aliyuncs.com",1883,1 //设置MQTT参数
AT+MQTTSUB=0,"/sys/k0p98TFTk3H/ESP8266/thing/service/property/set",1 //订阅
AT+MQTTPUB=0,"/sys/k0p98TFTk3H/ESP8266/thing/event/property/post","{\"temp\":50.5}",1,0 //发布
阿里云物联网产品
三、硬件部分
1.原理图
供电使用接线端子BAT，6-12V，接入一路稳5V的ams1117，再接一路稳3.3V的ams1117。5V电源给stm32最小系统板上的5V转3.3V稳压使用，也给串口、继电器供电使用以及拓展的5V供电排针使用。3.3V给其他相关外设使用，以及拓展的3.3V供电排针使用。ss54二极管用于电源防反接。
2.PCB图
外设不多，且使用最小系统板，只需放置排母即可，布局走线很简单。要注意的是背面切割尽量减少，两层板尽量保证背面GND网络的完整性，给顶层信号提供参考地。电源线加粗，干路电源线相比支路电源线也要加粗处理。LDO部分滤波电容不要外挂，输入要先经过电容再进芯片，输出先经过电容再给其他外设供电。
3.实物图
四、软件部分
1.主函数main
int main ( void )
{
uint8_t numdebugrx;
uint8_t num8266rx;
DHT11_Init();
USART1_Config (); //初始化串口1
CPU_TS_TmrInit(); //初始化DWT计数器，用于延时函数
LED_GPIO_Config(); //初始化 LED 灯
ESP8266_Init (); //初始化WiFi模块使用的接口和外设
OLED_Init(); //初始化OLED
//macESP8266_Usart ( "%s\r\n", "AABC" );
OLED_ShowString(1, 3, "ESP8266TEST");
macESP8266_CH_ENABLE(); //使能 ESP8266
Beep_OFF;
ESP8266_AT_Test(); //开启AT测试
DHT11_Data_TypeDef sensorData; //温湿度数据结构体变量
DHT11_Read_TempAndHumidity(&sensorData); //读取温湿度
printf("Humidity: %d.%d%%\n", sensorData.humi_int, sensorData.humi_deci);
printf("Temperature: %d.%d°C\n", sensorData.temp_int, sensorData.temp_deci);
printf("Checksum: %d\n", sensorData.check_sum);
while ( 1 )
{
DHT11_Data_TypeDef sensorData;
DHT11_Read_TempAndHumidity(&sensorData);
OLED_ShowNum(2, 4, strUSART_Fram_Record .InfBit .FramLength,3);
OLED_ShowNum(4, 4, strEsp8266_Fram_Record .InfBit .FramLength,3);
OLED_ShowNum(2,12,num8266rx,4);
OLED_ShowNum(4,12,numdebugrx,4);
OLED_ShowString(3,2,"W:");
OLED_ShowString(3,10,"S:");
OLED_ShowString(3,6,".");
OLED_ShowString(3,14,".");
OLED_ShowNum(3,4,sensorData.temp_int,2);
OLED_ShowNum(3,12,sensorData.humi_int,2);
OLED_ShowNum(3,7,sensorData.temp_deci,2);
OLED_ShowNum(3,15,sensorData.humi_deci,2);
if(sensorData.temp_int > 20) //蜂鸣器报警
{
Beep_ON;
}
else
{
Beep_OFF;
}
if(strUSART_Fram_Record .InfBit .FramFinishFlag == 1) //如果接收到了串口调试助手的数据
{
strUSART_Fram_Record .Data_RX_BUF[strUSART_Fram_Record .InfBit .FramLength] = '\0';
numdebugrx ++;
Usart_SendString(macESP8266_USARTx ,strUSART_Fram_Record .Data_RX_BUF); //数据从串口调试助手转发到ESP8266
strUSART_Fram_Record .InfBit .FramLength = 0; //接收数据长度置零
strUSART_Fram_Record .InfBit .FramFinishFlag = 0; //接收标志置零
}
if(strEsp8266_Fram_Record .InfBit .FramFinishFlag) //如果接收到了ESP8266的数据
{
strEsp8266_Fram_Record .Data_RX_BUF[strEsp8266_Fram_Record .InfBit .FramLength] = '\0';
num8266rx ++;
Usart_SendString(DEBUG_USARTx ,strEsp8266_Fram_Record .Data_RX_BUF); //数据从ESP8266转发到串口调试助手
if(strstr((const char*)strEsp8266_Fram_Record .Data_RX_BUF,"on"))
{
OLED_ShowString(4,8,"on");
LED2_OFF;
}
if(strstr((const char*)strEsp8266_Fram_Record .Data_RX_BUF,"off"))
{
OLED_ShowString(4,8,"off");
LED2_ON;
}
strEsp8266_Fram_Record .InfBit .FramLength = 0; //接收数据长度置零
strEsp8266_Fram_Record.InfBit.FramFinishFlag = 0; //接收标志置零
}
}
}
2.串口1配置函数（用于上位机debug）
#include "bsp_usart1.h"
/**
* @brief 配置嵌套向量中断控制器NVIC
* @param 无
* @retval 无
*/
static void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* 嵌套向量中断控制器组选择 */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
/* 配置USART为中断源 */
NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART_IRQ;
/* 抢断优先级*/
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
/* 子优先级 */
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
/* 使能中断 */
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
/* 初始化配置NVIC */
NVIC_Init(&NVIC_InitStructure);
}
/**
* @brief USART GPIO 配置,工作参数配置
* @param 无
* @retval 无
*/
void USART1_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
// 打开串口GPIO的时钟
DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
// 打开串口外设的时钟
DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
// 将USART Tx的GPIO配置为推挽复用模式
GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
// 将USART Rx的GPIO配置为浮空输入模式
GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
// 配置串口的工作参数
// 配置波特率
USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
// 配置 针数据字长
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
// 配置停止位
USART_InitStructure.USART_StopBits = USART_StopBits_1;
// 配置校验位
USART_InitStructure.USART_Parity = USART_Parity_No ;
// 配置硬件流控制
USART_InitStructure.USART_HardwareFlowControl =
USART_HardwareFlowControl_None;
// 配置工作模式，收发一起
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
// 完成串口的初始化配置
USART_Init(DEBUG_USARTx, &USART_InitStructure);
// 串口中断优先级配置
NVIC_Configuration();
// 使能串口接收中断
USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);
USART_ITConfig ( DEBUG_USARTx, USART_IT_IDLE, ENABLE ); //使能串口总线空闲中断
// 使能串口
USART_Cmd(DEBUG_USARTx, ENABLE);
}
/***************** 发送一个字符 **********************/
void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t ch)
{
/* 发送一个字节数据到USART */
USART_SendData(pUSARTx,ch);
/* 等待发送数据寄存器为空 */
while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}
/***************** 发送字符串 **********************/
void Usart_SendString( USART_TypeDef * pUSARTx, char *str)
{
unsigned int k=0;
do
{
Usart_SendByte( pUSARTx, *(str + k) );
k++;
} while(*(str + k)!='\0');
/* 等待发送完成 */
while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
{}
}
/***************** 发送一个16位数 **********************/
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)
{
uint8_t temp_h, temp_l;
/* 取出高八位 */
temp_h = (ch&0XFF00)>>8;
/* 取出低八位 */
temp_l = ch&0XFF;
/* 发送高八位 */
USART_SendData(pUSARTx,temp_h);
while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
/* 发送低八位 */
USART_SendData(pUSARTx,temp_l);
while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}
///重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
/* 发送一个字节数据到串口 */
USART_SendData(DEBUG_USARTx, (uint8_t) ch);
/* 等待发送完毕 */
while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
return (ch);
}
///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{
/* 等待串口输入数据 */
while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);
return (int)USART_ReceiveData(DEBUG_USARTx);
}
3.ESP8266配置函数（串口、复位、使能、IO）
u16 USART_RX_STA=0;
u8 USART_RX_BUF[USART_REC_LEN];
static void ESP8266_GPIO_Config ( void );
static void ESP8266_USART_Config ( void );
static void ESP8266_USART_NVIC_Configuration ( void );
struct STRUCT_USARTx_Fram strEsp8266_Fram_Record = { 0 };
struct STRUCT_USARTx_Fram strUSART_Fram_Record = { 0 };
/**
* @brief ESP8266初始化函数
* @param 无
* @retval 无
*/
void ESP8266_Init ( void )
{
ESP8266_GPIO_Config ();
ESP8266_USART_Config ();
macESP8266_RST_HIGH_LEVEL();
macESP8266_CH_DISABLE();
macESP8266_IO0_HIGH_LEVEL();
}
/**
* @brief 初始化ESP8266用到的GPIO引脚
* @param 无
* @retval 无
*/
static void ESP8266_GPIO_Config ( void )
{
/*定义一个GPIO_InitTypeDef类型的结构体*/
GPIO_InitTypeDef GPIO_InitStructure;
/* 配置 CH_PD 引脚*/
macESP8266_CH_PD_APBxClock_FUN ( macESP8266_CH_PD_CLK, ENABLE );
GPIO_InitStructure.GPIO_Pin = macESP8266_CH_PD_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init ( macESP8266_CH_PD_PORT, & GPIO_InitStructure );
/* 配置 IO0 引脚*/
macESP8266_IO0_APBxClock_FUN ( macESP8266_IO0_CLK, ENABLE );
GPIO_InitStructure.GPIO_Pin = macESP8266_IO0_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init ( macESP8266_IO0_PORT, & GPIO_InitStructure );
/* 配置 RST 引脚*/
macESP8266_RST_APBxClock_FUN ( macESP8266_RST_CLK, ENABLE );
GPIO_InitStructure.GPIO_Pin = macESP8266_RST_PIN;
GPIO_Init ( macESP8266_RST_PORT, & GPIO_InitStructure );
}
/**
* @brief 初始化ESP8266用到的 USART
* @param 无
* @retval 无
*/
static void ESP8266_USART_Config ( void )
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
/* config USART clock */
macESP8266_USART_APBxClock_FUN ( macESP8266_USART_CLK, ENABLE );
macESP8266_USART_GPIO_APBxClock_FUN ( macESP8266_USART_GPIO_CLK, ENABLE );
/* USART GPIO config */
/* Configure USART Tx as alternate function push-pull */
GPIO_InitStructure.GPIO_Pin = macESP8266_USART_TX_PIN;//A3
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(macESP8266_USART_TX_PORT, &GPIO_InitStructure);
/* Configure USART Rx as input floating */
GPIO_InitStructure.GPIO_Pin = macESP8266_USART_RX_PIN; //A2
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(macESP8266_USART_RX_PORT, &GPIO_InitStructure);
/* USART1 mode config */
USART_InitStructure.USART_BaudRate = macESP8266_USART_BAUD_RATE;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No ;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(macESP8266_USARTx, &USART_InitStructure);
/* 中断配置 */
USART_ITConfig ( macESP8266_USARTx, USART_IT_RXNE, ENABLE ); //使能串口接收中断
USART_ITConfig ( macESP8266_USARTx, USART_IT_IDLE, ENABLE ); //使能串口总线空闲中断
ESP8266_USART_NVIC_Configuration ();
USART_Cmd(macESP8266_USARTx, ENABLE);
}
void USART_ESP8266_IRQHandler(void) //ESP8266串口中断服务程序 接收
{
u8 Res;
if(USART_GetITStatus(macESP8266_USARTx, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a 回车换行结尾)
{
Res =USART_ReceiveData(macESP8266_USARTx); //读取接收到的数据
if((USART_RX_STA&0x8000)==0)//接收未完成
{
if(USART_RX_STA&0x4000)//接收到了0x0d
{
if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
else USART_RX_STA|=0x8000; //接收完成了
}
else //还没收到0X0D
{
if(Res==0x0d)USART_RX_STA|=0x4000;
else
{
USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
USART_RX_STA++;
if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收
}
}
}
}
}
/**
* @brief 配置 ESP8266 USART 的 NVIC 中断
* @param 无
* @retval 无
*/
static void ESP8266_USART_NVIC_Configuration ( void )
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Configure the NVIC Preemption Priority Bits */
NVIC_PriorityGroupConfig ( macNVIC_PriorityGroup_x );
/* Enable the USART2 Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = macESP8266_USART_IRQ;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/*
* 函数名：ESP8266_Rst
* 描述 ：重启WF-ESP8266模块
* 输入 ：无
* 返回 : 无
* 调用 ：被 ESP8266_AT_Test 调用
*/
void ESP8266_Rst ( void )
{
#if 0
ESP8266_Cmd ( "AT+RST", "OK", "ready", 2500 );
#else
macESP8266_RST_LOW_LEVEL();
Delay_ms ( 500 );
macESP8266_RST_HIGH_LEVEL();
#endif
}
bool ESP8266_DHCP_CUR ( )
{
char cCmd [40];
sprintf ( cCmd, "AT+CWDHCP_CUR=1,1");
return ESP8266_Cmd ( cCmd, "OK", NULL, 500 );
}
/*
* 函数名：ESP8266_Cmd
* 描述 ：对WF-ESP8266模块发送AT指令
* 输入 ：cmd，待发送的指令
* reply1，reply2，期待的响应，为NULL表不需响应，两者为或逻辑关系
* waittime，等待响应的时间
* 返回 : 1，指令发送成功
* 0，指令发送失败
* 调用 ：被外部调用
*/
bool ESP8266_Cmd ( char * cmd, char * reply1, char * reply2, u32 waittime )
{
strEsp8266_Fram_Record .InfBit .FramLength = 0; //从新开始接收新的数据包
macESP8266_Usart ( "%s\r\n", cmd );
if ( ( reply1 == 0 ) && ( reply2 == 0 ) ) //不需要接收数据
return true;
Delay_ms ( waittime ); //延时
strEsp8266_Fram_Record .Data_RX_BUF [ strEsp8266_Fram_Record .InfBit .FramLength ] = '\0';
macPC_Usart ( "%s", strEsp8266_Fram_Record .Data_RX_BUF );
strEsp8266_Fram_Record .InfBit .FramLength = 0; //清除接收标志
strEsp8266_Fram_Record.InfBit.FramFinishFlag = 0;
if ( ( reply1 != 0 ) && ( reply2 != 0 ) )
return ( ( bool ) strstr ( strEsp8266_Fram_Record .Data_RX_BUF, reply1 ) ||
( bool ) strstr ( strEsp8266_Fram_Record .Data_RX_BUF, reply2 ) );
else if ( reply1 != 0 )
return ( ( bool ) strstr ( strEsp8266_Fram_Record .Data_RX_BUF, reply1 ) );
else
return ( ( bool ) strstr ( strEsp8266_Fram_Record .Data_RX_BUF, reply2 ) );
}
/*
* 函数名：ESP8266_AT_Test
* 描述 ：对WF-ESP8266模块进行AT测试启动
* 输入 ：无
* 返回 : 无
* 调用 ：被外部调用
*/
//void ESP8266_AT_Test ( void )
//{
// macESP8266_RST_HIGH_LEVEL();
//
// Delay_ms ( 1000 );
//
// while ( ! ESP8266_Cmd ( "AT", "OK", NULL, 500 ) ) ESP8266_Rst ();
//}
bool ESP8266_AT_Test ( void )
{
char count=0;
//macESP8266_RST_HIGH_LEVEL();
printf("\r\nAT测试.....\r\n");
Delay_ms ( 2000 );
while ( count < 10 )
{
printf("\r\nAT测试次数 %d......\r\n", count);
if( ESP8266_Cmd ( "AT", "OK", NULL, 500 ) )
{
printf("\r\nAT测试启动成功 %d......\r\n", count);
return 1;
}
ESP8266_Rst();
++ count;
}
return 0;
}
/*
* 函数名：ESP8266_Net_Mode_Choose
* 描述 ：选择WF-ESP8266模块的工作模式
* 输入 ：enumMode，工作模式
* 返回 : 1，选择成功
* 0，选择失败
* 调用 ：被外部调用
*/
bool ESP8266_Net_Mode_Choose ( ENUM_Net_ModeTypeDef enumMode )
{
switch ( enumMode )
{
case STA:
return ESP8266_Cmd ( "AT+CWMODE=1", "OK", "no change", 2500 );
case AP:
return ESP8266_Cmd ( "AT+CWMODE=2", "OK", "no change", 2500 );
case STA_AP:
return ESP8266_Cmd ( "AT+CWMODE=3", "OK", "no change", 2500 );
default:
return false;
}
}
/*
* 函数名：ESP8266_JoinAP
* 描述 ：WF-ESP8266模块连接外部WiFi
* 输入 ：pSSID，WiFi名称字符串
* ：pPassWord，WiFi密码字符串
* 返回 : 1，连接成功
* 0，连接失败
* 调用 ：被外部调用
*/
bool ESP8266_JoinAP ( char * pSSID, char * pPassWord )
{
char cCmd [120];
sprintf ( cCmd, "AT+CWJAP=\"%s\",\"%s\"", pSSID, pPassWord );
return ESP8266_Cmd ( cCmd, "OK", NULL, 5000 );
}
/*
* 函数名：ESP8266_BuildAP
* 描述 ：WF-ESP8266模块创建WiFi热点
* 输入 ：pSSID，WiFi名称字符串
* ：pPassWord，WiFi密码字符串
* ：enunPsdMode，WiFi加密方式代号字符串
* 返回 : 1，创建成功
* 0，创建失败
* 调用 ：被外部调用
*/
bool ESP8266_BuildAP ( char * pSSID, char * pPassWord, ENUM_AP_PsdMode_TypeDef enunPsdMode )
{
char cCmd [120];
sprintf ( cCmd, "AT+CWSAP=\"%s\",\"%s\",1,%d", pSSID, pPassWord, enunPsdMode );
return ESP8266_Cmd ( cCmd, "OK", 0, 1000 );
}
/*
* 函数名：ESP8266_Enable_MultipleId
* 描述 ：WF-ESP8266模块启动多连接
* 输入 ：enumEnUnvarnishTx，配置是否多连接
* 返回 : 1，配置成功
* 0，配置失败
* 调用 ：被外部调用
*/
bool ESP8266_Enable_MultipleId ( FunctionalState enumEnUnvarnishTx )
{
char cStr [20];
sprintf ( cStr, "AT+CIPMUX=%d", ( enumEnUnvarnishTx ? 1 : 0 ) );
return ESP8266_Cmd ( cStr, "OK", 0, 500 );
}
/*
* 函数名：ESP8266_Link_Server
* 描述 ：WF-ESP8266模块连接外部服务器
* 输入 ：enumE，网络协议
* ：ip，服务器IP字符串
* ：ComNum，服务器端口字符串
* ：id，模块连接服务器的ID
* 返回 : 1，连接成功
* 0，连接失败
* 调用 ：被外部调用
*/
bool ESP8266_Link_Server ( ENUM_NetPro_TypeDef enumE, char * ip, char * ComNum, ENUM_ID_NO_TypeDef id)
{
char cStr [100] = { 0 }, cCmd [120];
switch ( enumE )
{
case enumTCP:
sprintf ( cStr, "\"%s\",\"%s\",%s", "TCP", ip, ComNum );
break;
case enumUDP:
sprintf ( cStr, "\"%s\",\"%s\",%s", "UDP", ip, ComNum );
break;
default:
break;
}
if ( id < 5 )
sprintf ( cCmd, "AT+CIPSTART=%d,%s", id, cStr);
else
sprintf ( cCmd, "AT+CIPSTART=%s", cStr );
return ESP8266_Cmd ( cCmd, "OK", "ALREAY CONNECT", 4000 );
}
/*
* 函数名：ESP8266_StartOrShutServer
* 描述 ：WF-ESP8266模块开启或关闭服务器模式
* 输入 ：enumMode，开启/关闭
* ：pPortNum，服务器端口号字符串
* ：pTimeOver，服务器超时时间字符串，单位：秒
* 返回 : 1，操作成功
* 0，操作失败
* 调用 ：被外部调用
*/
bool ESP8266_StartOrShutServer ( FunctionalState enumMode, char * pPortNum, char * pTimeOver )
{
char cCmd1 [120], cCmd2 [120];
if ( enumMode )
{
sprintf ( cCmd1, "AT+CIPSERVER=%d,%s", 1, pPortNum );
sprintf ( cCmd2, "AT+CIPSTO=%s", pTimeOver );
return ( ESP8266_Cmd ( cCmd1, "OK", 0, 500 ) &&
ESP8266_Cmd ( cCmd2, "OK", 0, 500 ) );
}
else
{
sprintf ( cCmd1, "AT+CIPSERVER=%d,%s", 0, pPortNum );
return ESP8266_Cmd ( cCmd1, "OK", 0, 500 );
}
}
/*
* 函数名：ESP8266_Get_LinkStatus
* 描述 ：获取 WF-ESP8266 的连接状态，较适合单端口时使用
* 输入 ：无
* 返回 : 2，获得ip
* 3，建立连接
* 3，失去连接
* 0，获取状态失败
* 调用 ：被外部调用
*/
uint8_t ESP8266_Get_LinkStatus ( void )
{
if ( ESP8266_Cmd ( "AT+CIPSTATUS", "OK", 0, 500 ) )
{
if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "STATUS:2\r\n" ) )
return 2;
else if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "STATUS:3\r\n" ) )
return 3;
else if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "STATUS:4\r\n" ) )
return 4;
}
return 0;
}
/*
* 函数名：ESP8266_Get_IdLinkStatus
* 描述 ：获取 WF-ESP8266 的端口（Id）连接状态，较适合多端口时使用
* 输入 ：无
* 返回 : 端口（Id）的连接状态，低5位为有效位，分别对应Id5~0，某位若置1表该Id建立了连接，若被清0表该Id未建立连接
* 调用 ：被外部调用
*/
uint8_t ESP8266_Get_IdLinkStatus ( void )
{
uint8_t ucIdLinkStatus = 0x00;
if ( ESP8266_Cmd ( "AT+CIPSTATUS", "OK", 0, 500 ) )
{
if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "+CIPSTATUS:0," ) )
ucIdLinkStatus |= 0x01;
else
ucIdLinkStatus &= ~ 0x01;
if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "+CIPSTATUS:1," ) )
ucIdLinkStatus |= 0x02;
else
ucIdLinkStatus &= ~ 0x02;
if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "+CIPSTATUS:2," ) )
ucIdLinkStatus |= 0x04;
else
ucIdLinkStatus &= ~ 0x04;
if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "+CIPSTATUS:3," ) )
ucIdLinkStatus |= 0x08;
else
ucIdLinkStatus &= ~ 0x08;
if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "+CIPSTATUS:4," ) )
ucIdLinkStatus |= 0x10;
else
ucIdLinkStatus &= ~ 0x10;
}
return ucIdLinkStatus;
}
/*
* 函数名：ESP8266_Inquire_ApIp
* 描述 ：获取 F-ESP8266 的 AP IP
* 输入 ：pApIp，存放 AP IP 的数组的首地址
* ucArrayLength，存放 AP IP 的数组的长度
* 返回 : 0，获取失败
* 1，获取成功
* 调用 ：被外部调用
*/
uint8_t ESP8266_Inquire_ApIp ( char * pApIp, uint8_t ucArrayLength )
{
char uc;
char * pCh;
ESP8266_Cmd ( "AT+CIFSR", "OK", 0, 500 );
pCh = strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "APIP,\"" );
if ( pCh )
pCh += 6;
else
return 0;
for ( uc = 0; uc < ucArrayLength; uc ++ )
{
pApIp [ uc ] = * ( pCh + uc);
if ( pApIp [ uc ] == '\"' )
{
pApIp [ uc ] = '\0';
break;
}
}
return 1;
}
/*
* 函数名：ESP8266_UnvarnishSend
* 描述 ：配置WF-ESP8266模块进入透传发送
* 输入 ：无
* 返回 : 1，配置成功
* 0，配置失败
* 调用 ：被外部调用
*/
bool ESP8266_UnvarnishSend ( void )
{
if ( ! ESP8266_Cmd ( "AT+CIPMODE=1", "OK", 0, 500 ) )
return false;
return
ESP8266_Cmd ( "AT+CIPSEND", "OK", ">", 500 );
}
/*
* 函数名：ESP8266_ExitUnvarnishSend
* 描述 ：配置WF-ESP8266模块退出透传模式
* 输入 ：无
* 返回 : 无
* 调用 ：被外部调用
*/
void ESP8266_ExitUnvarnishSend ( void )
{
Delay_ms ( 1000 );
macESP8266_Usart ( "+++" );
Delay_ms ( 500 );
}
/*
* 函数名：ESP8266_SendString
* 描述 ：WF-ESP8266模块发送字符串
* 输入 ：enumEnUnvarnishTx，声明是否已使能了透传模式
* ：pStr，要发送的字符串
* ：ulStrLength，要发送的字符串的字节数
* ：ucId，哪个ID发送的字符串
* 返回 : 1，发送成功
* 0，发送失败
* 调用 ：被外部调用
*/
bool ESP8266_SendString ( FunctionalState enumEnUnvarnishTx, char * pStr, u32 ulStrLength, ENUM_ID_NO_TypeDef ucId )
{
char cStr [20];
bool bRet = false;
if ( enumEnUnvarnishTx )
{
macESP8266_Usart ( "%s", pStr );
bRet = true;
}
else
{
if ( ucId < 5 )
sprintf ( cStr, "AT+CIPSEND=%d,%d", ucId, ulStrLength + 2 );
else
sprintf ( cStr, "AT+CIPSEND=%d", ulStrLength + 2 );
ESP8266_Cmd ( cStr, "> ", 0, 100 );
bRet = ESP8266_Cmd ( pStr, "SEND OK", 0, 500 );
}
return bRet;
}
/*
* 函数名：ESP8266_ReceiveString
* 描述 ：WF-ESP8266模块接收字符串
* 输入 ：enumEnUnvarnishTx，声明是否已使能了透传模式
* 返回 : 接收到的字符串首地址
* 调用 ：被外部调用
*/
char * ESP8266_ReceiveString ( FunctionalState enumEnUnvarnishTx )
{
char * pRecStr = 0;
strEsp8266_Fram_Record .InfBit .FramLength = 0;
strEsp8266_Fram_Record .InfBit .FramFinishFlag = 0;
while ( ! strEsp8266_Fram_Record .InfBit .FramFinishFlag );
strEsp8266_Fram_Record .Data_RX_BUF [ strEsp8266_Fram_Record .InfBit .FramLength ] = '\0';
if ( enumEnUnvarnishTx )
pRecStr = strEsp8266_Fram_Record .Data_RX_BUF;
else
{
if ( strstr ( strEsp8266_Fram_Record .Data_RX_BUF, "+IPD" ) )
pRecStr = strEsp8266_Fram_Record .Data_RX_BUF;
}
return pRecStr;
}4.温湿度配置与读取处理函数
/* DHT11延时函数使用DWT外设实现，因为SysTick的延时精度被设置为了10ms，不能提供us级别的延时 */
#define DHT11_DELAY_US(us) CPU_TS_Tmr_Delay_US(us)
#define DHT11_DELAY_MS(ms) CPU_TS_Tmr_Delay_MS(ms)
static void DHT11_GPIO_Config ( void );
static void DHT11_Mode_IPU ( void );
static void DHT11_Mode_Out_PP ( void );
static uint8_t DHT11_ReadByte ( void );
/**
* @brief DHT11 初始化函数
* @param 无
* @retval 无
*/
void DHT11_Init ( void )
{
DHT11_GPIO_Config ();
macDHT11_Dout_1; // 拉高GPIOB10
}
/*
* 函数名：DHT11_GPIO_Config
* 描述 ：配置DHT11用到的I/O口
* 输入 ：无
* 输出 ：无
*/
static void DHT11_GPIO_Config ( void )
{
/*定义一个GPIO_InitTypeDef类型的结构体*/
GPIO_InitTypeDef GPIO_InitStructure;
/*开启macDHT11_Dout_GPIO_PORT的外设时钟*/
macDHT11_Dout_SCK_APBxClock_FUN ( macDHT11_Dout_GPIO_CLK, ENABLE );
/*选择要控制的macDHT11_Dout_GPIO_PORT引脚*/
GPIO_InitStructure.GPIO_Pin = macDHT11_Dout_GPIO_PIN;
/*设置引脚模式为通用推挽输出*/
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
/*设置引脚速率为50MHz */
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
/*调用库函数，初始化macDHT11_Dout_GPIO_PORT*/
GPIO_Init ( macDHT11_Dout_GPIO_PORT, &GPIO_InitStructure );
}
/*
* 函数名：DHT11_Mode_IPU
* 描述 ：使DHT11-DATA引脚变为上拉输入模式
* 输入 ：无
* 输出 ：无
*/
static void DHT11_Mode_IPU(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/*选择要控制的macDHT11_Dout_GPIO_PORT引脚*/
GPIO_InitStructure.GPIO_Pin = macDHT11_Dout_GPIO_PIN;
/*设置引脚模式为浮空输入模式*/
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ;
/*调用库函数，初始化macDHT11_Dout_GPIO_PORT*/
GPIO_Init(macDHT11_Dout_GPIO_PORT, &GPIO_InitStructure);
}
/*
* 函数名：DHT11_Mode_Out_PP
* 描述 ：使DHT11-DATA引脚变为推挽输出模式
* 输入 ：无
* 输出 ：无
*/
static void DHT11_Mode_Out_PP(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/*选择要控制的macDHT11_Dout_GPIO_PORT引脚*/
GPIO_InitStructure.GPIO_Pin = macDHT11_Dout_GPIO_PIN;
/*设置引脚模式为通用推挽输出*/
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
/*设置引脚速率为50MHz */
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
/*调用库函数，初始化macDHT11_Dout_GPIO_PORT*/
GPIO_Init(macDHT11_Dout_GPIO_PORT, &GPIO_InitStructure);
}
/*
* 从DHT11读取一个字节，MSB先行
*/
static uint8_t DHT11_ReadByte ( void )
{
uint8_t i, temp=0;
for(i=0;i<8;i++)
{
/*每bit以50us低电平标置开始，轮询直到从机发出 的50us 低电平 结束*/
while(macDHT11_Dout_IN()==Bit_RESET);
/*DHT11 以26~28us的高电平表示“0”，以70us高电平表示“1”，
*通过检测 x us后的电平即可区别这两个状 ，x 即下面的延时
*/
DHT11_DELAY_US(40); //延时x us 这个延时需要大于数据0持续的时间即可
if(macDHT11_Dout_IN()==Bit_SET)/* x us后仍为高电平表示数据“1” */
{
/* 等待数据1的高电平结束 */
while(macDHT11_Dout_IN()==Bit_SET);
temp|=(uint8_t)(0x01<<(7-i)); //把第7-i位置1，MSB先行
}
else // x us后为低电平表示数据“0”
{
temp&=(uint8_t)~(0x01<<(7-i)); //把第7-i位置0，MSB先行
}
}
return temp;
}
/*
* 一次完整的数据传输为40bit，高位先出
* 8bit 湿度整数 + 8bit 湿度小数 + 8bit 温度整数 + 8bit 温度小数 + 8bit 校验和
*/
uint8_t DHT11_Read_TempAndHumidity(DHT11_Data_TypeDef *DHT11_Data)
{
/*输出模式*/
DHT11_Mode_Out_PP();
/*主机拉低*/
macDHT11_Dout_0;
/*延时18ms*/
DHT11_DELAY_MS(18);
/*总线拉高 主机延时30us*/
macDHT11_Dout_1;
DHT11_DELAY_US(30); //延时30us
/*主机设为输入 判断从机响应信号*/
DHT11_Mode_IPU();
/*判断从机是否有低电平响应信号 如不响应则跳出，响应则向下运行*/
if(macDHT11_Dout_IN()==Bit_RESET)
{
/*轮询直到从机发出 的80us 低电平 响应信号结束*/
while(macDHT11_Dout_IN()==Bit_RESET);
/*轮询直到从机发出的 80us 高电平 标置信号结束*/
while(macDHT11_Dout_IN()==Bit_SET);
/*开始接收数据*/
DHT11_Data->humi_int= DHT11_ReadByte();
DHT11_Data->humi_deci= DHT11_ReadByte();
DHT11_Data->temp_int= DHT11_ReadByte();
DHT11_Data->temp_deci= DHT11_ReadByte();
DHT11_Data->check_sum= DHT11_ReadByte();
/*读取结束，引脚改为输出模式*/
DHT11_Mode_Out_PP();
/*主机拉高*/
macDHT11_Dout_1;
/*检查读取的数据是否正确*/
if(DHT11_Data->check_sum == DHT11_Data->humi_int + DHT11_Data->humi_deci + DHT11_Data->temp_int+ DHT11_Data->temp_deci)
return SUCCESS;
else
return ERROR;
}
else
return ERROR;
}
5.串口重定向输出函数
#include "common.h"
#include "stm32f10x.h"
#include <stdarg.h>
static char * itoa ( int value, char * string, int radix );
/*
* 函数名：USART2_printf
* 描述 ：格式化输出，类似于C库中的printf，但这里没有用到C库
* 输入 ：-USARTx 串口通道，这里只用到了串口2，即USART2
* -Data 要发送到串口的内容的指针
* -... 其他参数
* 输出 ：无
* 返回 ：无
* 调用 ：外部调用
* 典型应用USART2_printf( USART2, "\r\n this is a demo \r\n" );
* USART2_printf( USART2, "\r\n %d \r\n", i );
* USART2_printf( USART2, "\r\n %s \r\n", j );
*/
void USART_printf ( USART_TypeDef * USARTx, char * Data, ... )
{
const char *s;
int d;
char buf[16];
va_list ap;
va_start(ap, Data);
while ( * Data != 0 ) // 判断是否到达字符串结束符
{
if ( * Data == 0x5c ) //'\'
{
switch ( *++Data )
{
case 'r': //回车符
USART_SendData(USARTx, 0x0d);
Data ++;
break;
case 'n': //换行符
USART_SendData(USARTx, 0x0a);
Data ++;
break;
default:
Data ++;
break;
}
}
else if ( * Data == '%')
{ //
switch ( *++Data )
{
case 's': //字符串
s = va_arg(ap, const char *);
for ( ; *s; s++)
{
USART_SendData(USARTx,*s);
while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
}
Data++;
break;
case 'd':
//十进制
d = va_arg(ap, int);
itoa(d, buf, 10);
for (s = buf; *s; s++)
{
USART_SendData(USARTx,*s);
while( USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET );
}
Data++;
break;
default:
Data++;
break;
}
}
else USART_SendData(USARTx, *Data++);
while ( USART_GetFlagStatus ( USARTx, USART_FLAG_TXE ) == RESET );
}
}
/*
* 函数名：itoa
* 描述 ：将整形数据转换成字符串
* 输入 ：-radix =10 表示10进制，其他结果为0
* -value 要转换的整形数
* -buf 转换后的字符串
* -radix = 10
* 输出 ：无
* 返回 ：无
* 调用 ：被USART2_printf()调用
*/
static char * itoa( int value, char *string, int radix )
{
int i, d;
int flag = 0;
char *ptr = string;
/* This implementation only works for decimal numbers. */
if (radix != 10)
{
*ptr = 0;
return string;
}
if (!value)
{
*ptr++ = 0x30;
*ptr = 0;
return string;
}
/* if this is a negative value insert the minus sign. */
if (value < 0)
{
*ptr++ = '-';
/* Make the value positive. */
value *= -1;
}
for (i = 10000; i > 0; i /= 10)
{
d = value / i;
if (d || flag)
{
*ptr++ = (char)(d + 0x30);
value -= (d * i);
flag = 1;
}
}
/* Null terminate the string. */
*ptr = 0;
return string;
} /* NCL_Itoa */
五、运行演示
STM32+WIFI+阿里云实现温湿度采集、继电器远程控制
