Prepare

• Software environment: Windows
• Hardware environment: STM32F103 + W5500
• Development tools: Keil uVision5
• Debugging Tool: Serial Debugging Wizard
• Connected platform: Baidu Yuntiangong ( https://cloud.baidu.com/）

2. Introduction to MQTT

MQTT official website address: ( http://mqtt.org/）

2.1 Characteristics of the MQTT protocol

MQTT is a client-server based message publish/subscribe transmission protocol. The MQTT protocol is lightweight, simple, open, and easy to implement. These characteristics make it applicable to a wide range. In many cases, including restricted environments such as machine-to-machine (M2M) communication and the Internet of Things (IoT). It has been widely used in satellite sensors to communicate with sensors, occasionally marking medical devices, smart homes, and some miniaturized devices.

The current version of the MQTT protocol is MQTT v3.1.1 released in 2014. In addition to the standard version, there is a simplified version of MQTT-SN. This protocol is primarily for embedded devices. These devices typically work on hundreds of TCP/IP networks, such as: ZigBee.

The MQTT protocol runs on TCP/IP or other network protocols and provides lossless and orderly bidirectional connections. Its features include:

• The publish/subscribe message pattern used, which provides one-to-many message distribution to decouple applications.
• Message transmission mechanism that protects the content of the payload.
• There are three types of Quality of Service (QoS) for transmitting messages:
• At most once, message loss or duplication can occur at this level, and message distribution depends on the underlying TCP/IP network. That is: <= 1
• At most once, this level ensures that messages arrive, but messages may be duplicates. That is: >= 1
• Only once, make sure that the message arrives only once. That is: = 1. This level can be used in some more demanding billing systems.

Minimize data transmission and protocol exchange (protocol header is only 2 bytes) to reduce network traffic

Notification mechanism

2.2 MQTT Protocol principle and implementation

Need to implement the MQTT protocol: client and server

There are three types of identities in the MQTT protocol: publisher, broker (server), and subscriber (subscribe). Among them, the publisher and subscriber of a message are both clients, the message broker is a server, and the publisher of a message can also be a subscriber.

Messages transmitted by MQTT are divided into two parts: subject and message payload.

The topic can be understood as the type of message. After a subscriber subscribes, they will receive the message content (payload) of the topic.

The payload, which can be understood as the content of the message, refers to the content that the subscriber specifically wants to use

2.3 Baidu Yuntiang MQTT connection steps

2.3.1. Enter the management console（Please login in advance）；

23. 2. Select the “IoT Access IoT Hub” section

23. 3. Create a project

(The routine is used with data type equipment. For detailed information on data type and equipment type differences, please go to Baidu Yuntiangong for inquiries)

23. 4. After submitting the project, enter the project creation sub-user

Name: the username in the MQTT connection message

Identity: determine the way of access, you can use a key connection.

Strategy: Link permissions and corresponding themes.

Key: Keep it safe. This is the password for the connection. (Forgetting can be reset in the identity list)

After the project has been created successfully, register: name, identity, key. You can modify the corresponding string through the routine to connect the device you created.

3. Routine experimental phenomenon

First, we must look at the experimental phenomenon after the programming process.

Note: The test of receiving messages and posting messages to the topics after the W5100S subscribes to the topic is the establishment of the second device B in Baidu Cloud. Device B broadcasts a message and receives a topic message from the W5100S. This is to check if the W5100S can receive the subject message or send it.

3.1 The serial port prints the message “Connection successful” or “Specific reason for connection failure”.

3.2 Subscribe to topics

3.3. Receive topic messages

3.4. Post a topic message

4. Example code

Because the code involves the unpacking part of MQTT, the detailed explanation is too detailed.

Therefore, this discussion only discusses function functions and code frameworks, and does not disassemble function implementation too much.

4.1. The general framework flow of the main function

1. #include <stdio.h>
2. #include <string.h>
3. #include “stm32f10x.h”
5. #include “bsp_usart1.h”
6. #include “bsp_fsmc.h”
7. #include “bsp_spi.h”
9. #include “w5100s.h”
10. #include “W5100s_conf.h”
11. #include “wizchip_conf.h”
12. #include “w5100s_conf.h”
14. #include “utility.h”
15. #include “tcp_demo.h”
16. #include “MqttKit.h”
18. int main(void)
19. {
20. systick_init (72); // Inicializa el temporizador de tic
21. USART1_Config (); // Inicializar USART1: 115200 @ 8-N-1
22. reset_break_gpio_init (); // Restablecer e interrumpir la inicialización del pin
23. #if (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_)
24. spi_gpio_init (); // inicialización del pin SPI
25. spiinitailize (); // inicialización de configuración SPI
26. reg_wizchip_spi_cbfunc (spi_read_byte, spi_send_byte); // asignación de funciones de datos de lectura y escritura SPI
27. reg_wizchip_cs_cbfunc (cs_low, cs_high); // asignación de función de control de selección de chip SPI
28. #elif (_WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_BUS_INDIR_)
29. FSMC_gpio_init (); // Inicialización de pin FSMC c
30. FSMCInitialize (); // Inicialización de configuración de FSMC
31. #endif
32. printf (” r n Tecnología Wei Shi – agente oficial de WIZnet W5100S. Soporte técnico completo, gran ventaja de precio! r n r n”);
33. reset_w5100s (); // Restablecimiento de hardware W5100S
34. PHY_check (); // programa de verificación de cable de red
35. set_w5100s_mac (); // Establecer dirección W5100SMAC
36. set_w5100s_netinfo (); // Establecer parámetros de red W5100S
37. wizchip_init (txsize, rxsize); // Inicializa el tamaño del búfer de envío y recepción de 4 sockets
38. printf (” r n La configuración del parámetro de red W5100S está completa, utilice la dirección W5100SIP ‘PING’ de la computadora para verificar si la red es fluida”);
40. while (1) / * función para ejecución de bucle * /
41. {
42. do_tcp_client (); // prueba de bucle invertido de datos del cliente TCP
44. delay_ms(100);
46. if (Usuario1 == 0) // Suscribirse
47. {
48. while(User1 == 0);
49. MQTT_STATE = MQTT_PKT_SUBSCRIBE;
50. }
51. // if (KEY_5 == 0) // cancelar suscripción
52. // {
53. // MQTT_STATE = MQTT_PKT_UNSUBSCRIBE;
54. // }
55. si no (Usuario0 == 0) // Publicar
56. {
57. while(User0 == 0);
58. MQTT_STATE =MQTT_PKT_PUBLISH;
59. }
60. }
61. }

The main part of the function, the general framework of the code is still very clear.

The main function is the initialization part before using the microcontroller and the W5100S.

Inside main is the basic TCP client program and key discovery. The different keys change the different states of MQTT_STATE.

Let’s explore the do_tcp_client() function in detail.

4.2.do_tcp_client() function

1. uint8 buff [2048]; / * define un caché de 2 KB * /
2. uint8 BD_TG_server_ip [4] = {163,177,150,12}; // dirección IP del servidor BD_TG
3. uint16 BD_TG_server_port = 1883; // número de puerto del servidor BD_TG
6. int MQTT_STATE = MQTT_PKT_CONNECT; // conectar
7. const char * topics [] = {“test”}; // topic
8. uint8 BD_TG_ping_pak [2] = {0xC0,0x00}; // Mensaje de latido
10. unsigned char * data_ptr = NULL; // el puntero se refiere a nulo
11. /**
12. * @ breve función de demostración de bucle invertido del cliente TCP.
13. * @ param Ninguno
14. * @ return Ninguno
15. */
16. void do_tcp_client(void)
17. {
18. uint16 len=0;
20. switch (getSn_SR (SOCK_TCPC)) / * Obtener el estado del socket * /
21. {
22. caso SOCK_CLOSED: / * el socket está cerrado * /
23. socket(SOCK_TCPC,Sn_MR_TCP,local_port++,Sn_MR_ND);
24. break;
26. case SOCK_INIT: / * el socket está en estado de inicialización * /
27. connect (SOCK_TCPC, BD_TG_server_ip, BD_TG_server_port); / * servidor de conexión de socket * /
28. break;
30. case SOCK_ESTABLISHED: / * el socket está en estado de establecimiento de conexión * /
31. if(getSn_IR(SOCK_TCPC) & Sn_IR_CON)
32. {
33. setSn_IR (SOCK_TCPC, Sn_IR_CON); / * Borrar el bit de bandera de interrupción de recepción * /
34. }
36. len = getSn_RX_RSR (SOCK_TCPC); / * Definir len como la longitud de los datos recibidos * /
37. if(len>0)
38. {
39. recv (SOCK_TCPC, buff, len); / * Recibir datos del servidor * /
40. data_ptr = buff;
41. if(data_ptr != NULL)
42. BD_TG_RevPro(data_ptr);
43. if(publish_buf[0] == 0x31)
44. {
45. LED_ALL_ON;
46. }
47. else if(publish_buf[0] == 0x32)
48. {
49. LED_ALL_OFF;
50. }
51. }
53. switch(MQTT_STATE)
54. {
55. / * El protocolo MQTT está conectado a la plataforma de agente BD_TG * /
56. case MQTT_PKT_CONNECT:
57. BD_TG_DevLink();
58. MQTT_STATE = MQTT_PKT_PINGREQ;
59. break;
60. / * Suscribirse a temas * /
61. case MQTT_PKT_SUBSCRIBE:
62. BD_TG_Subscribe(topics,1);
63. MQTT_STATE = MQTT_PKT_PINGREQ;
64. break;
65. / * Mensaje de liberación de nivel Qos2 * /
66. case MQTT_PKT_PUBLISH:
68. BD_TG_Publish (* temas, “Prueba de publicación MQTT”); // Publicar un mensaje
69. delay_ms (300); // Espera la respuesta de la plataforma
70. / * Recibir PubRec enviado por la plataforma y responder a la respuesta de PubRel * /
71. len=getSn_RX_RSR(SOCK_TCPC);
72. recv(SOCK_TCPC,buff,len);
73. data_ptr = buff;
74. if(data_ptr != NULL)
75. BD_TG_RevPro(data_ptr);
76. delay_ms (100); // La respuesta de PubRel espera la respuesta de la plataforma
77. len=getSn_RX_RSR(SOCK_TCPC);
78. recv(SOCK_TCPC,buff,len);
79. data_ptr = buff;
80. if(data_ptr != NULL)
81. BD_TG_RevPro(data_ptr);
82. MQTT_STATE = MQTT_PKT_PINGREQ;
83. / * Enviar una respuesta Ping una vez cada 120 segundos para mantener una conexión larga * /
84. break;
85. case MQTT_PKT_UNSUBSCRIBE:
86. MQTT_UnSubscribe(topics,1);
87. MQTT_STATE = MQTT_PKT_PINGREQ;
88. break;
89. case MQTT_PKT_PINGREQ:
90. if(BD_TG_ping_time > 120)
91. {
92. send(SOCK_TCPC,BD_TG_ping_pak,2);
93. BD_TG_ping_time = 0;
94. }
95. break;
96. }
97. break;
99. case SOCK_CLOSE_WAIT: / * el socket está esperando para cerrarse * /
100. close(SOCK_TCPC);
101. break;
102. }
103. }

It is primarily a state machine write format. Basic TCP establishes a connection ( State SOCK_ESTABLISHED ), Depending on the state of the MQTT_STATE variable, it is considered that there are different cases, such as sending an MQTT connect message, MQTT subscribe message, MQTT message release, subscribe MQTT cancel message and an MQTT heartbeat message.

At first, it will first enter MQTT_PKT_CONNECT by default and send a connection packet. To connect to Baidu Cloud, the following parameters must be changed:。

1. #define PROID “7321ph4 / w5500” // Nombre completo del dispositivo
3. #define AUTH_INFO “23h0wtzkmmti982q” // clave API
5. #define DEVID “qwe” // identidad

The above information will be established by the customer when Baidu Cloud builds the device. We just need to copy the settings and replace the old strings.

And we The MQTT function is implemented, then the corresponding parameter characters of the following functions are replaced Alright

1. const char * topics [] = {“test”}; // topic
3. BD_TG_Subscribe (temas, 1); // Tema de suscripción, cantidad 1
5. BD_TG_Publish (* temas, “Prueba de publicación MQTT”); // Temas publicados, mensajes publicados
7. MQTT_UnSubscribe (temas, 1); // Temas no suscritos, cantidad 1

For basic subscription and MQTT publication, modify the above parameters to complete.

For other functions, you need to modify the corresponding parameters according to the function description in the package.

The above code is www.w5100s.com Within the 17.MQTT_BDTG routine, this routine has been tested and can be connected to the Baidu Tiangong Cloud platform normally to achieve MQTT subscription, publication and other related functions.