ESP32 problema con librería kaa-arduino-sdk

Hola a todos, son principiante en la programación con el IDE Arduino y me encuentro realizando un proyecto con la placa NodeMCU-32S. Para este proyecto debo conseguir enviar información por mqtt al servidor Kaa, con ayuda de la librería kaa-arduino-sdk https://github.com/kaaproject/kaa-arduino-sdk, pero debo lograr modificar los parámetros que necesitamos tanto para conectarnos a wifi como para conectarnos al servidor kaa, sin necesidad de cargar un nuevo código y guardando estos datos en la memoria no volátil de la tarjeta.
Por esa razón estoy utilizando WiFiManager.
Ya conseguí ingresar los datos por medio de WiFiManager y guardarlos de manera permanente con ayuda de la librería preferences, así como recuperar datos guardados. El problema surge cuando intentamos utilizar los datos recuperados de la memoria para utilizar la librería del servido Kaa, necesitamos conocer tres cosas, el servidor, el token, y el app versión, estos tres parámetros son loa que guardamos en la memoria.
Ahora, necesitamos crear una variable de tipo kaa como se muestra continuación que nos pide ingresar tres variables, el cliente mqtt con el cual no tenemos mayor problema, y nos pide el token y app versión, que son tipo char* para generar automáticamente el topico al que se publicara
Kaa kaa(&client, KAA_TOKEN, KAA_APP_VERSION);
esta variable se declara de manera global, y nosotros recuperamos la información de la memoria en el setup, entonces cuando comienza a enviar mensajes, no logramos que recupere la información de la memoria, se queda con el valor que tienen las variables KAA_TOKEN y KAA_APP_VERSION, al momento que son declaradas.
quiero saber si alguien me puede ayudar a retornar esa información que esta en la memoria. Ya intente de diferentes formas, pero aun así no lo consigo.
Adjunto mi primer código.

#include <WiFi.h>  
#include <PubSubClient.h> 
#include <WiFiManager.h>
#include <WebServer.h>
#include <Preferences.h>
#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
#include <ArduinoJson.h>
#include "kaa.h"
Preferences preferences; 

#define COMMAND_1 "COMMAND_1"

char* KAA_SERVER= ""; 
char* KAA_TOKEN="";  
char* KAA_APP_VERSION="";
unsigned int mqtt_port = KAA_PORT;
char SERVERBuf[50]="";  
char VERSIONBuf[50]="";                  
char TOKENBuf[50]="";

char W_mqtt_server[40]="";
char W_api_token[34] = "";
char W_mqtt_version[40]= "";

WiFiClient espClient;
WiFiManager wm;
PubSubClient client(espClient);
Kaa kaa(&client, KAA_TOKEN, KAA_APP_VERSION);


void save_W_ConfigCallback () {
  Serial.println("SAVE");
  String Str_mqtt_server = String(W_mqtt_server);
  String Str_mqtt_version = String(W_mqtt_version);
  String Str_mqtt_token = String(W_api_token);
  preferences.begin("LICENSES", false);
  if (Str_mqtt_server!="") {preferences.putString("SERVER",Str_mqtt_server);
  Serial.print("Server: "); Serial.println(W_mqtt_server);}
  if (Str_mqtt_version!=""){preferences.putString("VERSION",Str_mqtt_version);
  Serial.print("Token: "); Serial.println(W_api_token);}
  if (Str_mqtt_token!="")  {preferences.putString("TOKEN",Str_mqtt_token);
  Serial.print("Version: "); Serial.println(W_mqtt_version);} 
  preferences.end();
 }

void return_W_Config_Callback (){
  Serial.println("RECOVERED DATA");
  preferences.begin("LICENSES", false);
 String SERVER= preferences.getString("SERVER","");
 String VERSION= preferences.getString("VERSION","");
 String TOKEN= preferences.getString("TOKEN","");
   preferences.end();
  SERVER.toCharArray(SERVERBuf, 50);
   VERSION.toCharArray(VERSIONBuf, 50);                  
   TOKEN.toCharArray(TOKENBuf, 50);
  Serial.print("Server: ");    Serial.println( SERVERBuf);
  Serial.print("Token: ");     Serial.println(TOKENBuf);
  Serial.print("Version: ");  Serial.println(VERSIONBuf);
      }
