Convertir un string en char

Bonsoir à tous,

En gros, j’envoie une requete POST et je reçois le payload qui est un string (Json) grace à payloadgetString()

pourquoi je veux faire cela ?

je souhaite envoyer mon payload à un arduino mega via l’ESP Nodemcu, donc puisque on peut pas envoyer le string via le serial port, je l’ai convertit en char, mais j’obtiens pas ce qui est vraiment dans le payload .

voici le code:

#include <Arduino.h>
#include <ArduinoJson.h>

#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>

#include <ESP8266HTTPClient.h>

#include <WiFiClientSecureBearSSL.h>
// Fingerprint for demo URL, expires on June 2, 2019, needs to be updated well before this date
// const uint8_t fingerprint[20] = {0x5A, 0xCF, 0xFE, 0xF0, 0xF1, 0xA6, 0xF4, 0x5F, 0xD2, 0x11, 0x11, 0xC6, 0x1D, 0x2F, 0x0E, 0xBC, 0x39, 0x8D, 0x50, 0xE0};

ESP8266WiFiMulti WiFiMulti;

char post_ping() {

  Serial.begin(115200);
  // Serial.setDebugOutput(true);

  Serial.println();
  Serial.println();
  Serial.println();

  for (uint8_t t = 4; t > 0; t--) {
    Serial.printf("[SETUP] WAIT %d...\n", t);
    Serial.flush();
    delay(1000);
  }

  WiFi.mode(WIFI_STA);
  WiFiMulti.addAP("xxxxxx", "xxxxx");

  // wait for WiFi connection
  if ((WiFiMulti.run() == WL_CONNECTED)) {

    std::unique_ptr<BearSSL::WiFiClientSecure>client(new BearSSL::WiFiClientSecure);

    //client->setFingerprint(fingerprint);
    client->setInsecure();

    HTTPClient https;

    Serial.print("[HTTPS] begin...\n");
    if (https.begin(*client, "https://xxxxxxxxxxxxx")) {  // HTTPS

      Serial.print("[HTTPS] POST...\n");
      // start connection and send HTTP header
      int httpCode = https.POST("borago"); 

      // httpCode will be negative on error
      if (httpCode > 0) {
        // HTTP header has been send and Server response header has been handled
        Serial.printf("[HTTPS] POST... code: %d\n", httpCode);

        // file found at server
        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
          String payload = https.getString();
       char copy[16];
      payload.toCharArray(copy, 16);

      s.begin(115200);
      Serial.print("================envoie payload à mega============");
Serial.print("/n");
Serial.print(copy);


  //s.write(copy);


        }
      } else {
        Serial.printf("[HTTPS] POST... failed, error: %s\n", https.errorToString(httpCode).c_str());
      }

      https.end();
    } else {
      Serial.printf("[HTTPS] Unable to connect\n");
    }

      

  }

  Serial.println("Wait 10s before next round...");

}

resultats:

