Introduction à la communication WIFI développée par ESP32+idf (5) Communication HTTP

Introduction à la communication WIFI développée par ESP32+idf (5) Communication HTTP

1. Réalisez la fonction :

En tant que client HTTP, esp32 utilise la méthode GET et la méthode POST pour envoyer des requêtes au serveur HTTP et obtenir des réponses, comme suit :

1. Méthode GET : envoyez une requête get/add à l'URL du serveur Web, envoyez les valeurs des paramètres x et y pour additionner et répondre sur le serveur, et esp32 obtient les données renvoyées ;

2. Méthode POST : envoyez une requête POST/ajoutez à l'URL du serveur Web, envoyez les valeurs des paramètres x et y à la somme et répondez à la fin du serveur, et esp32 obtient les données renvoyées ;

3. Utilisez le format de données json pour communiquer

2. Vue d'ensemble HTTP :

​ Le protocole HTTP est un protocole de transfert hypertexte (Hypertext Transfer Protocol) basé sur le protocole de communication TCP/IP pour transférer des données (fichiers HTML, fichiers images, résultats de requêtes, etc.) C'est un protocole orienté objet appartenant au Couche application En raison de sa simplicité, voie rapide, adaptée aux systèmes d'information hypermédia distribués. Ses principales caractéristiques :

Simple et rapide : lorsqu'un client demande un service au serveur, il lui suffit de transmettre la méthode et le chemin de la demande. Les méthodes de requête couramment utilisées sont GET, HEAD et POST. Chaque méthode spécifie un type différent de contact client-serveur. En raison de la simplicité du protocole HTTP, la taille du programme du serveur HTTP est petite, de sorte que la vitesse de communication est très rapide.

Flexible : HTTP permet la transmission de types arbitraires d'objets de données. Le type transféré est marqué par Content-Type.

Aucune connexion : la signification de l'absence de connexion est de limiter chaque connexion à traiter une seule demande. Une fois que le serveur a terminé de traiter la demande du client et reçu la réponse du client, il se déconnecte. De cette manière, le temps de transmission peut être économisé.

Sans état : Le protocole HTTP est un protocole sans état. Sans état signifie que le protocole n'a pas de capacité de mémoire pour le traitement des transactions. L'absence d'état signifie que si un traitement ultérieur nécessite des informations précédentes, celles-ci doivent être retransmises, ce qui peut entraîner une augmentation de la quantité de données transférées par connexion. En revanche, lorsque le serveur n'a pas besoin d'informations préalables, sa réponse est plus rapide.

Prend en charge les modes B/S et C/S.

HTTP utilise des identificateurs de ressources uniformes (Uniform Resource Identifiers, URI) pour transférer des données et établir des connexions. L'URL (UniformResourceLocator, Uniform Resource Locator) est un type spécial d'URI,

http://xxx.xxx.xxx.xxx:9999/add?x=3&y=4

L'URL ci-dessus comprend les parties suivantes : partie protocole (http:), partie nom de domaine/adresse IP, partie port (9999), partie nom de fichier (du dernier "/" après le nom de domaine à "?", c'est-à-dire /add ? ), partie paramètre (x=3&y=4), etc.

Le client envoie une requête HTTP au message de requête du serveur (request) : la ligne de requête (request line), l'en-tête de requête (header), la ligne vide et les données de requête sont composées de quatre parties.

Après réception et traitement de la requête du client, le serveur renverra un message de réponse HTTP (réponse) : ligne d'état, en-tête du message, ligne vide et corps de la réponse.

La différence entre la méthode GET et la méthode POST :

Soumission GET : les données demandées seront ajoutées à l'URL (c'est-à-dire que les données sont placées dans l'en-tête du protocole HTTP), et l'URL et les données de transmission sont séparées par ?, et plusieurs paramètres sont connectés par & ;

Soumission POST : placez les données soumises dans le corps du package HTTP.

Par conséquent, les données soumises par GET seront affichées dans la barre d'adresse, mais lorsqu'elles sont soumises par POST, la barre d'adresse ne changera pas.

3. Étapes

1. Copiez le code du composant de la connexion wifi dans les composants personnalisés (composants) du projet, entrez vscode pour créer un exemple de projet vide et ouvrez le terminal de commande :

mkdir components

cp -r D:\Espressif\frameworks\esp-idf-v4.4.1\examples\common_components\protocol_examples_common .\components

2. Configurez les paramètres de connexion Wi-Fi, ouvrez l'interface de commande du terminal pour entrer idf.py menuconfiget entrez dans l'interface Exemple de configuration de connexion pour configurer le SSID et le mot de passe des informations du point d'accès.

3. Écrivez le code client http de esp32 qui réalise les fonctions ci-dessus dans main.c :

#include <esp_log.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <esp_system.h>
#include <esp_event.h>

#include <nvs_flash.h>
#include <esp_netif.h>
#include <protocol_examples_common.h>