/*WIFI MANAGER*/
void configModeCallback (WiFiManager *myWiFiManager) {
 Serial.println("Conect AutoConnectAP ");   
   Serial.println(WiFi.softAPIP());
   Serial.println(myWiFiManager->getConfigPortalSSID());
   }

void setup_wifi(){
 WiFi.persistent(true);     
 WiFi.mode(WIFI_STA); 
 //wm.resetSettings();
wm.setAPCallback(configModeCallback);
  WiFiManagerParameter custom_W_mqtt_server("Server", "MQTT Server", W_mqtt_server, 40);
  WiFiManagerParameter custom_W_mqtt_version("Version", "MQTT Version",W_mqtt_version, 40);
  WiFiManagerParameter custom_W_api_token("Token", "MQTT Token", W_api_token, 34);
//add all your parameters here
  wm.addParameter(&custom_W_mqtt_server);
  wm.addParameter(&custom_W_mqtt_version);
  wm.addParameter(&custom_W_api_token);

if (!wm.autoConnect("AutoConnectAP","12345678")) {
Serial.println("failed to connect ");
delay(2000);
  }
  strcpy(W_mqtt_server, custom_W_mqtt_server.getValue());
  strcpy(W_mqtt_version, custom_W_mqtt_version.getValue());
  strcpy(W_api_token, custom_W_api_token.getValue());
save_W_ConfigCallback ();
Serial.println("WIFI connected");
}
/*CONEXION MQTT*/
void reconnect() 
{ 
  if (WiFi.status() == WL_CONNECTED){
     while (!client.connected()) 
     {
    Serial.print("Conecting Mqtt...");
    String clientId = "Client_Esp";   // Create a Client ID
    clientId += String(random(0xffff), HEX); //Add a random number to make unique the Client ID
    if (client.connect(clientId.c_str())) // Try to connect to MQTT broker
      { Serial.println("Connected!");
        kaa.connect();
         } 
     else 
      { Serial.print("failed to connect ");
        Serial.println(client.state());
        
        delay(5000);
      }
  } }
  
}

void callback(char* topic, byte* payload, unsigned int length) {
 Serial.print("Mensaje recibido desde -> ");
  Serial.println(topic);
   for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]); 
  }
  kaa.messageArrivedCallback(topic, (char*)payload, length);
  }


int commandCallback(char* command_type, char* payload, unsigned int len) {
  if (!strcmp(command_type, COMMAND_1)) {
   //DynamicJsonDocument doc(1023);
   StaticJsonDocument<255> doc_AC;
   DeserializationError error = deserializeJson(doc_AC, payload, len);
       if (error) {
     Serial.print(F("deserializeJson() failed: "));
     Serial.println(error.f_str());
           }
      else{
      JsonVariant json_var = doc_AC.as<JsonVariant>();

      Serial.print("Used command_");
      Serial.println(json_var[0]["id"].as<unsigned int>());
     int  NUMBER = json_var[0]["payload"]["number"].as<int>();
      int STATE = json_var[0]["payload"]["state"].as<int>();
          if (NUMBER==1){
           Serial.println("Command_1: True");}
            if (NUMBER==0){
           Serial.println("Command_1: False");}            
      kaa.sendCommandResultAllIds(command_type, json_var);
      }
  }
else {
    Serial.println ("Unknown command\n");
     StaticJsonDocument<255> doc_FN;
   DeserializationError error = deserializeJson(doc_FN, payload, len);
       if (error) {
     Serial.print(F("deserializeJson() failed: "));
     Serial.println(error.f_str());
       }
      else{
      JsonVariant json_var = doc_FN.as<JsonVariant>();
      kaa.sendCommandResultAllIds(command_type, json_var);}

  }
  return 0;
}

void sendOutputsState (){
     StaticJsonDocument<200> Doc;
    Doc.createNestedObject();
Doc[0]["Temperature"] = 52525;
Doc[1]["Humidity"]    = 55525252;
kaa.sendDataRaw(Doc.as<String>().c_str());
 }