[SETUP] WAIT 4…
[SETUP] WAIT 3…
[SETUP] WAIT 2…
[SETUP] WAIT 1…
[HTTPS] begin…
[HTTPS] POST…
[HTTPS] POST… code: 200
{⸮j

Merci d’avance !

on peut pas envoyer le string via le serial port

Ah bon ? Je ne savais pas...moi j’essayerai quand même Serial.print(maString); juste au cas où...

J'ai dit cela parce que j'ai obtenu :

error: no matching function for call to 'SoftwareSerial::write(String&)'

s.write(payload)

quand je fais :

s.write(payload)

mais peut etre c'est du à sa taille parce que j'obtiens ca aussi :

virtual size_t SoftwareSerial::write(uint8_t)

size_t write(uint8_t byte) override;

^

xxxxxxxxxxxxxxxx5\packages\esp8266\hardware\esp8266\2.5.1\libraries\SoftwareSerial\src/SoftwareSerial.h:74:9: note: no known conversion for argument 1 from 'String' to 'uint8_t {aka unsigned char}'
xxxxxxxxxxxxxxxx
rduino15\packages\esp8266\hardware\esp8266\2.5.1\libraries\SoftwareSerial\src/SoftwareSerial.h:75:9: note: virtual size_t SoftwareSerial::write(const uint8_t*, size_t)

size_t write(const uint8_t *buffer, size_t size) override;

^
xxxxxxxxxxxxxxxx\Local\Arduino15\packages\esp8266\hardware\esp8266\2.5.1\libraries\SoftwareSerial\src/SoftwareSerial.h:75:9: note: candidate expects 2 arguments, 1 provided

In file included from xxxxxxxxxxxxxxxxata\Local\Arduino15\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Stream.h:26:0,

from xxxxxxxxxxxxxxxxa\Local\Arduino15\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/HardwareSerial.h:32,

from xxxxxxxxxxxxxxxxocal\Arduino15\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Arduino.h:263,

from sketch\Borago_ESP.ino.cpp:1:

xxxxxxxxxxxxxxxxrduino15\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:71:16: note: size_t Print::write(long unsigned int)

size_t write(unsigned long t) { return write((uint8_t)t); }

^
xxxxxxxxxxxxxxxxl\Arduino15\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:71:16: note: no known conversion for argument 1 from 'String' to 'long unsigned int'

xxxxxxxxxxxxxxxx\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:70:16: note: size_t Print::write(long int)

size_t write(long t) { return write((uint8_t)t); }

^
xxxxxxxxxxxxxxxxkages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:70:16: note: no known conversion for argument 1 from 'String' to 'long int'

xxxxxxxxxxxxxxxxges\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:69:16: note: size_t Print::write(unsigned int)

size_t write(unsigned int t) { return write((uint8_t)t); }

^
xxxxxxxxxxxxxxxxrdware\esp8266\2.5.1\cores\esp8266/Print.h:69:16: note: no known conversion for argument 1 from 'String' to 'unsigned int'

xxxxxxxxxxxxxxxxware\esp8266\2.5.1\cores\esp8266/Print.h:68:16: note: size_t Print::write(int)

size_t write(int t) { return write((uint8_t)t); }

^

xxxxxxxxxxxxxxxxware\esp8266\2.5.1\cores\esp8266/Print.h:68:16: note: no known conversion for argument 1 from 'String' to 'int'

C:\Users\Lgabed\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:67:16: note: size_t Print::write(short unsigned int)

size_t write(unsigned short t) { return write((uint8_t)t); }

^
xxxxxxxxxxxxxxxx2.5.1\cores\esp8266/Print.h:67:16: note: no known conversion for argument 1 from 'String' to 'short unsigned int'

C:\Users\Lgabed\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:66:16: note: size_t Print::write(short int)

size_t write(short t) { return write((uint8_t)t); }

^

C:\xxxxxxxxxxxxxxxx\hardware\esp8266\2.5.1\cores\esp8266/Print.h:66:16: note: no known conversion for argument 1 from 'String' to 'short int'
xxxxxxxxxxxxxxxx\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:62:16: note: size_t Print::write(const char*, size_t)

size_t write(const char *buffer, size_t size) {

^
xxxxxxxxxxxxxxxx\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:62:16: note: candidate expects 2 arguments, 1 provided

xxxxxxxxxxxxxxxx\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:56:16: note: size_t Print::write(const char*)

size_t write(const char *str) {

^

xxxxxxxxxxxxxxxx\packages\esp8266\hardware\esp8266\2.5.1\cores\esp8266/Print.h:56:16: note: no known conversion for argument 1 from 'String' to 'const char*'

exit status 1
no matching function for call to 'SoftwareSerial::write(String&)'

J’ai pas dit write, j’ai dit Print...

C’est qui ‘s’ ?

Autant pour moi ^^,

oui donc Print, je l'ai fait aussi et j'obtient pas ce qui est dans le string(json) :

{
"success": true,
"code": "1",
"datas": [
{
"id": 1,
"days": 14,
"temp": 20,
"hum": 80
}
]
}

et sur mon moniteur serie j'ai :

{⸮j

En gros le but de tout ca c'est d'envoyer mon string Json du Nodemcu ver le mega.

Vu le

s.begin(115200);

s doit être la liaison série avec le Mega.

Moi j'essayerais payload.c_str() et strcpy

char copy[100];
strcpy(copy, payload.c_str());
Serial.println (copy) ;
s.print (copy);

Merci le sept ! cela marche , mais maintenant quand je regarde coté mega il reçoit des : -1
voila le petit coe mega :

#include<SoftwareSerial.h> //Included SoftwareSerial Library
SoftwareSerial s(10,11);


void setup(){

   Serial.begin(115200);

}
void loop()
{


    Serial.print(Serial.read());
  delay(1000);
}

Donc vous ne nous avez pas donné le code que vous utilisez... on ne voit pas ‘s’ (je me doute bien que c’est un SoftwareSerial)

Passer par un buffer additionnel ne change rien à l’affaire après coup - getString() lit directement le flux donc si vous ne sauvez pas le contenu quelque part, il est perdu. Je ne suis pas sûr que Payload contienne en fait les data.

si j’ai bien donné le code des deux coté.

je viens de voir que j’avais une erreur sur le coté mega :

Serial.print(s.read());

au lieu de ce que j’avais fait.

Passer par un buffer additionnel ne change rien à l’affaire après coup - getString() lit directement le flux donc si vous ne sauvez pas le contenu quelque part, il est perdu. Je ne suis pas sûr que Payload contienne en fait les data.

Vu mon niveau, j’ai pas bien compris …
le buffer c’etait pour strcpy
quand j’ai fait :

String payload = https.getString();

et puis le passer sur le buffer ca le stocke pas?

parce que quand j’affiche payload_char, je vois bien les donnée Json sur le moniteur serie.

UPDATE:

pardon le ‘s’ etait dans une la fonction loop setup et c’est :

#include<SoftwareSerial.h> //Included SoftwareSerial Library
//Started SoftwareSerial at RX and TX pin of ESP8266/NodeMCU
SoftwareSerial s(3,1);

si j'ai bien donné le code des deux coté.

Il y a un problème dans tes codes.
Dans le premier code tu utilise 's' sans le déclarer.
Dans le 2eme tu le déclare sans l'utiliser.

Enlève le delay(1000): ne sert à rien.

P.S.

je viens de voir que j'avais une erreur sur le coté mega :

Code: [Select]

Serial.print(s.read());

Ok tu l'utilise, même que c'est dommage utiliser SoftwareSerial sur un MEGA.

payload_char

Reposte ton code stp.

oui pardon vous avez raison, j'ai pas donné tout le code mais parce que la focntion sur l'esp est sur une autre fichier et le main dans un autre mais j'ai pas d'erreur de compilation ou quoi que ce soit.

pourquoi dommage? vaut mieux utiliser les pin destiné à rx tx ?

pourquoi dommage? vaut mieux utiliser les pin destiné à rx tx ?

Le Mega a 4 ports serial (hardware) .
Serial
Serial1
Serial2
Serial3

Mega

Et utiliser la pin 1 pour software serial n’est pas top...

Postez le code complet.

Ok ! voilà le code complet :

Coté Mega :

char payload_mega_receive;

void setup(){

   Serial.begin(115200);
   Serial1.begin(115200);

}
void loop()
{

    payload_mega_receive = Serial1.read(); //Read the serial data and store it
    Serial.print("payload_mega_receive :");
    Serial.print("\n");
    Serial.print(payload_mega_receive);
     Serial.print("\n");
  delay(1000);
}

Coté NodeMcu :

fonction request post avec communication serie :

#include <Arduino.h>
#include <ArduinoJson.h>

#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>

#include <ESP8266HTTPClient.h>

#include <WiFiClientSecureBearSSL.h>
// Fingerprint for demo URL, expires on June 2, 2019, needs to be updated well before this date
// const uint8_t fingerprint[20] = {0x5A, 0xCF, 0xFE, 0xF0, 0xF1, 0xA6, 0xF4, 0x5F, 0xD2, 0x11, 0x11, 0xC6, 0x1D, 0x2F, 0x0E, 0xBC, 0x39, 0x8D, 0x50, 0xE0};

ESP8266WiFiMulti WiFiMulti;

char post_ping() {

  Serial.begin(115200);
  // Serial.setDebugOutput(true);

  Serial.println();
  Serial.println();
  Serial.println();

  for (uint8_t t = 4; t > 0; t--) {
    Serial.printf("[SETUP] WAIT %d...\n", t);
    Serial.flush();
    delay(1000);
  }


  WiFi.mode(WIFI_STA);
  WiFiMulti.addAP("xxxxx", "xxxxx");

  // wait for WiFi connection
  if ((WiFiMulti.run() == WL_CONNECTED)) {

    std::unique_ptr<BearSSL::WiFiClientSecure>client(new BearSSL::WiFiClientSecure);

    //client->setFingerprint(fingerprint);
    client->setInsecure();

    HTTPClient https;

    Serial.print("[HTTPS] begin...\n");
    if (https.begin(*client, "xxxxxxxxxxxxxxx")) {  // HTTPS

      Serial.print("[HTTPS] POST...\n");
      // start connection and send HTTP header
      int httpCode = https.POST("borago"); 

      // httpCode will be negative on error
      if (httpCode > 0) {
        // HTTP header has been send and Server response header has been handled
        Serial.printf("[HTTPS] POST... code: %d\n", httpCode);

        // file found at server
        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
          String payload = https.getString();
       char payload_char[100];
     //payload.toCharArray(payload_char, 16);

strcpy(payload_char, payload.c_str());
     s.begin(115200);
      Serial.print("================envoie payload à mega============");
Serial.print("\n");
Serial.print(payload_char);


  s.write(payload_char);

  //    char* tempor = copy;
          //Serial.println(copy);

        

/*
          StaticJsonBuffer<300> jsonBuffer;
      
        JsonObject& root = jsonBuffer.parseObject(payload);
      const char* code = root["code"];
  
  const char* id = root["datas"][0];
  const char* days = root["datas"][1];
   const char* temp = root["datas"][2];
    const char* hum = root["datas"][3];

  // Print values.
  Serial.println(code);
  Serial.println(id);
  Serial.println(days);
  Serial.println(temp);
  Serial.println(hum); */

        }
      } else {
        Serial.printf("[HTTPS] POST... failed, error: %s\n", https.errorToString(httpCode).c_str());
      }

      https.end();
    } else {
      Serial.printf("[HTTPS] Unable to connect\n");
    }

      

  }

  Serial.println("Wait 10s before next round...");

}
#include<SoftwareSerial.h> //Included SoftwareSerial Library
//Started SoftwareSerial at RX and TX pin of ESP8266/NodeMCU
SoftwareSerial s(D6,D5);
unsigned long previousMillis = 0;        // will store last time LED was updated

// constants won't change:
//const long interval = 60000;     // 10min = 600000s
void setup(){


  
}

void loop() {
 post_ping();


}

moniteur serie coté mega :

payload_mega_receive :

payload_mega_receive :

payload_mega_receive :

payload_mega_receive :

moniteur serie coté nodemcu :

[SETUP] WAIT 4…
[SETUP] WAIT 3…
[SETUP] WAIT 2…
[SETUP] WAIT 1…
[HTTPS] begin…
[HTTPS] POST…
[HTTPS] POST… code: 200
================envoie payload à mega============{“success”:true,“code”:“1”,“datas”:⸮⸮

UPDATE :

Maintenant j'ai reussi à recevoir sur le mega , mais il envoie chaque element du char tout seul et ca donne :

payload_mega_receive :

payload_mega_receive :
{
payload_mega_receive :
"
payload_mega_receive :
s
payload_mega_receive :
u
payload_mega_receive :
c
payload_mega_receive :
c
payload_mega_receive :
e
payload_mega_receive :
s
payload_mega_receive :
s
payload_mega_receive :
"
payload_mega_receive :
:
payload_mega_receive :
t
payload_mega_receive :
r
payload_mega_receive :
u
payload_mega_receive :
e
payload_mega_receive :
,
payload_mega_receive :
"
payload_mega_receive :
c
payload_mega_receive :
o
payload_mega_receive :
d
payload_mega_receive :
e
payload_mega_receive :
"
payload_mega_receive :
:
payload_mega_receive :
"
payload_mega_receive :
1
payload_mega_receive :
"
payload_mega_receive :
,

Est ce qu'il y a un moyen de tout rassembler pour les parser apres avec Arduino Json ? ou sans passer par ArduinoJson peut etre rassembler chaque element comme voulu ?

mais il envoie chaque element du char tout seul

Non vous lisez un caractère à la fois

Si vous voulez comprendre comment bien écouter le port série (ou gérer un flux asynchrone genre keypad) vous pouvez jeter un oeil à mon petit tuto sur le sujet

Il existe pas mal de tutos pour apprendre à recevoir des données via une liaison série. Voir par exemple ici, à partir du chapitre “recevoir des données”

Il semble que votre JSON soit incomplet

D'accord merci pour vos liens, non puisque quand je print le payload directmenet sur le moniteur serie de l'ESP j'ai bien tout le JSON

En regardant plus haut ça imprime

mega============{"success":true,"code":"1","datas":[color=red]⸮⸮[/color]

Ça ne me semble pas bon ou alors vous avez modifié ce qui est imprimé ?