基于STM32和oneNET云平台的数据收罗体系(MQTT协议) - ToB企服应用市场:ToB评测及商务社交产业平台

/*-------------------------------------------------*/
/*函数名：复位DHT11 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void DHT11_Rst(void)
{
DHT11_IO_OUT(); //设置IO输出模式
DHT11_OUT(0); //拉低IO
DelayMs(30); //拉低至少18ms，我们拉低30
DHT11_OUT(1); //拉高IO
DelayUs(30); //主机拉高20~40us，我们拉高30us
}
/*-------------------------------------------------*/
/*函数名：等待DHT11的回应 */
/*参数：无 */
/*返回值：1错误 0正确 */
/*-------------------------------------------------*/
char DHT11_Check(void)
{
char timeout; //定义一个变量用于超时判断
timeout = 0; //超时变量清零
DHT11_IO_IN(); //IO设置输入模式
while((DHT11_DQ_IN == 1) && (timeout < 70))//DHT11会拉低40~50us,我们等待70us超时时间
{
timeout++; //超时变量+1
DelayUs(1); //延时1us
}
if(timeout >= 70)return 1; //如果timeout>=70,说明是因为超时退出的while循环，返回1表示错误
else timeout = 0; //反之，说明是因为等到了DHT11拉低IO，退出的while循环，正确并清零timeout
while((DHT11_DQ_IN == 0) && (timeout < 70))//DHT11拉低后会再次拉高40~50us,,我们等待70us超时时间
{
timeout++; //超时变量+1
DelayUs(1); //延时1us
}
if(timeout >= 70)return 2; //如果timeout>=70,说明是因为超时退出的while循环，返回2表示错误
return 0; //反之正确，返回0
}
/*-------------------------------------------------*/
/*函数名：读取一个位 */
/*参数：无 */
/*返回值：1或0 */
/*-------------------------------------------------*/
char DHT11_Read_Bit(void)
{
char timeout; //定义一个变量用于超时判断
timeout = 0; //清零timeout
while((DHT11_DQ_IN == 1) && (timeout < 40))//每一位数据开始，是12~14us的低电平，我们等40us
{
timeout++; //超时变量+1
DelayUs(1); //延时1us
}
timeout = 0; //清零timeout
while((DHT11_DQ_IN == 0) && (timeout < 60))//接下来，DHT11会拉高IO，根据拉高的时间判断是0或1，我们等60us
{
timeout++; //超时变量+1
DelayUs(1); //延时1us
}
DelayUs(35); //延时35us
if(DHT11_DQ_IN)return 1; //如果延时后，是高电平，那么本位接收的是1，返回1
else return 0; //反之延时后，是低电平，那么本位接收的是0，返回0
}
/*-------------------------------------------------*/
/*函数名：读取一个字节 */
/*参数：无 */
/*返回值：数据 */
/*-------------------------------------------------*/
char DHT11_Read_Byte(void)
{
char i; //定义一个变量用于for循环
char dat; //定义一个变量用于保存数据
dat = 0; //清除保存数据的变量
for (i = 0; i < 8; i++){ //一个字节8位，循环8次
dat <<= 1; //左移一位，腾出空位
dat |= DHT11_Read_Bit(); //读取一位数据
}
return dat; //返回一个字节的数据
}
/*-------------------------------------------------*/
/*函数名：读取一次数据温湿度 */
/*参数：temp:温度值 */
/*参数：humi:湿度值 */
/*返回值：1错误 0正确 */
/*-------------------------------------------------*/
char DHT11_Read_Data(char *temp, char *humi)
{
char buf[5]; //一次完整的数据有5个字节，定义一个缓冲区
char i; //定义一个变量用于for循环
DHT11_Rst(); //复位DHT11
if(DHT11_Check() == 0) //判断DHT11回复状态=0的话，表示正确，进入if
{
for(i = 0; i < 5; i++){ //一次完整的数据有5个字节，循环5次
buf[i] = DHT11_Read_Byte(); //每次读取一个字节
}
if((buf[0] + buf[1] + buf[2] + buf[3]) == buf[4])//判断数据校验，前4个字节相加应该等于第5个字节，正确的话，进入if
{
//u1_printf("%d\r\n",buf[0]); //温度数据
//u1_printf("%d\r\n",buf[1]);
//u1_printf("%d\r\n",buf[2]); //湿度数据
//u1_printf("%d\r\n",buf[3]);
//u1_printf("%d\r\n",buf[4]);
*humi = buf[0]; //湿度数据，保存在humi指针指向的地址变量中
*temp = buf[2]; //温度数据，保存在temp指针指向的地址变量中
}else return 1; //反之，数据校验错误，直接返回1
}else return 2; //反之，如果DHT11回复状态=1的话，表示错误，进入else，直接返回2
return 0; //读取正确返回0
}
/*-------------------------------------------------*/
/*函数名：初始化DHT11 */
/*参数：无 */
/*返回值：1错误 0正确 */
/*-------------------------------------------------*/
char DHT11_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure; //定义一个IO端口参数结构体
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //使能PA端口时钟
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; //准备设置PA8
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //速率50Mhz
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推免输出方式
GPIO_Init(GPIOA, &GPIO_InitStructure); //设置PA8
DHT11_Rst(); //复位DHT11
return DHT11_Check(); //返回DHT11的回复状态
}

复制代码