void setup() {
Serial.begin(115200);
 /* Initialize WiFi */
 Serial.print("Connecting WiFi");
setup_wifi();


 /* Initialize MQTT */

return_W_Config_Callback ();
KAA_SERVER= SERVERBuf;
 KAA_TOKEN=VERSIONBuf ; 
 KAA_APP_VERSION=TOKENBuf;
 Serial.println("Conecting Mqtt");
client.setServer(KAA_SERVER, mqtt_port);     
client.setCallback(callback);
kaa.setCommandCallback(&commandCallback);
reconnect();     delay(5000);
}
void loop() {
     if (!client.connected()) reconnect(); 
   if (client.connected()) sendOutputsState(); 
client.loop();
 delay(3000);
}

Intente retornar las variables con la siguiente funcion

char* token_return(){
 char TOKENBuf[50]="";
 preferences.begin("LICENSES", false);
 String TOKEN= preferences.getString("TOKEN","");
   preferences.end();
  TOKEN.toCharArray(TOKENBuf, 50);
  return TOKENBuf; 
}

Kaa kaa(&client, token_return(), KAA_APP_VERSION);

pero como consecuencia al cargar el programa en la tarjeta me manda el siguiente error

Intente también cambiar la forma de almacenar la información utilizando la librería SPIFFS, pero no cambia nada.
Espero que puedan ayudarme resolver esto o aconsejarme otras opciones.
El objetivo principal es modificar los parametros de mqtt sin necesidad de cargar el código constantemente.

Lo que no entiendo en tu código es esto

Kaa kaa(&client, KAA_TOKEN, KAA_APP_VERSION);

KAA_TOKEN y KAA_APP_VERSION estan definidos pero client no existe.
Realmente compila?

Si, compila sin problema, client esta definido una línea arriba, de la librería PubSubClient.

Siguiente paso, necesito saber de donde descargaste estas librerías para poder compilar en mi IDE y ver que ocurre.

Si claro.

Esta librería la descargue desde aquí https://github.com/knolleary/pubsubclient/releases/tag/v2.8

Estas dos vienen incluidas al descargar la configuración para ESP32.
Y gracias por el apoyo.

Ups.. que problema con Preferences porque no tengo tu versión Nodemcu-32S
Veré si no me da problemas con la que tengo.
Mañana te cuento.

De acuerdo, puedes intentar con la version 1.0.0

Bueno he logrado compilar pero no hace nada tu código.
Luego de borrar seteos previos de WifiManager (pruebas anteriores mias) logré que arranque al menos.
Tambien tuve que agregar esto

unsigned int mqtt_port  = KAA_PORT;

para que compile.
A mi no se me cuelga el código.
Uso Nodemcu-32S que para mi sorpresa coincide con el mio.

Bueno, no se si he dado con el problema pero esto si es un problema.
Has definido esto como constantes y yo para probar puse datoss de un ejemplo de kaa

#define KAA_SERVER      "mqtt.cloud.kaaiot.com"
#define KAA_PORT 1883
#define KAA_TOKEN       "12345678"
#define KAA_APP_VERSION "1.0"

ahora mira que ocurrió al intentar compilar.

return_W_Config_Callback ();
  KAA_SERVER = SERVERBuf;
  KAA_TOKEN = VERSIONBuf ;
  KAA_APP_VERSION = TOKENBuf;

me encuentro con que pretendes asignar valores a constantes, algo que no es posible.
Este es el error que recibo

C:\Users\surby\Documents\Arduino\Nodemcu-32S\Nodemcu-32S.ino: In function 'void setup()':
Nodemcu-32S:191:14: error: assignment of read-only location '"mqtt.cloud.kaaiot.com"'
   KAA_SERVER = SERVERBuf;

No puedes asignar valores a una locacion de solo lectura.

Esto es lo que he hecho. Debes arreglar el tema de mqtt_port que ahora esta fijo.

#include <WiFi.h>
#include <PubSubClient.h>
#include <WiFiManager.h>
#include <WebServer.h>
#include <Preferences.h>
#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
#include <ArduinoJson.h>
#include "kaa.h"
Preferences preferences;

