【N32G45x】N32G45x在RT-Thread中的应用

2万 · 2022-2-11 23:49

@21小跑堂
简单介绍N32G45x在RT-Thread中的应用，通过配置ESP8266建立WIFI与路由器之间的连接，并调通相关的网络，验证MQTT broker和N32G45x之间的通信功能。至于ESP8266要使用的AT指令和AT指令是什么，就需要自己去探索了，这里就不在赘述了，这里直接演示的是如何使用ESP8266上网了。
还有MQTT是什么和mqtt的通信机制，也不需要太详细的去了解，因为RT-Thread已经建立完成了底层，只需要知道如何去应用就行了。
后面可以使用mqtt.fx测试与终端设备的通信效果了。
一 N32G45x和RT-Thread的简单入门

1、下载RT-Thread studio的相关系统

通过https://www.rt-thread.org/page/studio.html下载RT-Thread studio，安装RT-threadstudio的过程就不再赘述了，傻瓜式安装即可。

2、打开RT-Thread studio软件，并点击建立新工程。选择RT-Thread 项目。

3、填写项目名称，选择要保存项目的位置，并且选择使用开发板。

4、在开发板选项中，选择N32G45的开发板。

如果选项中没有该开发板。则点击选择更多，去下载对应的开发板资料。并在打开的选项中选择N32G45的开发板并点击加载资源。我这里已经添加了N32G45的开发板，所以就不在选择和添加，加载按钮为灰色。

5、点击完成，创建工程文件。

6、生成的工程文件，如图所示，这里只是RT-Thread的验证工程文件，下载该程序以后，对应的LED会闪烁。

7、点击箭头1对工程文件进行编译，点击箭头2对下载工程文件。

8、选择DAP-link，并查看下载进度，如绿色框所示。这时，观察开发板，绿色的LED会按照每秒5次的频率进行闪烁。

二配置ESP8266，并联网。
1、双击RT-Thread -settings ，会弹出RT-Thread的软件包界面。

2、点击界面中的立即添加，出现安装包的界面，搜索AT_Device ,并点击安装。
返回界面以后，点击详细配置，这就会配置ESP8266和wifi了。

3、在这个界面，找到乐鑫ESP8266的选项，并填写wifi的账号和密码，并选择要使用的串口，我这里选择的时候uart2.

4、点击保存，会重新生成工程文件

5、差点忘了，需要激活串口2，重新进入该界面，找到硬件哪里，在UART选项处选择UART2，并使能UART，并重新保存。

6、重新编译该程序，并下载。对于ESP8266的更新AT固件就不在这里赘述了，可以搜索有大量的教程可以参考。
并ESP8266的引脚与PA2和PA3进行连接，当然肯定是ESP8266的TX-PA3，ESP8266的RX-PA2。
在编译的过程中会弹出这个错误的。因为在这个文件中缺少了两个头文件
#include "stdio.h"
#include "string.h"
在文件中添加就没有问题了。

7、打开RT-Thread字典的终端，验证ESP8266是否连接成功呢

当出现这个的时候证明没有问题了。

[I/at.dev.esp] esp0 device wifi is connected.
[I/at.dev.esp] esp0 device network initialize successfully.

下面这个问题不需要管它

please check and update esp0 device firmware to support the "AT+CIPDNS_CUR?" cmd.

我们在终端中输入，测试一下网络是不是连接成功了。

ping www.baidu.com

百度对该命令有了回应，这里就证明，N32G45x已经通过esp8266与网络建立了链接，后续就可以开展相关的网络应用代码了。

这个参考代码在at_sample-esp8266文件下了。测试的代码

#include <at_device_esp8266.h>

#define LOG_TAG                      "at.sample.esp"
#include <at_log.h>

#define ESP8266_SAMPLE_DEIVCE_NAME    "esp0"

static struct at_device_esp8266 esp0 =
{
ESP8266_SAMPLE_DEIVCE_NAME,
ESP8266_SAMPLE_CLIENT_NAME,

ESP8266_SAMPLE_WIFI_SSID,
ESP8266_SAMPLE_WIFI_PASSWORD,
ESP8266_SAMPLE_RECV_BUFF_LEN,
};

static int esp8266_device_register(void)
{
struct at_device_esp8266 *esp8266 = &esp0;

return at_device_register(&(esp8266->device),
                           esp8266->device_name,
                           esp8266->client_name,
                           AT_DEVICE_CLASS_ESP8266,
                           (void *) esp8266);
}
INIT_APP_EXPORT(esp8266_device_register);

