STM32驱动BC260Y连接阿里云平台并上报物模型数据

BC260Y连接阿里云平台

本次实验用到移远BC260Y-CN芯片连接阿里云平台进行物模型数据上传，利用STM32L051C8T6与BC260Y模组进行连接。

一、硬件连接

STM32L051C8T6	BC260Y
5V	VIN
GND	GND
TX	RXD
RX	TXD

硬件实物图

二、代码及介绍

1.串口初始化：程序中利用串口2来打印出BC260Y模块返回的响应信息，串口1用来向BC260Y发送AT指令。

usart.c

#include "usart.h"

/* USER CODE BEGIN 0 */
#include "string.h"
#include "stdio.h"

UARTTYPE uartType1,uartType2;

#if 1
#pragma import(__use_no_semihosting)

struct __FILE
{
	int handle;
};

FILE __stdout;

void _sys_exit(int x)
{
	x=x;
}

int fputc(int ch,FILE *f)
{
	HAL_UART_Transmit(&huart2,(uint8_t *)&ch,1,HAL_MAX_DELAY);
	   return  ch;
}

int fgetc(FILE *f)
{
	uint8_t ch = 0;
	HAL_UART_Receive(&huart2,&ch,1,0xffff);
	return ch ;
}
#endif

HAL_StatusTypeDef status;
/* USER CODE END 0 */

UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart1_rx;
DMA_HandleTypeDef hdma_usart1_tx;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;

/* USART1 init function */

void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  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.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
 __HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE);
  /* USER CODE END USART1_Init 2 */

}
/* USART2 init function */