void Adc_Init(void)
{
ADC_InitTypeDef ADC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |RCC_APB2Periph_ADC1, ENABLE ); //使能ADC1通道时钟
RCC_ADCCLKConfig(RCC_PCLK2_Div6); //设置ADC分频因子6 72M/6=12,ADC最大时间不能超过14M
//PA1 作为模拟通道输入引脚
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; //模拟输入引脚
GPIO_Init(GPIOA, &GPIO_InitStructure);
ADC_DeInit(ADC1); //复位ADC1
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; //ADC工作模式:ADC1和ADC2工作在独立模式
ADC_InitStructure.ADC_ScanConvMode = DISABLE; //模数转换工作在单通道模式
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; //模数转换工作在单次转换模式
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; //转换由软件而不是外部触发启动
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; //ADC数据右对齐
ADC_InitStructure.ADC_NbrOfChannel = 1; //顺序进行规则转换的ADC通道的数目
ADC_Init(ADC1, &ADC_InitStructure); //根据ADC_InitStruct中指定的参数初始化外设ADCx的寄存器
ADC_Cmd(ADC1, ENABLE); //使能指定的ADC1
ADC_ResetCalibration(ADC1); //使能复位校准
while(ADC_GetResetCalibrationStatus(ADC1)); //等待复位校准结束
ADC_StartCalibration(ADC1); //开启AD校准
while(ADC_GetCalibrationStatus(ADC1)); //等待校准结束
// ADC_SoftwareStartConvCmd(ADC1, ENABLE); //使能指定的ADC1的软件转换启动功能
}
/**************************** ADC转换值获取函数 ****************************
功能：获取ADC模块转换后的数值
参数：无
返回值：存放ADC转换值
***************************************************************************/
u16 Get_adcvalue(void)
{
//设置指定ADC的规则组通道，一个序列，采样时间
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_239Cycles5 ); //ADC1,ADC通道,采样时间为239.5周期
ADC_SoftwareStartConvCmd(ADC1, ENABLE); //使能指定的ADC1的软件转换启动功能
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC ));//等待转换结束
return ADC_GetConversionValue(ADC1); //返回最近一次ADC1规则组的转换结果
}
u16 Get_Adc_Average(u8 times)
{
u32 temp_val=0;
u8 t;
for(t=0;t<times;t++)
{
temp_val+=Get_adcvalue();
DelayMs(5);
}
return temp_val/times;
}

复制代码