三测试MQTT

按照上述同样的方法，按照paho-mqtt的库，

在packages中找到paho-mqtt中的test文件夹，修改里面需要MQTT broker的信息，如下所示。

#define MQTT_URI             "tcp://iot.eclipse.org:1883"
#define MQTT_USERNAME          "admin"
#define MQTT_PASSWORD          "admin"
#define MQTT_SUBTOPIC          "/mqtt/test"
#define MQTT_PUBTOPIC          "/mqtt/test"
#define MQTT_WILLMSG          "Goodbye!"

将服务器的地址用户名密码和账号替换为自己的服务器的地址。

输入下面的命令

msh />mqtt_test start

测试MQTT测试是否完成

在终端平台上显示出这个数据，证明mqtt已经测试完成了。

QoS : 1
Cannot find a RTC device to provide time!
Test duration(sec)          : 0
Number of published  packages : 4
Number of subscribed packages : 4
Packet loss rate             : 0.00%
Number of reconnections    : 0

如何接收到mqtt发送过来的数据呢？测试代码中没有详细的介绍，
需要修改这个代码。

static void mqtt_sub_callback(MQTTClient *c, MessageData *msg_data)
{
sub_count ++;
return;
}

修改为

static void mqtt_sub_callback(MQTTClient *c, MessageData *msg_data)
{
rt_kprintf("msg_data: %s\n",(char *)msg_data->message->payload);
sub_count ++;
return;
}

你就可以在终端看到过来的数据了。
附上测试文件的详细代码。

myPrj.rar (12.91 MB)

#define MQTT_TEST_SERVER_URI "tcp://106.54.182.59:1883"
#define MQTT_CLIENTID          "123455"
#define MQTT_USERNAME          "BearPi"
#define MQTT_PASSWORD          "123456"
#define MQTT_SUBTOPIC          "/mqtt/test"
#define MQTT_PUBTOPIC          "/mqtt/test"
#define MQTT_WILLMSG          "Goodbye!"
#define MQTT_TEST_QOS          1
#define MQTT_PUB_SUB_BUF_SIZE 1024

#define CMD_INFO             "'mqtt_test <start|stop>'"
#define TEST_DATA_SIZE       256
#define PUB_CYCLE_TM          1000

static rt_thread_t pub_thread_tid = RT_NULL;

static char *pub_data = RT_NULL;

/* define MQTT client context */
static MQTTClient client;

static rt_uint32_t pub_count = 0, sub_count = 0;
static int recon_count = -1;
static int test_start_tm = 0;
static int test_is_started = 0;

static void mqtt_sub_callback(MQTTClient *c, MessageData *msg_data)
{
sub_count ++;
return;
}

static void mqtt_connect_callback(MQTTClient *c)
{
return;
}

static void mqtt_online_callback(MQTTClient *c)
{
recon_count ++;
return;
}

static void mqtt_offline_callback(MQTTClient *c)
{
return;
}

/**
* This function create and config a mqtt client.
*
* @param void
*
* @return none
*/
static void mq_start(void)
{
/* init condata param by using MQTTPacket_connectData_initializer */
MQTTPacket_connectData condata = MQTTPacket_connectData_initializer;

rt_memset(&client, 0, sizeof(MQTTClient));

/* config MQTT context param */
{
      client.uri = MQTT_TEST_SERVER_URI;

      /* config connect param */
      memcpy(&client.condata, &condata, sizeof(condata));
      client.condata.clientID.cstring = MQTT_CLIENTID;
      client.condata.keepAliveInterval = 60;
      client.condata.cleansession = 1;
      client.condata.username.cstring = MQTT_USERNAME;
      client.condata.password.cstring = MQTT_PASSWORD;

      /* config MQTT will param. */
      client.condata.willFlag = 1;
      client.condata.will.qos = MQTT_TEST_QOS;
      client.condata.will.retained = 0;
      client.condata.will.topicName.cstring = MQTT_PUBTOPIC;
      client.condata.will.message.cstring = MQTT_WILLMSG;

      /* malloc buffer. */
      client.buf_size = client.readbuf_size = MQTT_PUB_SUB_BUF_SIZE;
      client.buf = rt_malloc(client.buf_size);
      client.readbuf = rt_malloc(client.readbuf_size);
      if (!(client.buf && client.readbuf))
      {
         rt_kprintf("no memory for MQTT client buffer!\n");
         goto _exit;
      }

      /* set event callback function */
      client.connect_callback = mqtt_connect_callback;
      client.online_callback = mqtt_online_callback;
      client.offline_callback = mqtt_offline_callback;

      /* set subscribe table and event callback */
      client.messageHandlers[0].topicFilter = rt_strdup(MQTT_SUBTOPIC);
      client.messageHandlers[0].callback = mqtt_sub_callback;
      client.messageHandlers[0].qos = MQTT_TEST_QOS;

      /* set default subscribe event callback */
      client.defaultMessageHandler = mqtt_sub_callback;
}

/* run mqtt client */
paho_mqtt_start(&client);

return;

_exit:
if (client.buf)
{
      rt_free(client.buf);
      client.buf = RT_NULL;
}
if (client.readbuf)
{
      rt_free(client.readbuf);
      client.readbuf = RT_NULL;
}
return;
}