void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  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.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */
 __HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE);
  /* USER CODE END USART2_Init 2 */

}

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspInit 0 */

  /* USER CODE END USART1_MspInit 0 */
    /* USART1 clock enable */
    __HAL_RCC_USART1_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF4_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* USART1 DMA Init */
    /* USART1_RX Init */
    hdma_usart1_rx.Instance = DMA1_Channel3;
    hdma_usart1_rx.Init.Request = DMA_REQUEST_3;
    hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_rx.Init.Mode = DMA_NORMAL;
    hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx);

    /* USART1_TX Init */
    hdma_usart1_tx.Instance = DMA1_Channel2;
    hdma_usart1_tx.Init.Request = DMA_REQUEST_3;
    hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart1_tx.Init.Mode = DMA_NORMAL;
    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx);

    /* USART1 interrupt Init */
    HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspInit 1 */

  /* USER CODE END USART1_MspInit 1 */
  }
  else if(uartHandle->Instance==USART2)
  {
  /* USER CODE BEGIN USART2_MspInit 0 */

  /* USER CODE END USART2_MspInit 0 */
    /* USART2 clock enable */
    __HAL_RCC_USART2_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**USART2 GPIO Configuration
    PA2     ------> USART2_TX
    PA3     ------> USART2_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF4_USART2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* USART2 DMA Init */
    /* USART2_RX Init */
    hdma_usart2_rx.Instance = DMA1_Channel5;
    hdma_usart2_rx.Init.Request = DMA_REQUEST_4;
    hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart2_rx.Init.Mode = DMA_NORMAL;
    hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart2_rx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart2_rx);

    /* USART2_TX Init */
    hdma_usart2_tx.Instance = DMA1_Channel4;
    hdma_usart2_tx.Init.Request = DMA_REQUEST_4;
    hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart2_tx.Init.Mode = DMA_NORMAL;
    hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;
    if (HAL_DMA_Init(&hdma_usart2_tx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart2_tx);

    /* USART2 interrupt Init */
    HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(USART2_IRQn);
  /* USER CODE BEGIN USART2_MspInit 1 */

  /* USER CODE END USART2_MspInit 1 */
  }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{

  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspDeInit 0 */

  /* USER CODE END USART1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART1_CLK_DISABLE();

    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);

    /* USART1 DMA DeInit */
    HAL_DMA_DeInit(uartHandle->hdmarx);
    HAL_DMA_DeInit(uartHandle->hdmatx);

    /* USART1 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspDeInit 1 */

  /* USER CODE END USART1_MspDeInit 1 */
  }
  else if(uartHandle->Instance==USART2)
  {
  /* USER CODE BEGIN USART2_MspDeInit 0 */

  /* USER CODE END USART2_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART2_CLK_DISABLE();

    /**USART2 GPIO Configuration
    PA2     ------> USART2_TX
    PA3     ------> USART2_RX
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3);

    /* USART2 DMA DeInit */
    HAL_DMA_DeInit(uartHandle->hdmarx);
    HAL_DMA_DeInit(uartHandle->hdmatx);

    /* USART2 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART2_IRQn);
  /* USER CODE BEGIN USART2_MspDeInit 1 */

  /* USER CODE END USART2_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */
void UART_Receive_IDLE(UART_HandleTypeDef *huart)
{
	uint32_t temp1;
	if((__HAL_UART_GET_FLAG(huart,UART_FLAG_IDLE) != RESET))
	{ 
		__HAL_UART_CLEAR_IDLEFLAG(huart);
		HAL_UART_DMAStop(huart);
		temp1 = huart->hdmarx->Instance->CNDTR;
		if(huart->Instance == huart1.Instance)
		{
			uartType1.rxLen =  UARTRXLEN - temp1; 
			uartType1.idle=1;
			HAL_UART_Receive_DMA(&huart1,(uint8_t *)uartType1.rxBuf,UARTRXLEN);

		}
		if(huart->Instance==huart2.Instance)
		{	
			uartType2.rxLen =  UARTRXLEN - temp1; 
			uartType2.idle=1;
			HAL_UART_Receive_DMA(&huart2,(uint8_t *)uartType2.rxBuf,UARTRXLEN);

		}
	}
}



void Uart1_SendStr(char*SendBuf)
{
	while(*SendBuf != '\0')
	{
    status = HAL_UART_Transmit(&huart1,(uint8_t *)SendBuf,1,HAL_MAX_DELAY);
		if(status != HAL_OK)
		{
		}
		SendBuf++;
	}
}


/* USER CODE END 1 */

2.BC260Y初始化，MQTT初始化

strstr（）函数 是C/C++标准库中的一个字符串处理函数，用于在一个字符串中查找另一个子字符串的第一次出现位置

BC260Y.c

#include "bc260y.h"
#include "usart.h"
#include "stdio.h"
#include "string.h"

char *strx,*extstrx;
char atstr[UARTRXLEN];
BC260Y BC260Y_Status;

只要修改三要素/
#define PRODUCEKEY "k0bbaj3J61l"        //修改产品秘钥
#define DEVICENAME "NBLX"           //修改设备名称
#define DEVICESECRET "816d9c9166fc012ab57ac0e3010d878a" //修改设备秘钥

#define PubTopic        "/sys/k0bbaj3J61l/NBLX/thing/event/property/post"//发布主题
#define SubTopic        "/sys/k0bbaj3J61l/NBLX/thing/service/property/set"//订阅主题
///

void Clear_Buffer(void)  //清空缓存
	{
		printf((const char *)uartType1.rxBuf);
		delay_ms(500);
		uartType1.idle=0;
		memset(uartType1.rxBuf,0,UARTRXLEN);
	}
	


void BC260Y_Init(void)
{
		Uart1_SendStr("AT+QRST=?\r\n");
		delay_ms(2000);
		printf((const char *)uartType1.rxBuf);
//		strx=strstr((const char *)uartType1.rxBuf,(const char *)"OK");
		Clear_Buffer();	
	
		Uart1_SendStr("ATI\r\n");
		delay_ms(500);
		printf((const char *)uartType1.rxBuf);
		strx=strstr((const char *)uartType1.rxBuf,(const char *)"OK");
		Clear_Buffer();

		Uart1_SendStr("AT+QSCLK=0\r\n");   //禁止休眠
		delay_ms(500);
	  printf(uartType1.rxBuf);
	
    Uart1_SendStr("AT+CFUN=1\r\n");    //打开全功能模式
    delay_ms(500);
    printf(uartType1.rxBuf);
	
    Uart1_SendStr("AT+CIMI\r\n");   //获取卡号，类似是否存在卡的意思，比较重要。
    delay_ms(500);
    strx=strstr((const char*)uartType1.rxBuf,(const char*)"ERROR");//返460，表明识别到卡了		
		
    if(strx==NULL)
		{
				printf("我的卡号是:%s \r\n",&uartType1.rxBuf[11]);
				Clear_Buffer();	
		}
		else
		{
				printf("卡错误： %s \r\n",uartType2.rxBuf);
				Clear_Buffer();
		}
		
		Uart1_SendStr("AT+CGATT=1\r\n");//激活网络，PDP
		delay_ms(500);
		strx=strstr((const char*)uartType1.rxBuf,(const char*)"OK");//返OK
		Clear_Buffer();	
		
		Uart1_SendStr("AT+CGATT?\r\n");//查询激活状态
//		 printf("AT+CGATT?\r\n");
		delay_ms(500);
		printf("recv=%s \r\n",uartType1.rxBuf);
		strx=strstr((const char*)uartType1.rxBuf,(const char*)"+CGATT: 1");//返1

//	 while(strx==NULL)
//		{
//				Clear_Buffer();	
//				Uart1_SendStr("AT+CGATT?\r\n");//获取激活状态
//				delay_ms(1000);
//				printf("recv=%s \r\n",uartType1.rxBuf);
//				strx=strstr((const char*)uartType1.rxBuf,(const char*)"+CGATT: 1");//返回1,表明注网成功
//		}
		
			Uart1_SendStr("AT+CSQ\r\n");//查看获取CSQ值
			delay_ms(500);
		 strx=strstr((const char*)uartType1.rxBuf,(const char*)"+CSQ");
		 if(strx)
		 {
			 printf("信号质量:%s\r\n", uartType1.rxBuf);
			 Clear_Buffer();
			 delay_ms(500);
		 }
			Clear_Buffer();	
}
	
char ServerIP[128]={0};

void  MQTT_Init(void)    //MQTT初始化
{
			memset(atstr,0,UARTRXLEN);
			sprintf(atstr,"AT+QMTCFG=\"aliauth\",0,\"%s\",\"%s\",\"%s\"\r\n",PRODUCEKEY,DEVICENAME,DEVICESECRET);
			printf("atstr = %s \r\n",atstr);
			Uart1_SendStr(atstr);//发送阿里云配置参数
			delay_ms(1000);  //等待300ms反馈OK
			printf("recv = %s \r\n",uartType1.rxBuf);
			strx=strstr((const char*)uartType1.rxBuf,(const char*)"OK");//返OK

			while(strx==NULL)
			{
					delay_ms(100);
					strx=strstr((const char*)uartType1.rxBuf,(const char*)"OK");//返OK 
			}

			Clear_Buffer();
			
			sprintf(ServerIP,"AT+QMTOPEN=0,\"%s.iot-as-mqtt.cn-shanghai.aliyuncs.com\",1883\r\n",PRODUCEKEY);
			printf("atstr = %s \r\n",ServerIP);
			Uart1_SendStr(ServerIP);//登录阿里云平台
			
			delay_ms(1000);
			printf("recv = %s \r\n",uartType1.rxBuf);
			strx=strstr((const char*)uartType1.rxBuf,(const char*)"+QMTOPEN: 0,0");//返+QMTOPEN: 0,0
			while(strx==NULL)
			{
				delay_ms(100);
				strx=strstr((const char*)uartType1.rxBuf,(const char*)"+QMTOPEN: 0,0");//确认返回值正确
			}
			
			Clear_Buffer(); 			
			memset(atstr,0,UARTRXLEN);
			
			sprintf(atstr,"AT+QMTCONN=0,\"%s\"\r\n",DEVICENAME);  //|securemode=3,signmethod=hmacsha1|
			printf("atstr = %s \r\n",atstr);
			Uart1_SendStr(atstr);//发送链接到阿里云
			delay_ms(500);
			printf("recv = %s \r\n",uartType1.rxBuf);
			strx=strstr((const char*)uartType1.rxBuf,(const char*)"+QMTCONN: 0,0,0");//返+QMTCONN: 0,0,0
			while(strx==NULL)
			{
					strx=strstr((const char*)uartType1.rxBuf,(const char*)"+QMTCONN: 0,0,0");//返+QMTCONN: 0,0,0

			}
			Clear_Buffer();
}


void aliyunMQTT_PUBdata(uint8_t TiltValue,uint8_t CoverState)   //向云端发送数据
{
		 uint8_t t_payload[200],len;
     sprintf(atstr,"AT+QMTPUB=0,0,0,0,%s\r\n",PubTopic);//发布主题
	   printf("atstr = %s",atstr);
	   Uart1_SendStr(atstr);
     delay_ms(500);
	   strx=strstr((const char*)uartType1.rxBuf,(const char *)">");
		while(strx==NULL)
		{
				strx=strstr((const char*)uartType1.rxBuf,(const char*)">");//返>

		}
			Clear_Buffer();
			
     len=Mqtt_Savedata(t_payload,TiltValue,CoverState);
     t_payload[len+1]=0x00;
	 
			sprintf(atstr,"%s",t_payload);
	   	printf("atstr = %s \r\n",atstr);
	    Uart1_SendStr(atstr);
	    delay_ms(300);
			
			while((USART1->ISR&0X40)==0){}		
		  USART1->TDR=(uint8_t )0x1A;
			
		
      delay_ms(100);
     strx=strstr((const char*)uartType1.rxBuf,(const char*)"+QMTPUB: 0,0,0");//看下返回状态
		while(strx==NULL)
    {
			delay_ms(300);
      strx=strstr((const char*)uartType1.rxBuf,(const char*)"+QMTPUB: 0,0,0");//看下返回状态
    }
    Clear_Buffer(); 
}



//访问阿里云需要提交JSON数据
uint8_t Mqtt_Savedata(uint8_t*t_payload,uint8_t TiltValue,uint8_t CoverState)
{
	//	char json[]="{\"id\":\"26\",\"version\":\"1.0\",\"params\":{\"CoverState\":\"value\":%d,\"TiltValue\":\"value\":%d.3},\"method\":\"thing.event.property.post\"}";
	  char json[]="{\"id\":\"28\",\"version\":\"1.0\",\"params\":{\"CoverState\":{\"value\":%d},\"TiltValue\":{\"value\":%d.2}},\"method\":\"thing.event.property.post\"}";
	
		char t_json[200];
    unsigned short json_len;
    sprintf(t_json, json,CoverState, TiltValue);
    json_len = strlen(t_json)/sizeof(char);
  	memcpy(t_payload, t_json, json_len);
    return json_len;
}

3.主函数的while中实现数据的发布与上传

  uint8_t TiltValue, CoverState; 分别为井盖倾斜度和井盖状态两个物模型数据

int main(void)
{
  /* USER CODE BEGIN 1 */
  uint8_t TiltValue, CoverState;

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();
  delay_init(72);
  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART1_UART_Init();  //串口1初始化
  MX_USART2_UART_Init();  //串口2初始化
  /* USER CODE BEGIN 2 */
     BC260Y_Init(); //BC260Y初始化
		 MQTT_Init();   //MQTT初始化
  /* USER CODE END 2 */
	
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
	printf("BC26Y ALIYUN DEMO \r\n");
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		  CoverState=0;
		  TiltValue=22;
      aliyunMQTT_PUBdata(TiltValue,CoverState);  //上传数据
		  delay_ms(2000);
			delay_ms(2000);
			delay_ms(2000);

  }
  /* USER CODE END 3 */
}

4.结果显示

井盖状态和倾斜度数据上传成功