14天鸿蒙设备开发实战之网络应用开发笔记

int socket(int domain, int type, int protocol)

int sendto (socket s , const void * msg, int len, unsigned int flags,
const struct sockaddr * to , int tolen) ;

int recvfrom(int s, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen);

/*烧录完成后，按一下开发板的复位按键，此时可以看到日志中打印了一些信息，也已经可以在调试工具数据接收及提示窗口中看到开发板发送的数据；在调试工具数据发送窗口中发送数据后，可以在MobaXterm的串口工具中看到UDP服务端发送的数据*/
#include <stdio.h>
#include <unistd.h>
#include "ohos_init.h"
#include "cmsis_os2.h"
#include "wifi_device.h"
#include "lwip/netifapi.h"
#include "lwip/api_shell.h"
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#include "lwip/sockets.h"
#include "wifi_connect.h"
#define _PROT_ 8888
//在sock_fd 进行监听，在 new_fd 接收新的链接
int sock_fd;
int addr_length;
static const char *send_data = "Hello! I'm BearPi-HM_Nano UDP Client!\r\n";
static void UDPClientTask(void)
{
    //服务器的地址信息
    struct sockaddr_in send_addr;
    socklen_t addr_length = sizeof(send_addr);
    char recvBuf[512];
    //连接Wifi
    WifiConnect("TP-LINK_65A8", "xxxxxx");  // 参数分别是热点名称和热点password，连接的WiFi和自己电脑所连的网络要在同一个局域网中，才能实现数据的收发
    //创建socket
    if ((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)  // AF_INT:ipv4, SOCK_DGRAM:udp协议，0:协议，写为0时表示由第二个参数确定，返回一个文件描述符
    {
        perror("create socket failed!\r\n");
        exit(1);
    }
    //初始化预连接的服务端地址
    send_addr.sin_family = AF_INET;  // 协议族
    send_addr.sin_port = htons(_PROT_);  // 端口号
    send_addr.sin_addr.s_addr = inet_addr("192.168.1.6");  // IPv4地址，应填自己电脑的IPv4地址，可以使用ipconfig查找
    addr_length = sizeof(send_addr);

    //总计发送 count 次数据
    while (1)
    {
        bzero(recvBuf, sizeof(recvBuf));  // 将recvBuf清0
        //发送数据到服务远端
        sendto(sock_fd, send_data, strlen(send_data), 0, (struct sockaddr *)&send_addr, addr_length);
        //线程休眠一段时间
        sleep(10);  // 10s
        //接收服务端返回的字符串
        recvfrom(sock_fd, recvBuf, sizeof(recvBuf), 0, (struct sockaddr *)&send_addr, &addr_length);  // 阻塞接收，即如果没有从服务端接收到数据，会一直阻塞在这里
        printf("%s:%d=>%s\n", inet_ntoa(send_addr.sin_addr), ntohs(send_addr.sin_port), recvBuf);
    }
    //关闭这个 socket
    closesocket(sock_fd);
}
static void UDPClientDemo(void)
{
    osThreadAttr_t attr;
    attr.name = "UDPClientTask";
    attr.attr_bits = 0U;
    attr.cb_mem = NULL;
    attr.cb_size = 0U;
    attr.stack_mem = NULL;
    attr.stack_size = 10240;
    attr.priority = osPriorityNormal;
    if (osThreadNew((osThreadFunc_t)UDPClientTask, NULL, &attr) == NULL)
    {
        printf("[UDPClientDemo] Falied to create UDPClientTask!\n");
    }
}
APP_FEATURE_INIT(UDPClientDemo);

bind(int s, const struct sockaddr * name, socklen_t namelen)

int listen(int s, int backlog)

int accept(int s, struct sockaddr *addr, socklen_t addrlen)

int recv( SOCKET s, char *buf, int  len, int flags)

int send( SOCKET s,char *buf,int len,int flags )

/*创建客户端之后，点击连接，可以看到日志中打印出了`accept addr`，通过调试工具数据发送窗口向开发板TCP服务端发送一些数据，发送后数据会在日志中被打印出来，在调试工具数据接收及提示窗口中也可以看到开发板TCP服务端回复的数据。*/
#include <stdio.h>
#include <unistd.h>
#include "ohos_init.h"
#include "cmsis_os2.h"
#include "lwip/sockets.h"
#include "wifi_connect.h"
#define _PROT_ 8888
#define TCP_BACKLOG 10
//在sock_fd 进行监听，在 new_fd 接收新的链接
int sock_fd, new_fd;
char recvbuf[512];
char *buf = "Hello! I'm BearPi-HM_Nano TCP Server!";
static void TCPServerTask(void)
{
  //服务端地址信息
  struct sockaddr_in server_sock;
  //客户端地址信息
  struct sockaddr_in client_sock;
  int sin_size;
  struct sockaddr_in *cli_addr;
  //连接Wifi
  WifiConnect("TP-LINK_65A8", "xxxxxx");  // 参数分别是热点名称和热点password
  //创建socket
  if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  // AF_INT:ipv4, SOCK_STREAM:tcp协议，0:协议，写为0时表示由第二个参数确定，返回一个文件描述符
  {
    perror("socket is error\r\n");
    exit(1);
  }
  bzero(&server_sock, sizeof(server_sock));  // 将server_sock清0
  server_sock.sin_family = AF_INET;  // 协议族
  server_sock.sin_addr.s_addr = htonl(INADDR_ANY);  // IPv4地址，应填自己电脑的IPv4地址，可以使用ipconfig查找
  server_sock.sin_port = htons(_PROT_);  // 端口号
  //调用bind函数绑定socket和地址
  if (bind(sock_fd, (struct sockaddr *)&server_sock, sizeof(struct sockaddr)) == -1)
  {
    perror("bind is error\r\n");
    exit(1);
  }
  //调用listen函数监听(指定port监听)
  if (listen(sock_fd, TCP_BACKLOG) == -1)
  {
    perror("listen is error\r\n");
    exit(1);
  }
  printf("start accept\n");
  //调用accept函数从队列中
  while (1)
  {
    sin_size = sizeof(struct sockaddr_in);

    if ((new_fd = accept(sock_fd, (struct sockaddr *)&client_sock, (socklen_t *)&sin_size)) == -1)  // 返回新创建的套接字
    {
      perror("accept");
      continue;
    }
    cli_addr = malloc(sizeof(struct sockaddr));  // 向系统申请分配内存空间
    printf("accept addr\r\n");
    if (cli_addr != NULL)
    {
      memcpy(cli_addr, &client_sock, sizeof(struct sockaddr));  // 复制到cli_addr
    }
    //处理目标
    ssize_t ret;
    while (1)
    {
      if ((ret = recv(new_fd, recvbuf, sizeof(recvbuf), 0)) == -1)  // 接收数据
      {
        printf("recv error \r\n");
      }
      printf("recv :%s\r\n", recvbuf);
      sleep(2);
      if ((ret = send(new_fd, buf, strlen(buf) + 1, 0)) == -1)  // 发送数据
      {
        perror("send : ");
      }
      sleep(2);
    }
    close(new_fd);
  }
}
static void TCPServerDemo(void)
{
  // 创建一个任务
  osThreadAttr_t attr;
  attr.name = "TCPServerTask";
  attr.attr_bits = 0U;
  attr.cb_mem = NULL;
  attr.cb_size = 0U;
  attr.stack_mem = NULL;
  attr.stack_size = 10240;
  attr.priority = osPriorityNormal;
  if (osThreadNew((osThreadFunc_t)TCPServerTask, NULL, &attr) == NULL)
  {
    printf("[TCPServerDemo] Falied to create TCPServerTask!\n");
  }
}
APP_FEATURE_INIT(TCPServerDemo);

int connect (int s, const struct sockaddr * name, socklen_t namelen)

// 修改后的TCP客户端代码
/*烧录完成后，按一下开发板的复位按键，日志中会打印对应的信息，并且在调试工具数据接收及提示窗口中看到开发板发送的数据；在调试工具数据发送窗口中发送数据后，可以在MobaXterm的串口工具中看到TCP服务端发送的数据*/
#include <stdio.h>
#include <unistd.h>
#include "ohos_init.h"
#include "cmsis_os2.h"
#include "wifi_device.h"
#include "lwip/netifapi.h"
#include "lwip/api_shell.h"
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#include "lwip/sockets.h"
#include "wifi_connect.h"
#define _PROT_ 8888
//在sock_fd 进行监听，在 new_fd 接收新的链接
int sock_fd;
int addr_length;
static const char *send_data = "Hello! I'm BearPi-HM_Nano TCP Client!\r\n";
static void TCPClientTask(void)
{
    //服务器的地址信息
    struct sockaddr_in send_addr;
    socklen_t addr_length = sizeof(send_addr);
    char recvBuf[512];
    //连接Wifi
    WifiConnect("TP-LINK_65A8", "xxxxxx");  // 参数分别是热点名称和热点password，连接的WiFi和自己电脑所连的网络要在同一个局域网中，才能实现数据的收发
    //创建socket
    if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  // AF_INT:ipv4, SOCK_STREAM:tcp协议，0:协议，写为0时表示由第二个参数确定，返回一个文件描述符
    {
        perror("create socket failed!\r\n");
        exit(1);
    }
    //初始化预连接的服务端地址
    send_addr.sin_family = AF_INET;  // 协议族
    send_addr.sin_port = htons(_PROT_);  // 端口号
    send_addr.sin_addr.s_addr = inet_addr("192.168.1.6");  // IPv4地址，应填自己电脑的IPv4地址，可以使用ipconfig查找
    addr_length = sizeof(send_addr);
    connect(sock_fd, (struct sockaddr *)&send_addr, addr_length);  // 连接TCP服务器，之后进行数据发送和接收是不需要再指定服务端信息
    //总计发送 count 次数据
    while (1)
    {
        bzero(recvBuf, sizeof(recvBuf));  // 将recvBuf清0
        //发送数据到服务远端
        send(sock_fd, send_data, strlen(send_data), 0);
        //线程休眠一段时间
        // sleep(10);  // 10s
        //接收服务端返回的字符串
        recv(sock_fd, recvBuf, sizeof(recvBuf), 0);  // 阻塞接收，即如果没有从服务端接收到数据，会一直阻塞在这里
        printf("%s:%d=>%s\n", inet_ntoa(send_addr.sin_addr), ntohs(send_addr.sin_port), recvBuf);
    }
    //关闭这个 socket
    closesocket(sock_fd);
}
static void TCPClientDemo(void)
{
    osThreadAttr_t attr;
    attr.name = "TCPClientTask";
    attr.attr_bits = 0U;
    attr.cb_mem = NULL;
    attr.cb_size = 0U;
    attr.stack_mem = NULL;
    attr.stack_size = 10240;
    attr.priority = osPriorityNormal;
    if (osThreadNew((osThreadFunc_t)TCPClientTask, NULL, &attr) == NULL)
    {
        printf("[TCPClientDemo] Falied to create TCPClientTask!\n");
    }
}
APP_FEATURE_INIT(TCPClientDemo);

// 修改后的UDP服务端代码
/*当通过调试工具中的数据发送窗口向开发板的UDP服务端发送数据后，在数据接收及提示窗口可以看到开发板服务端的数据反馈，并且在串口工具打印的日志中，也可以看到UDP客户端发送过来的数据。*/
#include <stdio.h>
#include <unistd.h>
#include "ohos_init.h"
#include "cmsis_os2.h"
#include "lwip/sockets.h"
#include "wifi_connect.h"
#define _PROT_ 8888
#define UDP_BACKLOG 10
//在sock_fd 进行监听，在 new_fd 接收新的链接
int sock_fd, new_fd;
char recvbuf[512];
char *buf = "Hello! I'm BearPi-HM_Nano UDP Server!";
static void UDPServerTask(void)
{
  //服务端地址信息
  struct sockaddr_in server_sock;
  //客户端地址信息
  struct sockaddr_in client_sock;
  int sin_size;
  struct sockaddr_in *cli_addr;
  //连接Wifi
  WifiConnect("TP-LINK_65A8", "xxxxxx");  // 参数分别是热点名称和热点password
  //创建socket
  if ((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)  // AF_INT:ipv4, SOCK_DGRAM:udp协议，0:协议，写为0时表示由第二个参数确定，返回一个文件描述符
  {
    perror("socket is error\r\n");
    exit(1);
  }
  bzero(&server_sock, sizeof(server_sock));  // 将server_sock清0
  server_sock.sin_family = AF_INET;  // 协议族
  server_sock.sin_addr.s_addr = htonl(INADDR_ANY);  // IPv4地址，应填自己电脑的IPv4地址，可以使用ipconfig查找
  server_sock.sin_port = htons(_PROT_);  // 端口号
  //调用bind函数绑定socket和地址
  if (bind(sock_fd, (struct sockaddr *)&server_sock, sizeof(struct sockaddr)) == -1)
  {
    perror("bind is error\r\n");
    exit(1);
  }
  // UDP服务器不需要进行监听
  // //调用listen函数监听(指定port监听)
  // if (listen(sock_fd, TCP_BACKLOG) == -1)
  // {
  //  perror("listen is error\r\n");
  //  exit(1);
  // }
  // printf("start accept\n");
  //调用accept函数从队列中
  while (1)
  {
    sin_size = sizeof(struct sockaddr_in);
    // if ((new_fd = accept(sock_fd, (struct sockaddr *)&client_sock, (socklen_t *)&sin_size)) == -1)  // 返回新创建的套接字
    // {
    //  perror("accept");
    //  continue;
    // }
    // cli_addr = malloc(sizeof(struct sockaddr));  // 向系统申请分配内存空间
    // printf("accept addr\r\n");
    // if (cli_addr != NULL)
    // {
    //  memcpy(cli_addr, &client_sock, sizeof(struct sockaddr));  // 复制到cli_addr
    // }
    //处理目标
    ssize_t ret;
    while (1)
    {
      bzero(recvbuf, sizeof(recvbuf));  // 将recvbuf清0
      if ((ret = recvfrom(sock_fd, recvbuf, sizeof(recvbuf), 0, (struct sockaddr *)&client_sock, (socklen_t *)&sin_size)) == -1)  // 接收数据
      {
        printf("recv error \r\n");
      }
      printf("recv :%s\r\n", recvbuf);
      // sleep(2);
      if ((ret = sendto(new_fd, buf, strlen(buf) + 1, 0, (struct sockaddr *)&client_sock, sizeof(client_sock))) == -1)  // 发送数据
      {
        perror("send : ");
      }
      // sleep(2);
    }
    close(new_fd);
  }
}
static void UDPServerDemo(void)
{
  // 创建一个任务
  osThreadAttr_t attr;
  attr.name = "UDPServerTask";
  attr.attr_bits = 0U;
  attr.cb_mem = NULL;
  attr.cb_size = 0U;
  attr.stack_mem = NULL;
  attr.stack_size = 10240;
  attr.priority = osPriorityNormal;
  if (osThreadNew((osThreadFunc_t)UDPServerTask, NULL, &attr) == NULL)
  {
    printf("[UDPServerDemo] Falied to create UDPServerTask!\n");
  }
}
APP_FEATURE_INIT(UDPServerDemo);

void MQTTClientInit(MQTTClient* client, Network* network, unsigned int command_timeout_ms, unsigned char* sendbuf, size_t sendbuf_size, unsigned char* readbuf, size_t readbuf_size);

int MQTTConnect(MQTTClient* client, MQTTPacket_connectData* options);

int MQTTConnectWithResults(MQTTClient* client, MQTTPacket_connectData* options, MQTTConnackData* data);

int MQTTPublish(MQTTClient* client, const char* topicName, MQTTMessage* message);

int MQTTSubscribe(MQTTClient* client, const char* topicFilter, enum QoS, messageHandler);

/*在eclipse工具中添加订阅，之后在历史记录中可以看到开发板发过来的数据；在eclipse工具中发布一个主题，在MobaXterm的串口工具日志中打印出了发布内容*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "ohos_init.h"
#include "cmsis_os2.h"
#include "wifi_connect.h"
#include "MQTTClient.h"
static unsigned char sendBuf[1000];
static unsigned char readBuf[1000];
Network network;
void messageArrived(MessageData* data)
{
    printf("Message arrived on topic %.*s: %.*s\n", data->topicName->lenstring.len, data->topicName->lenstring.data,
        data->message->payloadlen, data->message->payload);
}
/* */
static void MQTT_DemoTask(void)
{
    WifiConnect("Hold","xxxxxx");  // 连接WiFi，参数分别是热点名称和热点password
    printf("Starting ...\n");
    int rc, count = 0;
    MQTTClient client;
    NetworkInit(&network);  // 用于MQTT对Socket依赖关系的注册，初始化网络结构体，socket描述符、socket发送和接收函数
    printf("NetworkConnect  ...\n");
begin:  
    NetworkConnect(&network, "192.168.0.176", 1883);  // 连接MQTT服务端，ip地址值为自己电脑的ip
    printf("MQTTClientInit  ...\n");
    MQTTClientInit(&client, &network, 2000, sendBuf, sizeof(sendBuf), readBuf, sizeof(readBuf));  // 创建一个MQTT客户端对象
    // 配置MQTT客户端的信息
    MQTTString clientId = MQTTString_initializer;
    clientId.cstring = "bearpi";
    MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
    data.clientID          = clientId;  // 用户id
    data.willFlag          = 0;  // 是否使用临终遗言
    data.MQTTVersion       = 3;  // MQTT协议版本号
    data.keepAliveInterval = 0;  // 保活周期
    data.cleansession      = 1;  // 是否清楚session信息
    printf("MQTTConnect  ...\n");
    rc = MQTTConnect(&client, &data);  // 发送连接数据包，返回值为0时，表示发送成功
    if (rc != 0) {
        printf("MQTTConnect: %d\n", rc);
        NetworkDisconnect(&network);  // 断开连接
        MQTTDisconnect(&client);  // 断开连接数据包并关闭连接
        osDelay(200);
        goto begin;  // 回到begin，重新连接MQTT服务端
    }
    printf("MQTTSubscribe  ...\n");
    rc = MQTTSubscribe(&client, "substopic", 2, messageArrived);  // 订阅消息，substopic为订阅的消息主题，messageArrived为订阅成功后的回调函数
    if (rc != 0) {
        printf("MQTTSubscribe: %d\n", rc);
        osDelay(200);
        goto begin;
    }
    while (++count)  // 每500ms发布一次消息
    {
        MQTTMessage message;
        char payload[30];
        message.qos = 2;  // 服务等级
        message.retained = 0;  // 是否保留
        message.payload = payload;  // 消息数据
        sprintf(payload, "message number %d", count);  // 发送格式化输出到payload所指向的字符串
        message.payloadlen = strlen(payload);  // 消息数据长度
        if ((rc = MQTTPublish(&client, "pubtopic", &message)) != 0){  // 发布消息，pubtopic为发布的消息主题，message为需要发布的消息结构体
            printf("Return code from MQTT publish is %d\n", rc);
            NetworkDisconnect(&network);  // 断开连接
            MQTTDisconnect(&client);  // 断开连接数据包并关闭连接
            goto begin;
        }
        osDelay(50);    
    }
}
static void MQTT_Demo(void)
{
    // 创建一个任务
    osThreadAttr_t attr;

    attr.name = "MQTT_DemoTask";
    attr.attr_bits = 0U;
    attr.cb_mem = NULL;
    attr.cb_size = 0U;
    attr.stack_mem = NULL;
    attr.stack_size = 10240;
    attr.priority = osPriorityNormal;

    if (osThreadNew((osThreadFunc_t)MQTT_DemoTask, NULL, &attr) == NULL) {
        printf("[MQTT_Demo] Falied to create MQTT_DemoTask!\n");
    }
}
APP_FEATURE_INIT(MQTT_Demo);