static void show_test_info(void)
{
char temp[50] = {0};
rt_kprintf("\r==== MQTT Stability test ====\n");
rt_kprintf("Server: "MQTT_TEST_SERVER_URI"\n");
rt_kprintf("QoS : %d\n", MQTT_TEST_QOS);

rt_kprintf("Test duration(sec)          : %d\n", time((time_t *)RT_NULL) - test_start_tm);
rt_kprintf("Number of published  packages : %d\n", pub_count);
rt_kprintf("Number of subscribed packages : %d\n", sub_count);
snprintf(temp, sizeof(temp), "Packet loss rate             : %.2f%% \n", (float)((float)(pub_count - sub_count) * 100.0f / pub_count));
rt_kprintf(temp);
rt_kprintf("Number of reconnections    : %d\n", recon_count);
/* up the cursor 8 line */
rt_kprintf("\033[8A");
}

static void thread_pub(void *parameter)
{
pub_data = rt_malloc(TEST_DATA_SIZE * sizeof(char));
if (!pub_data)
{
      rt_kprintf("no memory for pub_data\n");
      return;
}
rt_memset(pub_data, '*', TEST_DATA_SIZE * sizeof(char));

test_start_tm = time((time_t *)RT_NULL);
rt_kprintf("test start at '%d'\r\n", test_start_tm);

while (1)
{
      if (!paho_mqtt_publish(&client, QOS1, MQTT_PUBTOPIC, pub_data))
      {
         ++ pub_count;
      }

      rt_thread_delay(PUB_CYCLE_TM);

      show_test_info();
}
}

static void mqtt_test_start(void)
{
if (test_is_started)
{
      return;
}

mq_start();

while (!client.isconnected)
{
      rt_kprintf("Waiting for mqtt connection...\n");
      rt_thread_delay(1000);
}

pub_thread_tid = rt_thread_create("pub_thread", thread_pub, RT_NULL, 1024, 8, 100);
if (pub_thread_tid != RT_NULL)
{
      rt_thread_startup(pub_thread_tid);
}

test_is_started = 1;

return;
}

static void mqtt_test_stop(void)
{
MQTTClient *local_client = &client;

if (pub_thread_tid)
{
      rt_thread_delete(pub_thread_tid);
}

if (pub_data)
{
      rt_free(pub_data);
      pub_data = RT_NULL;
}

if (local_client)
{
      paho_mqtt_stop(local_client);
}

/* up the cursor 1 line */
rt_kprintf("\033[1A");

show_test_info();

/* down the cursor 10 line */
rt_kprintf("\033[10B");

pub_count = sub_count = recon_count = 0;
test_is_started = 0;

rt_kprintf("==== MQTT Stability test stop ====\n");
}

static void mqtt_test(uint8_t argc, char **argv)
{
if (argc >= 2)
{
      if (!strcmp(argv[1], "start"))
      {
         mqtt_test_start();
      }
      else if (!strcmp(argv[1], "stop"))
      {
         mqtt_test_stop();
      }
      else
      {
         rt_kprintf("Please input "CMD_INFO"\n");
      }
}
else
{
      rt_kprintf("Please input "CMD_INFO"\n");
}
}
MSH_CMD_EXPORT(mqtt_test, MQTT test CMD_INFO);