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.