#define COMMAND_1 "COMMAND_1"

char* KAA_SERVER      =  "mqtt.cloud.kaaiot.com";
char* KAA_PORT        =  "1883";
char* KAA_TOKEN       =  "12345678";
char* KAA_APP_VERSION =  "1.0";

unsigned int mqtt_port  = 1883;
char SERVERBuf[50]      = "";
char VERSIONBuf[50]     = "";
char TOKENBuf[50]       = "";

char W_mqtt_server[40]  = "";
char W_api_token[34]    = "";
char W_mqtt_version[40] = "";


WiFiClient espClient;
WiFiManager wm;
PubSubClient client(espClient);
Kaa kaa(&client, KAA_TOKEN, KAA_APP_VERSION);

void save_W_ConfigCallback () {
  Serial.println("SAVE");
  String Str_mqtt_server = String(W_mqtt_server);
  String Str_mqtt_version = String(W_mqtt_version);
  String Str_mqtt_token = String(W_api_token);
  preferences.begin("LICENSES", false);
  if (Str_mqtt_server != "") {
    preferences.putString("SERVER", Str_mqtt_server);
    Serial.print("Server: "); Serial.println(W_mqtt_server);
  }
  if (Str_mqtt_version != "") {
    preferences.putString("VERSION", Str_mqtt_version);
    Serial.print("Token: "); Serial.println(W_api_token);
  }
  if (Str_mqtt_token != "")  {
    preferences.putString("TOKEN", Str_mqtt_token);
    Serial.print("Version: "); Serial.println(W_mqtt_version);
  }
  preferences.end();
}

void return_W_Config_Callback () {
  Serial.println("RECOVERED DATA");
  preferences.begin("LICENSES", false);
  String SERVER   = preferences.getString("SERVER", "");
  String VERSION  = preferences.getString("VERSION", "");
  String TOKEN    = preferences.getString("TOKEN", "");
  preferences.end();
  SERVER.toCharArray(SERVERBuf, 50);
  VERSION.toCharArray(VERSIONBuf, 50);
  TOKEN.toCharArray(TOKENBuf, 50);
  Serial.print("Server: ");     Serial.println(SERVERBuf);
  Serial.print("Token: ");      Serial.println(TOKENBuf);
  Serial.print("Version: ");    Serial.println(VERSIONBuf);
}

/*WIFI MANAGER*/
void configModeCallback (WiFiManager *myWiFiManager) {
  Serial.println("Conect AutoConnectAP ");
  Serial.println(WiFi.softAPIP());
  Serial.println(myWiFiManager->getConfigPortalSSID());
}

void setup_wifi() {
  WiFi.persistent(true);
  WiFi.mode(WIFI_STA);
  //wm.resetSettings();
  wm.setAPCallback(configModeCallback);
  WiFiManagerParameter custom_W_mqtt_server("Server",   "MQTT Server" , W_mqtt_server , 40);
  WiFiManagerParameter custom_W_mqtt_version("Version", "MQTT Version", W_mqtt_version, 40);
  WiFiManagerParameter custom_W_api_token("Token",      "MQTT Token"  , W_api_token   , 34);
  //add all your parameters here
  wm.addParameter(&custom_W_mqtt_server);
  wm.addParameter(&custom_W_mqtt_version);
  wm.addParameter(&custom_W_api_token);

  if (!wm.autoConnect("AutoConnectAP", "12345678")) {
      Serial.println("failed to connect ");
      delay(2000);
  }
  strcpy(W_mqtt_server, custom_W_mqtt_server.getValue());
  strcpy(W_mqtt_version, custom_W_mqtt_version.getValue());
  strcpy(W_api_token, custom_W_api_token.getValue());
  save_W_ConfigCallback ();
  Serial.println("WIFI connected");
}
/*CONEXION MQTT*/
void reconnect()
{
  if (WiFi.status() == WL_CONNECTED) {
    while (!client.connected())     {
      Serial.print("Conecting Mqtt...");
      String clientId = "Client_Esp";   // Create a Client ID
      clientId += String(random(0xffff), HEX); //Add a random number to make unique the Client ID
      if (client.connect(clientId.c_str())) { // Try to connect to MQTT broker
          Serial.println("Connected!");
          kaa.connect();
      }
      else      { 
        Serial.print("failed to connect ");
        Serial.println(client.state());

        delay(5000);
      }
    }
  }

}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido desde -> ");
  Serial.println(topic);
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  kaa.messageArrivedCallback(topic, (char*)payload, length);
}