#include <esp_http_client.h>
#include <cJSON.h>

static char *TAG = "http_client";
static char response_data[1024]; // 自定义缓存空间储存一次响应数据
static int recived_len = 0;      // 自定义变量储存一次响应中接收到分片数据的累计偏移

// http客户端的事件处理回调函数
static esp_err_t http_client_event_handler(esp_http_client_event_t *evt)
{
    
    
    switch (evt->event_id)
    {
    
    
    case HTTP_EVENT_ON_CONNECTED:
        ESP_LOGI(TAG, "connected to web-server");
        recived_len = 0;
        break;
    case HTTP_EVENT_ON_DATA:
        if (evt->user_data)
        {
    
    
            memcpy(evt->user_data + recived_len, evt->data, evt->data_len); // 将分片的每一片数据都复制到user_data
            recived_len += evt->data_len;//累计偏移更新
        }
        break;
    case HTTP_EVENT_ON_FINISH:
        ESP_LOGI(TAG, "finished a request and response!");
        recived_len = 0;
        break;
    case HTTP_EVENT_DISCONNECTED:
        ESP_LOGI(TAG, "disconnected to web-server");
        recived_len = 0;
        break;
    case HTTP_EVENT_ERROR:
        ESP_LOGE(TAG, "error");
        recived_len = 0;
        break;
    default:
        break;
    }

    return ESP_OK;
}

void app_main(void)
{
    
    
    esp_err_t ret;

    nvs_flash_init();
    esp_netif_init();
    esp_event_loop_create_default();

    example_connect();

    const esp_http_client_config_t cfg = {
    
    
        .url = "http://111.230.201.180:3000",
        .event_handler = http_client_event_handler,
        .user_data = response_data,
    };
    //使用http服务器配置参数对http客户端初始化
    esp_http_client_event_handle_t httpclient = esp_http_client_init(&cfg);

    // GET方法请求
    esp_http_client_set_method(httpclient, HTTP_METHOD_GET);
    esp_http_client_set_url(httpclient, "/add?x=10&y=11");//url传递发送数据x=10，y=11
    ret = esp_http_client_perform(httpclient);//启动并阻塞等待一次响应完成
    if (ret == ESP_OK)
    {
    
    
		//一次响应完成，打印完整响应数据，即得到X+y的值
        printf("GET:%s\n", response_data);
    }
    // POST方法请求
    esp_http_client_set_method(httpclient, HTTP_METHOD_POST);
    esp_http_client_set_url(httpclient, "/add/");

    //设置请求头
    esp_http_client_set_header(httpclient, "Content-Type", "application/json");

    //构造json数据jsonArg请求体（即发送数据x=24，y=124）
    cJSON *pRoot = cJSON_CreateObject();
    cJSON_AddStringToObject(pRoot, "x", "24");
    cJSON_AddStringToObject(pRoot, "y", "124");
    // char *jsonArg = "{\"x\":23,\"y\":34}";
    char *jsonArg = cJSON_Print(pRoot);
    //printf("jsonArg:%s\n", jsonArg);
    esp_http_client_set_post_field(httpclient, jsonArg, strlen(jsonArg));

    ret = esp_http_client_perform(httpclient);
    if (ret == ESP_OK)
    {
    
    
        //一次响应完成，打印完整响应数据，即得到X+y的值
        printf("POST:%s\n", response_data);
    }

    esp_http_client_cleanup(httpclient);//清空http客户端描述符
}

4. Le serveur lui-même est déployé sur le serveur Tencent Cloud et le fichier de code du serveur index.js est le suivant. (Les débutants ne peuvent pas déployer le serveur en premier, mais peuvent utiliser leur propre serveur pour les tests)

const express = require('express')
const bodyParser = require('body-parser')
const request = require('request')
const fs = require('fs')
const app = express()
app.use(bodyParser.json())

app.get('/add', (req, res) => {
    
    
    console.log("\nx: "+req.query.x)
    console.log("\ny: "+req.query.y)
    //查询
    res.json({
    
    
                result: true,
                method:"GET",
                message:Number(req.query.x) + Number(req.query.y)
            })
})

app.post('/add', (req, res) => {
    
    
    console.log("\nx: "+req.body.x)
    console.log("\ny: "+req.body.y)
    //增加
    res.json({
    
    
                result: true,
                method:"POST",
                message:Number(req.body.x) + Number(req.body.y)
            })
})


app.listen(3000, () => {
    
    
    console.log('server running at http://127.0.0.1:3000')
})

4. Testez

Si vous avez un serveur auto-construit, exécutez-le sous le chemin correspondant : sudo node index.jsdémarrez le serveur.

Compilez, programmez et surveillez esp32, observez les informations d'impression du terminal d'esp32 et testez si les données de réponse sont normales. Obtenir le test de requête GET 10+11=21 et renvoyer le test de données json est normal ; la requête POST 24+124=148 renvoyer le test de données json est normale.