/*-------------------------------------------------*/
/*函数名：初始化LED函数 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void LED_Init(void)
{
GPIO_InitTypeDef GPIO_InitStr;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB ,ENABLE); //使能时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE ,ENABLE);
GPIO_InitStr.GPIO_Mode=GPIO_Mode_Out_PP; //结构体变量赋值
GPIO_InitStr.GPIO_Pin=GPIO_Pin_5;
GPIO_InitStr.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOB,&GPIO_InitStr); //初始化GPIOB
GPIO_SetBits(GPIOB,GPIO_Pin_5); //赋予 GPIO_Pin_5 初始为高电平
GPIO_InitStr.GPIO_Mode=GPIO_Mode_Out_PP;
GPIO_InitStr.GPIO_Pin=GPIO_Pin_5;
GPIO_InitStr.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_Init(GPIOE,&GPIO_InitStr);
GPIO_SetBits(GPIOE,GPIO_Pin_5);
}
/*-------------------------------------------------*/
/*函数名：LED开启 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void LED_On(void)
{
GPIO_ResetBits(GPIOB, GPIO_Pin_5); //PD2 输出低
}
/*-------------------------------------------------*/
/*函数名：LED关闭 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void LED_Off(void)
{
GPIO_SetBits(GPIOB, GPIO_Pin_5); //PD2 输出高
}

复制代码

/*-------------------------------------------------*/
/*函数名：初始化WiFi的复位IO */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void WiFi_ResetIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure; //定义一个设置IO端口参数的结构体
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA , ENABLE); //使能PA端口时钟
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; //准备设置PA4
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //速率50Mhz
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //推免输出方式
GPIO_Init(GPIOA, &GPIO_InitStructure); //设置PA4
RESET_IO(1); //复位IO拉高电平
}
/*-------------------------------------------------*/
/*函数名：WiFi发送设置指令 */
/*参数：cmd：指令 */
/*参数：timeout：超时时间（100ms的倍数） */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_SendCmd(char *cmd, int timeout)
{
WiFi_RxCounter = 0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF, 0, WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
WiFi_printf("%s\r\n", cmd); //发送指令
while(timeout--) //等待超时时间到0
{
DelayMs(100); //延时100ms
if(strstr(WiFi_RX_BUF, "OK")) //如果接收到OK表示指令成功
break; //主动跳出while循环
u1_printf("%d ", timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout <= 0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到OK，返回1
else return 0; //反之，表示正确，说明收到OK，通过break主动跳出while
}
/*-------------------------------------------------*/
/*函数名：WiFi复位 */
/*参数：timeout：超时时间（100ms的倍数） */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_Reset(int timeout)
{
RESET_IO(0); //复位IO拉低电平
DelayMs(500); //延时500ms
RESET_IO(1); //复位IO拉高电平
while(timeout--) //等待超时时间到0
{
DelayMs(100); //延时100ms
if(strstr(WiFi_RX_BUF, "ready")) //如果接收到ready表示复位成功
break; //主动跳出while循环
u1_printf("%d ", timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout <= 0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到ready，返回1
else return 0; //反之，表示正确，说明收到ready，通过break主动跳出while
}
/*-------------------------------------------------*/
/*函数名：WiFi加入路由器指令 */
/*参数：timeout：超时时间（1s的倍数） */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_JoinAP(int timeout)
{
WiFi_RxCounter = 0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF, 0, WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
WiFi_printf("AT+CWJAP="%s","%s"\r\n", SSID, PASS); //发送指令
while(timeout--) //等待超时时间到0
{
DelayMs(1000); //延时1s
if(strstr(WiFi_RX_BUF, "OK")) //如果接收到WIFI GOT IP表示成功
break; //主动跳出while循环
u1_printf("%d ", timeout); //串口输出现在的超时时间
}
u1_printf("\r\n%s\r\n", WiFi_RX_BUF);
u1_printf("\r\n"); //串口输出信息
if(timeout <= 0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到WIFI GOT IP，返回1
return 0; //正确，返回0
}
/*-------------------------------------------------*/
/*函数名：连接TCP服务器，并进入透传模式 */
/*参数：timeout：超时时间（100ms的倍数） */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_Connect_Server(int timeout)
{
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
WiFi_printf("AT+CIPSTART="TCP","%s",%d\r\n", ServerIP, ServerPort);//发送连接服务器指令
while(timeout--) //等待超时与否
{
DelayMs(100); //延时100ms
if(strstr(WiFi_RX_BUF, "CONNECT")) //如果接受到CONNECT表示连接成功
break; //跳出while循环
if(strstr(WiFi_RX_BUF, "CLOSED")) //如果接受到CLOSED表示服务器未开启
return 1; //服务器未开启返回1
if(strstr(WiFi_RX_BUF, "ALREADY CONNECTED"))//如果接受到ALREADY CONNECTED已经建立连接
return 2; //已经建立连接返回2
u1_printf("%d ", timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout <= 0)return 3; //超时错误，返回3
else //连接成功，准备进入透传
{
u1_printf("连接服务器成功，准备进入透传\r\n"); //串口显示信息
WiFi_RxCounter = 0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF, 0, WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
WiFi_printf("AT+CIPSEND\r\n"); //发送进入透传指令
while(timeout--) //等待超时与否
{
DelayMs(100); //延时100ms
if(strstr(WiFi_RX_BUF, "\r\nOK\r\n\r\n>"))//如果成立表示进入透传成功
break; //跳出while循环
u1_printf("%d ", timeout); //串口输出现在的超时时间
}
if(timeout <= 0)return 4; //透传超时错误，返回4
}
return 0; //成功返回0
}
/*-------------------------------------------------*/
/*函数名：WiFi_Smartconfig */
/*参数：timeout：超时时间（1s的倍数） */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_Smartconfig(int timeout)
{
WiFi_RxCounter=0; //WiFi接收数据量变量清零
memset(WiFi_RX_BUF,0,WiFi_RXBUFF_SIZE); //清空WiFi接收缓冲区
while(timeout--) //等待超时时间到0
{
DelayMs(1000); //延时1s
if(strstr(WiFi_RX_BUF, "connected")) //如果串口接受到connected表示成功
break; //跳出while循环
u1_printf("%d ", timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout <= 0)return 1; //超时错误，返回1
return 0; //正确返回0
}
/*-------------------------------------------------*/
/*函数名：等待加入路由器 */
/*参数：timeout：超时时间（1s的倍数） */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_WaitAP(int timeout)
{
while(timeout--){ //等待超时时间到0
DelayMs(1000); //延时1s
if(strstr(WiFi_RX_BUF, "WIFI GOT IP")) //如果接收到WIFI GOT IP表示成功
break; //主动跳出while循环
u1_printf("%d ", timeout); //串口输出现在的超时时间
}
u1_printf("\r\n"); //串口输出信息
if(timeout <= 0)return 1; //如果timeout<=0，说明超时时间到了，也没能收到WIFI GOT IP，返回1
return 0; //正确，返回0
}
/*-------------------------------------------------*/
/*函数名：WiFi连接服务器 */
/*参数：无 */
/*返回值：0：正确其他：错误 */
/*-------------------------------------------------*/
char WiFi_Connect_IoTServer(void)
{
u1_printf("准备复位模块\r\n"); //串口提示数据
if(WiFi_Reset(50)) //复位，100ms超时单位，总计5s超时时间
{
u1_printf("复位失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 1; //返回1
}else u1_printf("复位成功\r\n"); //串口提示数据
u1_printf("准备设置STA模式\r\n"); //串口提示数据
if(WiFi_SendCmd("AT+CWMODE=1",50))//设置STA模式，100ms超时单位，总计5s超时时间
{
u1_printf("设置STA模式失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 2; //返回2
}else u1_printf("设置STA模式成功\r\n"); //串口提示数据
if(wifi_mode==0) //如果联网模式=0：SSID和密码写在程序里
{
u1_printf("准备取消自动连接\r\n"); //串口提示数据
if(WiFi_SendCmd("AT+CWAUTOCONN=0",50)) //取消自动连接，100ms超时单位，总计5s超时时间
{
u1_printf("取消自动连接失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 3; //返回3
}else u1_printf("取消自动连接成功\r\n"); //串口提示数据
u1_printf("准备连接路由器\r\n"); //串口提示数据
if(WiFi_JoinAP(30))//连接路由器,1s超时单位，总计30s超时时间
{
u1_printf("连接路由器失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 4; //返回4
}else u1_printf("连接路由器成功\r\n"); //串口提示数据
}
u1_printf("准备设置透传\r\n"); //串口提示数据
if(WiFi_SendCmd("AT+CIPMODE=1",50)) //设置透传，100ms超时单位，总计5s超时时间
{
u1_printf("设置透传失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 8; //返回8
}else u1_printf("设置透传成功\r\n"); //串口提示数据
u1_printf("准备关闭多路连接\r\n"); //串口提示数据
if(WiFi_SendCmd("AT+CIPMUX=0",50)) //关闭多路连接，100ms超时单位，总计5s超时时间
{
u1_printf("关闭多路连接失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 9; //返回9
}else u1_printf("关闭多路连接成功\r\n"); //串口提示数据
u1_printf("准备连接服务器\r\n"); //串口提示数据
if(WiFi_Connect_Server(100)) //连接服务器，100ms超时单位，总计10s超时时间
{
u1_printf("连接服务器失败，准备重启\r\n"); //返回非0值，进入if，串口提示数据
return 10; //返回10
}else u1_printf("连接服务器成功\r\n"); //串口提示数据
return 0; //正确返回0
}

复制代码

/*-------------------------------------------------*/
/*函数名：定时器2使能10s定时 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void TIM2_ENABLE_10S(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure; //定义一个设置定时器的变量
NVIC_InitTypeDef NVIC_InitStructure; //定义一个设置中断的变量
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断向量分组：第2组抢先优先级：0 1 2 3 子优先级：0 1 2 3
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); //使能TIM2时钟
TIM_DeInit(TIM2); //定时器2寄存器恢复默认值
TIM_TimeBaseInitStructure.TIM_Period = 20000-1; //设置自动重装载值
TIM_TimeBaseInitStructure.TIM_Prescaler = 36000-1; //设置定时器预分频数
TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;//向上计数模式
TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; //1分频
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure); //设置TIM2
TIM_ClearITPendingBit(TIM2, TIM_IT_Update); //清除溢出中断标志位
TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); //使能TIM2溢出中断
TIM_Cmd(TIM2, ENABLE); //开TIM2
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn; //设置TIM2中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; //抢占优先级2
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //子优先级1
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //中断通道使能
NVIC_Init(&NVIC_InitStructure); //设置中断
}
/*-------------------------------------------------*/
/*函数名：定时器3使能30s定时 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void TIM3_ENABLE_30S(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure; //定义一个设置定时器的变量
NVIC_InitTypeDef NVIC_InitStructure; //定义一个设置中断的变量
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断向量分组：第2组抢先优先级：0 1 2 3 子优先级：0 1 2 3
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //使能TIM3时钟
TIM_DeInit(TIM3); //定时器3寄存器恢复默认值
TIM_TimeBaseInitStructure.TIM_Period = 60000-1; //设置自动重装载值
TIM_TimeBaseInitStructure.TIM_Prescaler = 36000-1; //设置定时器预分频数
TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;//向上计数模式
TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; //1分频
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStructure); //设置TIM3
TIM_ClearITPendingBit(TIM3, TIM_IT_Update); //清除溢出中断标志位
TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE); //使能TIM3溢出中断
TIM_Cmd(TIM3, ENABLE); //开TIM3
NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //设置TIM3中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2; //抢占优先级2
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; //子优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //中断通道使能
NVIC_Init(&NVIC_InitStructure); //设置中断
}
/*-------------------------------------------------*/
/*函数名：定时器3使能2s定时 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void TIM3_ENABLE_2S(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure; //定义一个设置定时器的变量
NVIC_InitTypeDef NVIC_InitStructure; //定义一个设置中断的变量
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断向量分组：第2组抢先优先级：0 1 2 3 子优先级：0 1 2 3
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //使能TIM3时钟
TIM_DeInit(TIM3); //定时器3寄存器恢复默认值
TIM_TimeBaseInitStructure.TIM_Period = 20000-1; //设置自动重装载值
TIM_TimeBaseInitStructure.TIM_Prescaler = 7200-1; //设置定时器预分频数
TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;//向上计数模式
TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; //1分频
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStructure); //设置TIM3
TIM_ClearITPendingBit(TIM3, TIM_IT_Update); //清除溢出中断标志位
TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE); //使能TIM3溢出中断
TIM_Cmd(TIM3, ENABLE); //开TIM3
NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn; //设置TIM3中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; //抢占优先级1
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //中断通道使能
NVIC_Init(&NVIC_InitStructure); //设置中断
}
/*-------------------------------------------------*/
/*函数名：定时器4初始化 */
/*参数：arr：自动重装值 0~65535 */
/*参数：psc：时钟预分频数 0~65535 */
/*返回值：无 */
/*说明：定时时间：arr*psc*1000/72000000 单位ms */
/*-------------------------------------------------*/
void TIM4_Init(unsigned short int arr, unsigned short int psc)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure; //定义一个设置定时器的变量
NVIC_InitTypeDef NVIC_InitStructure; //定义一个设置中断的变量
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断向量分组：第2组抢先优先级：0 1 2 3 子优先级：0 1 2 3
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); //使能TIM4时钟
TIM_TimeBaseInitStructure.TIM_Period = arr; //设置自动重装载值
TIM_TimeBaseInitStructure.TIM_Prescaler = psc; //设置定时器预分频数
TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up; //向上计数模式
TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; //1分频
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseInitStructure); //设置TIM4
TIM_ClearITPendingBit(TIM4, TIM_IT_Update); //清除溢出中断标志位
TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE); //使能TIM4溢出中断
TIM_Cmd(TIM4, DISABLE); //先关闭TIM4
NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn; //设置TIM4中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; //抢占优先级1
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //中断通道使能
NVIC_Init(&NVIC_InitStructure); //设置中断
}

复制代码

/*-------------------------------------------------*/
/*函数名：定时器4中断服务函数。处理MQTT数据 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void TIM4_IRQHandler(void)
{
if(TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)//如果TIM_IT_Update置位，表示TIM4溢出中断，进入if
{
memcpy(&MQTT_RxDataInPtr[2], Usart2_RxBuff, Usart2_RxCounter); //拷贝数据到接收缓冲区
MQTT_RxDataInPtr[0] = Usart2_RxCounter/256; //记录数据长度高字节
MQTT_RxDataInPtr[1] = Usart2_RxCounter%256; //记录数据长度低字节
MQTT_RxDataInPtr += RBUFF_UNIT; //指针下移
if(MQTT_RxDataInPtr == MQTT_RxDataEndPtr) //如果指针到缓冲区尾部了
MQTT_RxDataInPtr = MQTT_RxDataBuf[0]; //指针归位到缓冲区开头
Usart2_RxCounter = 0; //串口2接收数据量变量清零
TIM_SetCounter(TIM3, 0); //清零定时器3计数器，重新计时ping包发送时间
TIM_Cmd(TIM4, DISABLE); //关闭TIM4定时器
TIM_SetCounter(TIM4, 0); //清零定时器4计数器
TIM_ClearITPendingBit(TIM4, TIM_IT_Update); //清除TIM4溢出中断标志
}
}
/*-------------------------------------------------*/
/*函数名：定时器3中断服务函数 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void TIM3_IRQHandler(void)
{
if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)//如果TIM_IT_Update置位，表示TIM3溢出中断，进入if
{
switch(pingFlag) //判断pingFlag的状态
{
case 0: //如果pingFlag等于0，表示正常状态，发送Ping报文
MQTT_PingREQ(); //添加Ping报文到发送缓冲区
break;
case 1: //如果pingFlag等于1，说明上一次发送到的ping报文，没有收到服务器回复，所以1没有被清除为0，可能是连接异常，我们要启动快速ping模式
TIM3_ENABLE_2S(); //我们将定时器6设置为2s定时,快速发送Ping报文
MQTT_PingREQ(); //添加Ping报文到发送缓冲区
break;
case 2: //如果pingFlag等于2，说明还没有收到服务器回复
case 3: //如果pingFlag等于3，说明还没有收到服务器回复
case 4: //如果pingFlag等于4，说明还没有收到服务器回复
MQTT_PingREQ(); //添加Ping报文到发送缓冲区
break;
case 5: //如果pingFlag等于5，说明我们发送了多次ping，均无回复，应该是连接有问题，我们重启连接
connectFlag = 0; //连接状态置0，表示断开，没连上服务器
TIM_Cmd(TIM3, DISABLE); //关TIM3
break;
}
pingFlag++; //pingFlag自增1，表示又发送了一次ping，期待服务器的回复
TIM_ClearITPendingBit(TIM3, TIM_IT_Update); //清除TIM3溢出中断标志
}
}
/*-------------------------------------------------*/
/*函数名：定时器2中断服务函数 */
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
extern u16 ADC_Val;
void TIM2_IRQHandler(void)
{
char humidity; //定义一个变量，保存湿度值
char temperature; //定义一个变量，保存温度值
char head1[3];
char temp[50]; //定义一个临时缓冲区1,不包括报头
char tempAll[100]; //定义一个临时缓冲区2，包括所有数据
int dataLen = 0; //报文长度
ADC_Val_Disp(10,20); //气敏检测
if(TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
{
DHT11_Read_Data(&temperature,&humidity);//读取温湿度值
memset(temp, 0, 50); //清空缓冲区1
memset(tempAll, 0, 100); //清空缓冲区2
memset(head1, 0, 3); //清空MQTT头
sprintf(temp,"{"MQ":"%d","TM":"%d","HM":"%d"}",
(ADC_Val/100), temperature, humidity);//构建报文
head1[0] = 0x03; //固定报头
head1[1] = 0x00; //固定报头
head1[2] = strlen(temp); //剩余长度
sprintf(tempAll, "%c%c%c%s", head1[0], head1[1], head1[2], temp);
u1_printf("\r\n"); //串口显示相关数据
u1_printf("%s\r\n", tempAll + 3);
dataLen = strlen(temp) + 3;
MQTT_PublishQs0(Data_TOPIC_NAME,tempAll, dataLen);//添加数据，发布给服务器
TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
}
}

复制代码

/*-------------------------------------------------*/
/*函数名：初始化串口1发送功能 */
/*参数：bound：波特率 */
/*返回值：无 */
/*-------------------------------------------------*/
void Usart1_Init(unsigned int bound)
{
GPIO_InitTypeDef GPIO_InitStructure; //定义一个设置GPIO功能的变量
USART_InitTypeDef USART_InitStructure; //定义一个设置串口功能的变量
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); //使能串口1时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //使能GPIOA时钟
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //准备设置PA9
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //IO速率50M
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出，用于串口1的发送
GPIO_Init(GPIOA, &GPIO_InitStructure); //设置PA9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //准备设置PA10
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入，用于串口1的接收
GPIO_Init(GPIOA, &GPIO_InitStructure); //设置PA10
USART_InitStructure.USART_BaudRate = bound; //波特率设置
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //8个数据位
USART_InitStructure.USART_StopBits = USART_StopBits_1; //1个停止位
USART_InitStructure.USART_Parity = USART_Parity_No; //无奇偶校验位
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
//如果不使能接收模式
USART_InitStructure.USART_Mode = USART_Mode_Tx ; //只发模式
USART_Init(USART1, &USART_InitStructure); //设置串口1
USART_Cmd(USART1, ENABLE); //使能串口1
}
/*-------------------------------------------------*/
/*函数名：串口1 printf函数 */
/*参数：char* fmt,... 格式化输出字符串和参数 */
/*返回值：无 */
/*-------------------------------------------------*/
__align(8) char Usart1_TxBuff[USART1_TXBUFF_SIZE];
void u1_printf(char * fmt, ...)
{
unsigned int i, length;
va_list ap;
va_start(ap, fmt);
vsprintf(Usart1_TxBuff, fmt, ap);
va_end(ap);
length = strlen((const char*)Usart1_TxBuff);
while((USART1->SR&0X40) == 0);
for(i = 0; i < length; i++)
{
USART1->DR = Usart1_TxBuff[i];
while((USART1->SR&0X40) == 0);
}
}
/*-------------------------------------------------*/
/*函数名：初始化串口2发送功能 */
/*参数：bound：波特率 */
/*返回值：无 */
/*-------------------------------------------------*/
void Usart2_Init(unsigned int bound)
{
GPIO_InitTypeDef GPIO_InitStructure; //定义一个设置GPIO功能的变量
USART_InitTypeDef USART_InitStructure; //定义一个设置串口功能的变量
NVIC_InitTypeDef NVIC_InitStructure; //如果使能接收功能，定义一个设置中断的变量
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置中断向量分组：第2组抢先优先级：0 1 2 3 子优先级：0 1 2 3
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); //使能串口2时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //使能GPIOA时钟
USART_DeInit(USART2); //串口2寄存器重新设置为默认值
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //准备设置PA2
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //IO速率50M
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出，用于串口2的发送
GPIO_Init(GPIOA, &GPIO_InitStructure); //设置PA2
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; //准备设置PA3
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入，用于串口2的接收
GPIO_Init(GPIOA, &GPIO_InitStructure); //设置PA3
USART_InitStructure.USART_BaudRate = bound; //波特率设置
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //8个数据位
USART_InitStructure.USART_StopBits = USART_StopBits_1; //1个停止位
USART_InitStructure.USART_Parity = USART_Parity_No; //无奇偶校验位
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; //收发模式
USART_Init(USART2, &USART_InitStructure); //设置串口2
USART_ClearFlag(USART2, USART_FLAG_RXNE); //清除接收标志位
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //开启接收中断
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; //设置串口2中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //抢占优先级0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //子优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //中断通道使能
NVIC_Init(&NVIC_InitStructure); //设置串口2中断
USART_Cmd(USART2, ENABLE); //使能串口2
}
/*-------------------------------------------------*/
/*函数名：串口2 printf函数 */
/*参数：char* fmt,... 格式化输出字符串和参数 */
/*返回值：无 */
/*-------------------------------------------------*/
__align(8) char USART2_TxBuff[USART2_TXBUFF_SIZE];
void u2_printf(char* fmt, ...)
{
unsigned int i, length;
va_list ap;
va_start(ap, fmt);
vsprintf(USART2_TxBuff, fmt, ap);
va_end(ap);
length=strlen((const char*)USART2_TxBuff);
while((USART2->SR&0X40) == 0);
for(i = 0; i < length; i++)
{
USART2->DR = USART2_TxBuff[i];
while((USART2->SR&0X40) == 0);
}
}
/*-------------------------------------------------*/
/*函数名：串口2发送缓冲区中的数据 */
/*参数：data：数据 */
/*返回值：无 */
/*-------------------------------------------------*/
void u2_TxData(unsigned char *data)
{
int i;
while((USART2->SR&0X40) == 0);
for(i = 1; i <= (data[0] * 256 + data[1]); i++)
{
USART2->DR = data[i+1];
while((USART2->SR&0X40) == 0);
}
}

复制代码

/*-------------------------------------------------*/
/*函数名：串口2接收中断函数（最高优先级，处理接收数据）*/
/*参数：无 */
/*返回值：无 */
/*-------------------------------------------------*/
void USART2_IRQHandler(void)
{
if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) //如果USART_IT_RXNE标志置位，表示有数据到了，进入if分支
{
if(connectFlag == 0) //如果connectFlag等于0，当前还没有连接服务器，处于指令配置状态
{
if(USART2->DR)
{ //处于指令配置状态时，非零值才保存到缓冲区
Usart2_RxBuff[Usart2_RxCounter] = USART2->DR;//保存到缓冲区
Usart2_RxCounter++; //每接收1个字节的数据，Usart2_RxCounter加1，表示接收的数据总量+1
}
}
else
{ //反之connectFlag等于1，连接上服务器了
Usart2_RxBuff[Usart2_RxCounter] = USART2->DR; //把接收到的数据保存到Usart2_RxBuff中
if(Usart2_RxCounter == 0)
{ //如果Usart2_RxCounter等于0，表示是接收的第1个数据，进入if分支
TIM_Cmd(TIM4, ENABLE);
}
else //else分支，表示果Usart2_RxCounter不等于0，不是接收的第一个数据
{
TIM_SetCounter(TIM4, 0);
}
Usart2_RxCounter++; //每接收1个字节的数据，Usart2_RxCounter加1，表示接收的数据总量+1
}
}
}

复制代码

/*----------------------------------------------------------*/
/*函数名：初始化接收,发送,命令数据的缓冲区以及各状态参数 */
/*参数：无 */
/*返回值：无 */
/*----------------------------------------------------------*/
void MQTT_Buff_Init(void)
{
MQTT_RxDataInPtr=MQTT_RxDataBuf[0]; //指向发送缓冲区存放数据的指针归位
MQTT_RxDataOutPtr=MQTT_RxDataInPtr; //指向发送缓冲区读取数据的指针归位
MQTT_RxDataEndPtr=MQTT_RxDataBuf[R_NUM-1]; //指向发送缓冲区结束的指针归位
MQTT_TxDataInPtr=MQTT_TxDataBuf[0]; //指向发送缓冲区存放数据的指针归位
MQTT_TxDataOutPtr=MQTT_TxDataInPtr; //指向发送缓冲区读取数据的指针归位
MQTT_TxDataEndPtr=MQTT_TxDataBuf[T_NUM-1]; //指向发送缓冲区结束的指针归位
MQTT_CMDInPtr=MQTT_CMDBuf[0]; //指向命令缓冲区存放数据的指针归位
MQTT_CMDOutPtr=MQTT_CMDInPtr; //指向命令缓冲区读取数据的指针归位
MQTT_CMDEndPtr=MQTT_CMDBuf[C_NUM-1]; //指向命令缓冲区结束的指针归位
MQTT_ConectPack(); //发送缓冲区添加连接报文
MQTT_Subscribe(S_TOPIC_NAME,0); //发送缓冲区添加订阅topic，等级0
pingFlag = connectPackFlag = subcribePackFlag = 0; //各个参数清零
}
/*----------------------------------------------------------*/
/*函数名：云初始化参数，得到客户端ID，用户名和密码 */
/*参数：无 */
/*返回值：无 */
/*----------------------------------------------------------*/
void IoT_Parameter_Init(void)
{
memset(ClientID,0,128); //客户端ID的缓冲区全部清零
sprintf(ClientID,"%s",DEVICEID); //构建客户端ID，并存入缓冲区
ClientID_len = strlen(ClientID); //计算客户端ID的长度
memset(Username,0,128); //用户名的缓冲区全部清零
sprintf(Username,"%s",PRODUCTID); //构建用户名，并存入缓冲区
Username_len = strlen(Username); //计算用户名的长度
memset(Passward,0,128); //用户名的缓冲区全部清零
sprintf(Passward,"%s",AUTHENTICATION); //构建密码，并存入缓冲区
Passward_len = strlen(Passward); //计算密码的长度
memset(ServerIP,0,128);
sprintf(ServerIP,"%s","183.230.40.39"); //构建服务器域名
ServerPort = 6002; //服务器端口号6002
u1_printf("服务器：%s:%d\r\n",ServerIP,ServerPort); //串口输出调试信息
u1_printf("客户端ID：%s\r\n",ClientID); //串口输出调试信息
u1_printf("用户名：%s\r\n",Username); //串口输出调试信息
u1_printf("密码：%s\r\n",Passward); //串口输出调试信息
}
/*----------------------------------------------------------*/
/*函数名：连接服务器报文 */
/*参数：无 */
/*返回值：无 */
/*----------------------------------------------------------*/
void MQTT_ConectPack(void)
{
int temp,Remaining_len;
Fixed_len = 1; //连接报文中，固定报头长度暂时先=1
Variable_len = 10; //连接报文中，可变报头长度=10
Payload_len = 2 + ClientID_len + 2 + Username_len + 2 + Passward_len; //连接报文中，负载长度
Remaining_len = Variable_len + Payload_len; //剩余长度=可变报头长度+负载长度
temp_buff[0]=0x10; //固定报头第1个字节：固定0x01
do{ //循环处理固定报头中的剩余长度字节，字节量根据剩余字节的真实长度变化
temp = Remaining_len%128; //剩余长度取余128
Remaining_len = Remaining_len/128; //剩余长度取整128
if(Remaining_len>0)
temp |= 0x80; //按协议要求位7置位
temp_buff[Fixed_len] = temp; //剩余长度字节记录一个数据
Fixed_len++; //固定报头总长度+1
}while(Remaining_len > 0); //如果Remaining_len>0的话，再次进入循环
temp_buff[Fixed_len + 0] = 0x00; //可变报头第1个字节：固定0x00
temp_buff[Fixed_len + 1] = 0x04; //可变报头第2个字节：固定0x04
temp_buff[Fixed_len + 2] = 0x4D; //可变报头第3个字节：固定0x4D
temp_buff[Fixed_len + 3] = 0x51; //可变报头第4个字节：固定0x51
temp_buff[Fixed_len + 4] = 0x54; //可变报头第5个字节：固定0x54
temp_buff[Fixed_len + 5] = 0x54; //可变报头第6个字节：固定0x54
temp_buff[Fixed_len + 6] = 0x04; //可变报头第7个字节：固定0x04
temp_buff[Fixed_len + 7] = 0xC2; //可变报头第8个字节：使能用户名和密码校验，不使用遗嘱，不保留会话
temp_buff[Fixed_len + 8] = 0x00; //可变报头第9个字节：保活时间高字节 0x00
temp_buff[Fixed_len + 9] = 0x64; //可变报头第10个字节：保活时间高字节 0x64 100s
/* CLIENT_ID */
temp_buff[Fixed_len+10] = ClientID_len/256; //客户端ID长度高字节
temp_buff[Fixed_len+11] = ClientID_len%256; //客户端ID长度低字节
memcpy(&temp_buff[Fixed_len+12],ClientID,ClientID_len); //复制过来客户端ID字串
/* 用户名 */
temp_buff[Fixed_len+12+ClientID_len] = Username_len/256; //用户名长度高字节
temp_buff[Fixed_len+13+ClientID_len] = Username_len%256; //用户名长度低字节
memcpy(&temp_buff[Fixed_len+14+ClientID_len],Username,Username_len); //复制过来用户名字串
/* 密码 */
temp_buff[Fixed_len+14+ClientID_len+Username_len] = Passward_len/256; //密码长度高字节
temp_buff[Fixed_len+15+ClientID_len+Username_len] = Passward_len%256; //密码长度低字节
memcpy(&temp_buff[Fixed_len+16+ClientID_len+Username_len],Passward,Passward_len); //复制过来密码字串
TxDataBuf_Deal(temp_buff, Fixed_len + Variable_len + Payload_len); //加入发送数据缓冲区
}
/*----------------------------------------------------------*/
/*函数名：SUBSCRIBE订阅topic报文 */
/*参数：QoS：订阅等级 */
/*参数：topic_name：订阅topic报文名称 */
/*返回值：无 */
/*----------------------------------------------------------*/
void MQTT_Subscribe(char *topic_name, int QoS)
{
Fixed_len = 2; //SUBSCRIBE报文中，固定报头长度=2
Variable_len = 2; //SUBSCRIBE报文中，可变报头长度=2
Payload_len = 2 + strlen(topic_name) + 1; //计算有效负荷长度 = 2字节(topic_name长度)+ topic_name字符串的长度 + 1字节服务等级
temp_buff[0] = 0x82; //第1个字节：固定0x82
temp_buff[1] = Variable_len + Payload_len; //第2个字节：可变报头+有效负荷的长度
temp_buff[2] = 0x00; //第3个字节：报文标识符高字节，固定使用0x00
temp_buff[3] = 0x01; //第4个字节：报文标识符低字节，固定使用0x01
temp_buff[4] = strlen(topic_name)/256; //第5个字节：topic_name长度高字节
temp_buff[5] = strlen(topic_name)%256; //第6个字节：topic_name长度低字节
memcpy(&temp_buff[6], topic_name, strlen(topic_name)); //第7个字节开始：复制过来topic_name字串
temp_buff[6 + strlen(topic_name)] = QoS; //最后1个字节：订阅等级
TxDataBuf_Deal(temp_buff, Fixed_len + Variable_len + Payload_len); //加入发送数据缓冲区
}
/*----------------------------------------------------------*/
/*函数名：PING报文，心跳包 */
/*参数：无 */
/*返回值：无 */
/*----------------------------------------------------------*/
void MQTT_PingREQ(void)
{
temp_buff[0] = 0xC0; //第1个字节：固定0xC0
temp_buff[1] = 0x00; //第2个字节：固定0x00
TxDataBuf_Deal(temp_buff, 2); //加入数据到缓冲区
}
/*----------------------------------------------------------*/
/*函数名：等级0 发布消息报文 */
/*参数：topic_name：topic名称 */
/*参数：data：数据 */
/*参数：data_len：数据长度 */
/*返回值：无 */
/*----------------------------------------------------------*/
void MQTT_PublishQs0(char *topic, char *data, int data_len)
{
int temp,Remaining_len;
Fixed_len = 1; //固定报头长度暂时先等于：1字节
Variable_len = 2 + strlen(topic); //可变报头长度：2字节(topic长度)+ topic字符串的长度
Payload_len = data_len; //有效负荷长度：就是data_len
Remaining_len = Variable_len + Payload_len; //剩余长度=可变报头长度+负载长度
temp_buff[0] = 0x30; //固定报头第1个字节：固定0x30
do{ //循环处理固定报头中的剩余长度字节，字节量根据剩余字节的真实长度变化
temp = Remaining_len%128; //剩余长度取余128
Remaining_len = Remaining_len/128; //剩余长度取整128
if(Remaining_len>0)
temp |= 0x80; //按协议要求位7置位
temp_buff[Fixed_len] = temp; //剩余长度字节记录一个数据
Fixed_len++; //固定报头总长度+1
}while(Remaining_len>0); //如果Remaining_len>0的话，再次进入循环
temp_buff[Fixed_len+0] = strlen(topic)/256; //可变报头第1个字节：topic长度高字节
temp_buff[Fixed_len+1] = strlen(topic)%256; //可变报头第2个字节：topic长度低字节
memcpy(&temp_buff[Fixed_len+2], topic,strlen(topic)); //可变报头第3个字节开始：拷贝topic字符串
memcpy(&temp_buff[Fixed_len + 2 + strlen(topic)], data, data_len);//有效负荷：拷贝data数据
TxDataBuf_Deal(temp_buff, Fixed_len + Variable_len + Payload_len);//加入发送数据缓冲区
}
/*----------------------------------------------------------*/
/*函数名：处理服务器发来的等级0的推送 */
/*参数：redata：接收的数据 */
/*返回值：无 */
/*----------------------------------------------------------*/
void MQTT_DealPushdata_Qs0(unsigned char *redata)
{
int re_len; //定义一个变量，存放接收的数据总长度
int pack_num; //定义一个变量，当多个推送一起过来时，保存推送的个数
int temp,temp_len; //定义一个变量，暂存数据
int totle_len; //定义一个变量，存放已经统计的推送的总数据量
int topic_len; //定义一个变量，存放推送中主题的长度
int cmd_len; //定义一个变量，存放推送中包含的命令数据的长度
int cmd_loca; //定义一个变量，存放推送中包含的命令的起始位置
int i; //定义一个变量，用于for循环
int local,multiplier;
unsigned char tempbuff[RBUFF_UNIT]; //临时缓冲区
unsigned char *data; //redata过来的时候，第一个字节是数据总量，data用于指向redata的第2个字节，真正的数据开始的地方
re_len = redata[0]*256+redata[1]; //获取接收的数据总长度
data = &redata[2]; //data指向redata的第2个字节，真正的数据开始的
pack_num = temp_len = totle_len = temp = 0; //各个变量清零
local = 1;
multiplier = 1;
do{
pack_num++; //开始循环统计推送的个数，每次循环推送的个数+1
do{
temp = data[totle_len + local];
temp_len += (temp & 127) * multiplier;
multiplier *= 128;
local++;
}while ((temp & 128) != 0);
totle_len += (temp_len + local); //累计统计的总的推送的数据长度
re_len -= (temp_len + local) ; //接收的数据总长度减去本次统计的推送的总长度
local = 1;
multiplier = 1;
temp_len = 0;
}while(re_len!=0); //如果接收的数据总长度等于0了，说明统计完毕了
u1_printf("本次接收了%d个推送数据\r\n",pack_num); //串口输出信息
temp_len = totle_len = 0; //各个变量清零
local = 1;
multiplier = 1;
for(i = 0; i < pack_num; i++) //已经统计到了接收的推送个数，开始for循环，取出每个推送的数据
{
do{
temp = data[totle_len + local];
temp_len += (temp & 127) * multiplier;
multiplier *= 128;
local++;
}while ((temp & 128) != 0);
topic_len = data[local + totle_len]*256 + data[local + 1 + totle_len] + 2; //计算本次推送数据中主题占用的数据量
cmd_len = temp_len - topic_len; //计算本次推送数据中命令数据占用的数据量
cmd_loca = totle_len + local + topic_len; //计算本次推送数据中命令数据开始的位置
memcpy(tempbuff, &data[cmd_loca], cmd_len); //命令数据拷贝出来
CMDBuf_Deal(tempbuff, cmd_len); //加入命令到缓冲区
totle_len += (temp_len + local); //累计已经统计的推送的数据长度
local = 1;
multiplier = 1;
temp_len = 0;
}
}
/*----------------------------------------------------------*/
/*函数名：处理发送缓冲区 */
/*参数：data：数据 */
/*参数：size：数据长度 */
/*返回值：无 */
/*----------------------------------------------------------*/
void TxDataBuf_Deal(unsigned char *data, int size)
{
memcpy(&MQTT_TxDataInPtr[2], data, size); //拷贝数据到发送缓冲区
MQTT_TxDataInPtr[0] = size/256; //记录数据长度
MQTT_TxDataInPtr[1] = size%256; //记录数据长度
MQTT_TxDataInPtr += TBUFF_UNIT; //指针下移
if(MQTT_TxDataInPtr == MQTT_TxDataEndPtr) //如果指针到缓冲区尾部了
MQTT_TxDataInPtr = MQTT_TxDataBuf[0]; //指针归位到缓冲区开头
}
/*----------------------------------------------------------*/
/*函数名：处理命令缓冲区 */
/*参数：data：数据 */
/*参数：size：数据长度 */
/*返回值：无 */
/*----------------------------------------------------------*/
void CMDBuf_Deal(unsigned char *data, int size)
{
memcpy(&MQTT_CMDInPtr[2], data,size); //拷贝数据到命令缓冲区
MQTT_CMDInPtr[0] = size/256; //记录数据长度
MQTT_CMDInPtr[1] = size%256; //记录数据长度
MQTT_CMDInPtr[size+2] = '\0'; //加入字符串结束符
MQTT_CMDInPtr += CBUFF_UNIT; //指针下移
if(MQTT_CMDInPtr == MQTT_CMDEndPtr) //如果指针到缓冲区尾部了
MQTT_CMDInPtr = MQTT_CMDBuf[0]; //指针归位到缓冲区开头
}

复制代码