int commandCallback(char* command_type, char* payload, unsigned int len) {
  if (!strcmp(command_type, COMMAND_1)) {
    //DynamicJsonDocument doc(1023);
    StaticJsonDocument<255> doc_AC;
    DeserializationError error = deserializeJson(doc_AC, payload, len);
    if (error) {
      Serial.print(F("deserializeJson() failed: "));
      Serial.println(error.f_str());
    }
    else {
      JsonVariant json_var = doc_AC.as<JsonVariant>();

      Serial.print("Used command_");
      Serial.println(json_var[0]["id"].as<unsigned int>());
      int  NUMBER = json_var[0]["payload"]["number"].as<int>();
      int STATE = json_var[0]["payload"]["state"].as<int>();
      if (NUMBER == 1) {
        Serial.println("Command_1: True");
      }
      if (NUMBER == 0) {
        Serial.println("Command_1: False");
      }
      kaa.sendCommandResultAllIds(command_type, json_var);
    }
  }
  else {
    Serial.println ("Unknown command\n");
    StaticJsonDocument<255> doc_FN;
    DeserializationError error = deserializeJson(doc_FN, payload, len);
    if (error) {
      Serial.print(F("deserializeJson() failed: "));
      Serial.println(error.f_str());
    }
    else {
      JsonVariant json_var = doc_FN.as<JsonVariant>();
      kaa.sendCommandResultAllIds(command_type, json_var);
    }

  }
  return 0;
}

void sendOutputsState () {
  StaticJsonDocument<200> Doc;
  Doc.createNestedObject();
  Doc[0]["Temperature"] = 52525;
  Doc[1]["Humidity"]    = 55525252;
  kaa.sendDataRaw(Doc.as<String>().c_str());
}

void setup() {
  Serial.begin(115200);
  /* Initialize WiFi */
  Serial.print("Connecting WiFi");
  setup_wifi();
  strcpy(SERVERBuf, KAA_SERVER);
  strcpy(VERSIONBuf,KAA_TOKEN);
  strcpy(TOKENBuf,  KAA_APP_VERSION);
  /* Initialize MQTT */

  return_W_Config_Callback ();
  

  Serial.println("Conecting Mqtt");
  client.setServer(SERVERBuf, mqtt_port);
  client.setCallback(callback);
  kaa.setCommandCallback(&commandCallback);
  reconnect();     delay(5000);
}

void loop() {
  if (!client.connected()) reconnect();
  if (client.connected()) sendOutputsState();
  client.loop();
  delay(3000);
}

Al código le hice unos cambios menores.
Cambie los #define por char * y le puese datos

char* KAA_SERVER      =  "mqtt.cloud.kaaiot.com";
char* KAA_PORT        =  "1883";
char* KAA_TOKEN       =  "12345678";
char* KAA_APP_VERSION =  "1.0";

Obviamente luego los borras y debería recuperarlos.

En una primer compilación tmb repetí acá

char W_mqtt_server[40]  = "mqtt.cloud.kaaiot.com";
char W_api_token[34]    = "12345678";
char W_mqtt_version[40] = "1.0";

y luego recompilas y los pones "" y verás que los recupera correctamente.

Realmente no es lo correcto pero era para comprobar que el código funciona.
Te queda simplificar cosas. pero por ahi van los tiros.

De acuerdo , gracias, si guarda los datos asi, solo que el servidor, si lo actualiza de acuerdo a lo que recupero de la memoria, pero KAA_TOKEN Y KAA_APP_VERSION no, aunque tenga existo en gurdarse y recuperarse el dato, no se ve reflejado al momento que corre el programa, se queda con los datos que agregamos al compilar.

estos dos

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.