OTA cannot be seen in the arduino ide #160

jagonzalezga · 2022-06-23T21:15:04Z

jagonzalezga
Jun 23, 2022

hello how are you, i have been working with the OTA library at home and everything worked fine, the arduino ide detects it but when changing to another network it does not appear in the ide, but the rest works except for the power part compile it via OTA.

I hope someone knows what it could be.

this is a header file

`#ifdef ESP32
#include <WiFi.h>
#include <ESPmDNS.h>
#else
#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#endif
#include <RTClib.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

int restart1=0;
RTC_DS3231 RTC;
#if defined(ESP32_RTOS) && defined(ESP32)
void ota_handle( void * parameter ) {
for (;;) {

ArduinoOTA.handle();
  delay(500);

}
}
#endif

void setupOTA(const char* nameprefix, const char* ssid, const char* password,const char* Adjust) {
Serial.println("ENTRO A RUTINA SETUP OTA");
// Configure the hostname
uint16_t maxlen = strlen(nameprefix) + 7;
char *fullhostname = new char[maxlen];
uint8_t mac[6];
WiFi.macAddress(mac);
snprintf(fullhostname, maxlen, "%s-%02x%02x%02x", nameprefix, mac[3], mac[4], mac[5]);
ArduinoOTA.setHostname(fullhostname);
delete[] fullhostname;

/*
WiFi.mode(WIFI_STA) station mode: the ESP32 connects to an access point
WiFi.mode(WIFI_AP) access point mode: stations can connect to the ESP32
WiFi.mode(WIFI_STA_AP) access point and a station connected to another access point
*/
WiFi.mode(WIFI_STA);//esta seccion me inidca en que tipo de modo se utilizara el esp32
WiFi.begin(ssid, password);//una vez configurado el json se extraen los valores de ssid y la contraseña del wifi
Serial.print("Connecting to WiFi ..");
/*para saber el estatus de nuestra conexion a wifi llamamos una funcion while que este checando el estatus
si es diferente a WL_CONNECTED y la variable restart es menor a 30 se hara la iteracion

*/
while (WiFi.status() != WL_CONNECTED and restart1 < 30)
{
    Serial.print('.');
    restart1++;
    delay(1000);
}
//si se cumple mas de 30 iteraciones y no se pudo conectar al internet se hace un reset por codigo al esp32
if (restart1 >= 30)
{
    //La funcion ESP.restart() es llamada,la ejecucion del programa es parada, ambos cpu´s son reseteados, y la aplicacion 
    //es cargada por el bootloadery empieza la ejecucion de nuevo
    ESP.restart();
}

WiFi.setAutoReconnect(true);
WiFi.persistent(true);

if(Adjust){
    Serial.println("Entro a actualizar la hora");
    RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));

}

// Port defaults to 3232
// ArduinoOTA.setPort(3232); // Use 8266 port if you are working in Sloeber IDE, it is fixed there and not adjustable

// No authentication by default
// ArduinoOTA.setPassword("admin");

// Password can be set with it's md5 value as well
// MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
// ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");

ArduinoOTA.onStart( {
//NOTE: make .detach() here for all functions called by Ticker.h library - not to interrupt transfer process in any way.
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
type = "filesystem";

// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
Serial.println("Start updating " + type);

});

ArduinoOTA.onEnd( {
Serial.println("\nEnd");
});

ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
});

ArduinoOTA.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("\nAuth Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("\nBegin Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("\nConnect Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("\nReceive Failed");
else if (error == OTA_END_ERROR) Serial.println("\nEnd Failed");
});

ArduinoOTA.begin();

Serial.println("OTA Initialized");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
Serial.println("\n");

#if defined(ESP32_RTOS) && defined(ESP32)
xTaskCreate(
ota_handle, /* Task function. /
"OTA_HANDLE", / String with name of task. /
10000, / Stack size in bytes. /
NULL, / Parameter passed as input of the task /
1, / Priority of the task. /
NULL); / Task handle. */
#endif
}`

this a main file

`#include <RTClib.h>
#include <SocketIoClient.h>
#include "FS.h"
#include "SD.h"
#include "SPI.h"
#include <Wire.h>//libreria encargada de la interfaz i2c
#include <Arduino_JSON.h>
#include <WiFi.h>
//#include <WebSocketsClient.h>
#include <Adafruit_ADS1X15.h>//libreria del adc
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <OneWire.h>//biblioteca usada para los dispositivos que un solo cable como el sensor DS18620
#include <DallasTemperature.h>//libreria para el control y manejo del sensor DS18620
///////////////////////////////////////////

#include "OTA.h"
///////////////////////////////////

#pragma region variables
//estas tareas se dividen en dos ya que el esp tiene dos nucleos
TaskHandle_t Task1;
TaskHandle_t Task2;
//aqui declaramos las variables JSON con el tipo de dato JSONVar
JSONVar esp32,response,jsonResponse,jsonDigitales;

int restart = 0;//variable que se usa en la seccion de wifi para el conteo
bool enviarDigitales = false;

SocketIoClient socketIO;
//SocketIoClient socket;
Adafruit_ADS1115 ads;
RTC_DS3231 myRTC;

#define SCREEN_WIDTH 128 //constante definida para el ancho del oled display
#define SCREEN_HEIGHT 32 //constante definida para la altura del oled display
#define OLED_RESET 4 //pin de reset de la pantalla oled display
#define SDB 27 //gpio donde el sensor DS18620 sera conectado

float volt = 0,
lectura = 0,
Vcc = 3.3,
VccAds = 4.096,
Resistencia = 10000,
K = 2.5,
constanteV = 4095,
constanteVAds = 32767,
delayR = 2,
pantallaTemperatura;

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

/*el sensor de temperatura DS18620 es un sensor de un solo cable y digital, esto significa que requiere una lina de datps y gnd para comunicarse
con el esp32, cada sensor de temperatura tiene un codigo serial unico de 64bits. Esto permite que podamos conectar multiple sennsores en la misma linea
1.-se comunica a traves de one-wire comunicacion
2.-opera entre 3.0v a 5.5v
3.-rango de operacion de temperatura -55c a +125c
4.-precision de +/-0.5 grados centigrado(entre el rango de -10c a 85c)
*/
OneWire oneWire(SDB);//configura la instancia onewire para comunicarce con culaquier dispositivo que maneje el protocolo onewire
DallasTemperature sensors(&oneWire); //pasa nuestra referencia de la instancia onewire a la biblioteca de DallasTemperature
int numberOfDevices;//variable que guarda en numero de dispositivos que estan conectados al bus de datos
DeviceAddress tempDeviceAddress;

String address = "";

#pragma endregion comment

#pragma region DISPLAY_Methods
//________________________________________________________________
void initDisplay()
{

if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))
{ // Address 0x3C for 128x32
    Serial.println(F("SSD1306 allocation failed"));
    for (;;)
        ; // Don't proceed, loop forever
}

// Show initial display buffer contents on the screen --
// the library initializes this with an Adafruit splash screen.
display.display();
delay(2000); // Pause for 2 seconds

// Clear the buffer
display.clearDisplay();
display.display();
delay(1000);

}

void initTime()
{

myRTC.begin();

if(esp32["variables"]["adjustTime"]){
myRTC.adjust(DateTime(atoi(esp32["variables"]["fecha"]["ano"]),//año
                          atoi(esp32["variables"]["fecha"]["mes"]),//mes
                          atoi(esp32["variables"]["fecha"]["dia"]),//dia
                          atoi(esp32["variables"]["tiempo"]["hora"]),//hora
                          atoi(esp32["variables"]["tiempo"]["minutos"]),//minutos
                          atoi(esp32["variables"]["tiempo"]["segundos"])));//segundos
}

if (myRTC.lostPower())
{
     myRTC.adjust(DateTime(atoi(esp32["variables"]["fecha"]["ano"]),//año
                           atoi(esp32["variables"]["fecha"]["mes"]),//mes
                           atoi(esp32["variables"]["fecha"]["dia"]),//dia
                           atoi(esp32["variables"]["tiempo"]["hora"]),//hora
                           atoi(esp32["variables"]["tiempo"]["minutos"]),//minutos
                           atoi(esp32["variables"]["tiempo"]["segundos"])));//segundos
}

}

String getDateTime()
{

char str[50];
DateTime now = myRTC.now();
uint32_t timestamp = now.unixtime();

// Serial.println(timestamp);

sprintf(str, "%02d/%02d/%02d %02d:%02d:%02d", now.year(), now.month(), now.day(), now.hour(), now.minute(), now.second());
// Serial.println(str);

return str;

}

String getDateTimeStr()
{

char str[50];
DateTime now = myRTC.now();
uint32_t timestamp = now.unixtime();

// Serial.println(timestamp);

sprintf(str, "%02d", timestamp);

// Serial.println(str);

return str;

}
//________________________________________________________________
void textDraw()
{

display.clearDisplay();

display.setTextSize(0.3);
display.setTextColor(WHITE);
display.setCursor(0, 0);
display.println(esp32["device"]["CodigoMDC"]);

display.setTextSize(0.3);
display.setTextColor(WHITE);
display.setCursor(0, 12);
display.println(WiFi.localIP());

display.setTextSize(0.3);
display.setTextColor(WHITE);
display.setCursor(0, 24);
display.println(getDateTime());

display.display();
delay(500);

}
//________________________________________________________________
void textDrawError()
{

display.clearDisplay();

display.setTextSize(0.3);
display.setTextColor(WHITE);
display.setCursor(0, 0);
display.println(esp32["device"]["CodigoMDC"]);

display.setTextSize(0.3);
display.setTextColor(WHITE);
display.setCursor(0, 12);
display.println("Network not found");

display.setTextSize(0.3);
display.setTextColor(WHITE);
display.setCursor(0, 24);
display.println(getDateTime());

display.display();
delay(500);

}
//________________________________________________________________
#pragma endregion commit

#pragma region ADS
//________________________________________________________________
void getGain(int i){
switch (i)
{
case 1:
ads.setGain(GAIN_ONE);
break;
case 2:
ads.setGain(GAIN_TWO);
break;
case 4:
ads.setGain(GAIN_FOUR);
break;
case 8:
ads.setGain(GAIN_EIGHT);
break;
case 16:
ads.setGain(GAIN_SIXTEEN);
break;
case 23:
ads.setGain(GAIN_TWOTHIRDS);
break;
}
}
//________________________________________________________________
void initADS(){
if(esp32["variables"]["statusAPS"]){
ads.setGain(GAIN_ONE);//GAIN_ONE = ADS1X15_REG_CONFIG_PGA_4_096V,
ads.begin();
}
}
//________________________________________________________________
#pragma endregion comment

#pragma region SD_Methods
//________________________________________________________________
bool isTypeSDExists()
{

if (!SD.begin())
{
    return false;
}

uint8_t cardType = SD.cardType();

if (cardType == CARD_NONE)
{
    return false;
}
else if (cardType == CARD_MMC)
{
    return true;
}
else if (cardType == CARD_SD)
{
    return true;
}
else if (cardType == CARD_SDHC)
{
    return true;
}

}
//________________________________________________________________
void createDir(fs::FS &fs, const char *path)
{
Serial.printf("Creating Dir: %s\n", path);
if (fs.mkdir(path))
{
Serial.println("Dir created");
}
else
{
Serial.println("mkdir failed");
}
}
//________________________________________________________________
void removeDir(fs::FS &fs, const char *path)
{
Serial.printf("Removing Dir: %s\n", path);
if (fs.rmdir(path))
{
Serial.println("Dir removed");
}
else
{
Serial.println("rmdir failed");
}
}
//________________________________________________________________
void deleteFile(fs::FS &fs, const char *path)
{
Serial.printf("Deleting file: %s\n", path);
if (fs.remove(path))
{
Serial.println("File deleted");
}
else
{
Serial.println("Delete failed");
}
}
//________________________________________________________________
void writeFile(fs::FS &fs, const char *path, const char *message)
{
Serial.printf("Writing file: %s\n", path);

File file = fs.open(path, FILE_WRITE);
if (!file)
{
    Serial.println("Failed to open file for writing");
    return;
}
if (file.print(message))
{
    Serial.println("File written");
}
else
{
    Serial.println("Write failed");
}
file.close();

}
//________________________________________________________________
String getDataFromSD(fs::FS &fs, const char *path)
{

Serial.printf("Leyendo archivo: %s\n", path);
String finalString = "";

File file = fs.open(path);

if (!file)
{
    finalString = "0x0091";
}
else
{

    Serial.print("Read from file2: ");
    while (file.available())
    {
                // Serial.write(file.read());

// filebytes = Serial.write(file.read());
finalString += (char)file.read();
}
}

file.close();

delay(1000);

if (finalString.length() > 0)
{
    return finalString;
}
else
{
    return "No se pudo recavar informacion";
}

}
//se manda a llamar la funcion desde el void setup
void initSD()
{

if (isTypeSDExists())//si la funcion retorna un valor de tipo de memoria sd ejecuta las siguientes instrucciones
{
    // getDataFromSD(SD, "/config.json");

    esp32 = null;
    Serial.println(esp32);
    //el metodojson.parse analiza una cadena de texto como json , transformandoopcionalmente el valor producido por el analisis
    //despues utiliza la funcion getDataFromSD 
     esp32 = JSON.parse(getDataFromSD(SD, "/config.json"));
    Serial.println(esp32["red"]);
    Serial.println(esp32["device"]);
    Serial.println(esp32["variables"]);
    Serial.println(esp32["setup"]);

}else
{
    Serial.println("No existe el tipo de sd para este programa");//si no retorna algun tipo de sd permitoda emite este mensaje deerror
}

}
//________________________________________________________________
#pragma endregion comment

#pragma region WIFI_Methods
//________________________________________________________________

//________________________________________________________________
#pragma endregion commit

#pragma region WebSocket_Methods
//________________________________________________________________
void onRestartByWs(const char *payload, size_t length)
{
Serial.printf("got message: %s\n", payload);
if (strlen(payload) != 0)
{
Serial.println("Metodo Reiniciar");
String datos = String(payload);
datos.replace("\", "");
JSONVar restartESP = JSON.parse(datos);
if((strcmp(restartESP["CodigoMDC"],esp32["device"]["CodigoMDC"])) == 0){
ESP.restart();
}
}
}
//________________________________________________________________
void onRelayByWs(const char *payload, size_t length)//
{
Serial.printf("got message: %s\n", payload);
if (strlen(payload) != 0)
{
Serial.println("Metodo encender apagar Relay");
String datos = String(payload);
datos.replace("\", "");
JSONVar restartESP = JSON.parse(datos);
if((strcmp(restartESP["Code"],esp32["device"]["CodigoMDC"])) == 0){
int pin = int(atoi(restartESP["p"]));
pinMode(pin,OUTPUT);
if((strcmp(restartESP["v"],"1.00"))==0){
digitalWrite(pin,HIGH);
Serial.println("Apagar Salida");
sendInfoWebSocket("SetRelee",restartESP);
}else{
digitalWrite(pin,LOW);
Serial.println("Encender Salida");
sendInfoWebSocket("SetRelee",restartESP);
}
}
}
}
//________________________________________________________________
void onGetConfigurationByWs(const char *payload, size_t length)
{
Serial.printf("got message: %s\n", payload);
if (strlen(payload) != 0)
{
String datos = String(payload);
datos.replace("\", "");
jsonResponse = JSON.parse(datos);
if (JSON.typeof(jsonResponse) == "undefined")
{
Serial.println("Parsing input failed!");
return;
}
if ((strcmp(jsonResponse["idRespuesta"], "1")) == 0){
if ((strcmp(jsonResponse["Code"], esp32["device"]["CodigoMDC"])) == 0)
{

            loadPins();

        }else{

            Serial.println("Error en el dispositivo");
        }
    }else{
        Serial.println("Error en el dispositivo");
    }
}

}
//________________________________________________________________
void loadPins(){
Serial.println("llegamos a la funcion loadPins");
if (jsonResponse["Pines"].length() > 0){
for (int cnt = 0; cnt < jsonResponse["Pines"].length(); cnt++)
{
Serial.println(jsonResponse["Pines"][cnt]);
if((strcmp(jsonResponse["Pines"][cnt]["t"],"REL")) == 0){
pinMode(int(atoi(jsonResponse["Pines"][cnt]["p"])), OUTPUT);
JSONVar jss = esp32["sendServer"];
jsonResponse["Pines"][cnt]["sendServer"] = jss;
}else if((strcmp(jsonResponse["Pines"][cnt]["t"],"TDI")) != 0){
pinMode(int(atoi(jsonResponse["Pines"][cnt]["p"])), INPUT);
JSONVar js = esp32["varPines"];
JSONVar jss = esp32["sendServer"];
// jss["CodigoMDC"]=esp32+["device"]["CodigoMDC"];
jsonResponse["Pines"][cnt]["vars"] = js;
jsonResponse["Pines"][cnt]["sendServer"] = jss;

            esp32["setup"] = jsonResponse;
        }
    }

    if (!esp32["variables"]["createdAt"]){
        Serial.println("Se creara archivo por primera vez");
        esp32["variables"]["createdAt"] = true;
        crearConfigFile();
        sendInfoWebSocket("ConfiguracionAplicada",esp32["device"]);
    }else if((strcmp(jsonResponse["cambio"],"1")) == 0){
        Serial.println("Se creara archivo");
        esp32["setup"] = jsonResponse;
        crearConfigFile();
        sendInfoWebSocket("ConfiguracionAplicada",esp32["device"]);
    }
}

}
//________________________________________________________________

/*
esta fucnion es la que emite los eventos y la variable json
el evento que esta en la parte del servidor con listener .on aobtiene el evento y recibe el JSONVar
lo traduce a una caden de estilo c con la funcion c_str() y los serilaiza con la funcion stringify()
/
void sendInfoWebSocket(String metodo, JSONVar object)//
{
if(esp32["variables"]["statusWs"]){
socketIO.emit(metodo.c_str(), JSON.stringify(object).c_str());//manda allamar el evento de emit de la libreria de socketIO.emit
}
}
//________________________________________________________________
/
esta funcion depende de la libreria SocketIoClient.h
void SocketIoClient::on(const char* event, std::function<void (const char * payload, size_t length)> func) {
_events[event] = func;
}

*/
void initWebSocket()
{
if(esp32["variables"]["statusWs"])
{
// server address, port and URL
socketIO.begin(esp32["server"]["host"], int(atoi(esp32["server"]["port"])));
// event handler for the event message
socketIO.on("GetConfiguracion",onGetConfigurationByWs);//listener
socketIO.on("Reiniciar", onRestartByWs);//listener
socketIO.on("SetRelee", onRelayByWs);//listener
sendInfoWebSocket("GetConfiguracion",esp32["device"]);//manda a llamar la funcion sendInfoWebSocket le pasa los argumentos del evento y del dispositivo
}

}
//________________________________________________________________
#pragma endregion commit

#pragma region EXTRAS_Methods
//________________________________________________________________
void crearConfigFile()
{

deleteFile(SD, "/config.json");
String str_json = JSON.stringify(esp32);
writeFile(SD, "/config.json", str_json.c_str());
Serial.print("archivo: ");
Serial.println(getDataFromSD(SD, "/config.json"));

}
//________________________________________________________________
int16_t getPositionADS(int sel){
switch (sel)
{
case 100:
return ads.readADC_SingleEnded(0);
break;
case 101:
return ads.readADC_SingleEnded(1);
break;
case 102:
return ads.readADC_SingleEnded(2);
break;
case 103:
return ads.readADC_SingleEnded(3);
break;
}
}
//________________________________________________________________

//________________________________________________________________

float getTemperatureDigital(){

sensors.requestTemperatures();

float celsius = sensors.getTempCByIndex(0);

if (isnan(celsius)){
    celsius = 0.0;
}

return celsius;

}
//________________________________________________________________
float getCurrent(float raw,float volRange,float constantRaw,int cCorriente){
float a = ((((raw * volRange) / constantRaw) * cCorriente) / 5);
return a;
}
//________________________________________________________________
void checkInfo(JSONVar sensor,float value){
//se hace la media para hacer el calculo
if (int(atoi(sensor["vars"]["countSamplers"])) == int(atoi(sensor["vars"]["maxSamplers"]))){
float t = (float)int(atoi(sensor["vars"]["averageSamplers"])) / int(atoi(sensor["vars"]["maxSamplers"]));
if (int(atoi(sensor["vars"]["lastRegister"])) != int(t)){
sensor["vars"]["lastRegister"] = "0";
sensor["vars"]["lastRegister"] = String(int(t));
sensor["sendServer"]["Fecha"] = getDateTime();
sensor["sendServer"]["Valor"] = String(int(value));
sensor["sendServer"]["GPIO"] = JSON.stringify(sensor["p"]).c_str();
sendInfoWebSocket("stateChanged",sensor["sendServer"]);
Serial.print("Load pins Sensor: ");
Serial.println(sensor);
}
sensor["vars"]["averageSamplers"] = "0";
sensor["vars"]["countSamplers"] = "0";
}else{
int sum = 0;
sum = int(atoi(sensor["vars"]["averageSamplers"])) + (int)value;
sensor["vars"]["averageSamplers"] = String(sum);
int num = int(atoi(sensor["vars"]["countSamplers"])) + 1;
sensor["vars"]["countSamplers"] = String(num);
}

}
//________________________________________________________________
void checkInfoCor(JSONVar sensor,float value){

if (int(atoi(sensor["vars"]["countSamplers"])) == int(atoi(sensor["vars"]["maxSamplers"]))){
    float t = (float)int(atoi(sensor["vars"]["averageSamplers"])) / int(atoi(sensor["vars"]["maxSamplers"]));
    if (int(atoi(sensor["vars"]["lastRegister"])) != int(t)){
        sensor["vars"]["lastRegister"] = "0";
        sensor["vars"]["lastRegister"] = String(int(t));
        sensor["sendServer"]["Fecha"] = getDateTime();
        sensor["sendServer"]["Valor"] = String(value);
        sensor["sendServer"]["GPIO"] = JSON.stringify(sensor["p"]).c_str();
        sendInfoWebSocket("stateChanged",sensor["sendServer"]);
        Serial.print("Sensor: ");
        Serial.println(sensor);
    }
    sensor["vars"]["averageSamplers"] = "0";
    sensor["vars"]["countSamplers"] = "0";
}else{
    int sum = 0;
    sum = int(atoi(sensor["vars"]["averageSamplers"])) + (int)value;
    sensor["vars"]["averageSamplers"] = String(sum);
    int num = int(atoi(sensor["vars"]["countSamplers"])) + 1;
    sensor["vars"]["countSamplers"] = String(num);
}

}
//________________________________________________________________
#pragma endregion commit

#pragma region SensoresTemperaturaDigital
//________________________________________________________________
// function to print a device address
String printAddress(DeviceAddress deviceAddress) {
address = "";
for (uint8_t i = 0; i < 8; i++){
if (deviceAddress[i] < 16){
address = address + "0";
}else{
address = address + String(deviceAddress[i],HEX);
}

}
return address;

}
//________________________________________________________________
void InitDigitalTemperature()
{
sensors.begin();

// Grab a count of devices on the wire
//obtiene
numberOfDevices = sensors.getDeviceCount();//manda a llamar la funcion de la libreria dallas y retorna elnumero de dispositivos conectados al bus de datos

// locate devices on the bus
Serial.print("Locating devices...");
Serial.print("Found ");
Serial.print(numberOfDevices, DEC);
Serial.println(" devices.");


//loop a traves de cada dispositivo,imprimiendo la direccion
for(int i=0;i<numberOfDevices; i++){
    // Search the wire for address
    if(sensors.getAddress(tempDeviceAddress, i)){
        String ad = printAddress(tempDeviceAddress);//manda a llamar la funcion de printAddress aqui en el mismo codigo y nos retorna un String
        String adp = "27," + ad;//aqui se le agrega el punto decimal para poder reconocerlos
        JSONVar j = esp32["digitalPin"];//se crea una variable tipo json y se iguala al valor de esp32["digitalPin"]
        JSONVar js = esp32["varPines"];//se crea una variable tipo json y se iguala al valor de esp32["varPines"]
        JSONVar jss = esp32["sendServer"];//se crea una variable tipo json y se iguala al valor de esp32["sendServer"]
        j["p"] = adp.c_str();//
        j["id"] = "20" + String(i);
        jsonDigitales[i] = j;
        jsonDigitales[i]["vars"] = js;
        jsonDigitales[i]["sendServer"] = jss;
        Serial.println(jsonDigitales[i]);
    } else {
        Serial.print("Found ghost device at ");
        Serial.print(i, DEC);
        Serial.print(" but could not detect address. Check power and cabling");
    }
}

}
//________________________________________________________________
#pragma endregion commit
//________________________________________________________________
void Task1code( void * parameter ){
Serial.print("Task1 is running on core ");
Serial.println(xPortGetCoreID());
while(1){
socketIO.loop();
//delay(500);
vTaskDelay(pdMS_TO_TICKS(500)); // Delay for 1000 milliseconds
}
}
//________________________________________________________________
void setup()
{
Serial.begin(115200);// inicializa el baud rate para la comunicacion de la tablilla de desarrollo

/*El esp32 tiene dos interfaces de i2c que pueden servir de maestro o esclavo 
SCL= clock signal SDA=send and recive data en este casoson los pines 33 para el SDA y el 36 para SCL
ojo no confundir con la libreria de onewire son cosas diferentes
*/
Wire.begin();
initSD();//"Funcion muy importante poner mucha atencion"
setupOTA(esp32["device"]["CodigoMDC"],esp32["red"]["ssid"],esp32["red"]["ssidPass"],esp32["variables"]["adjustTime"]);
initTime();//inicia los valores del reloj RTC
initDisplay();//inicializa los parametros para la pantalla oled dependiendo del formato que se use pantalla en este caso Address 0x3C for 128x32

/*
la inicializacion de la SD es muy importante por que se hace uso de la variable del tipo JSONVar
JSONVar esp32 se iguala al archivo config.json variable que se usa mucho en el voidloop para obtener valores de configuracion
*/







/*aqui se adquieren los valores de la variable esp32 que es tipoJSONVar para obtener el estatus del webSocket (host,puerto)
ademas se hace uso de tres funciones que son
1.-onGetConfigurationByWs
2.-onRestartByWs
3.-onRelayByWs
toda esta informacion la obtenemos del servidor el nos regresa los datos para poder configurar de manera correcta el esp32
*/
initWebSocket();

initADS();//aqui se usa la variaable esp32["variables"]["statusAPS"]

/*
en esta funcion se inicializa la funcion sensors.begin() para saber el numero de dispositivos en el bus de datos y asigna los valores de la
nueva varaiable JSONVar jsonDigitales
*/
InitDigitalTemperature();

xTaskCreatePinnedToCore(
    Task1code,  //funcion tarea
    "Task1",    //nombre de la tarea en tipo String
    10000,      //tamaño de la pila en palabras
    NULL,       //parametro de entrada de la tarea
    1,          //prioridad de la tarea
    &Task1,     //manejador dela tarea
    0
    );                         
delay(500);

}
//________________________________________________________________
void loop()
{

if(esp32["setup"]["Pines"].length() > 0){
    for (int cnt = 0; cnt < esp32["setup"]["Pines"].length(); cnt++)
    {
        if((strcmp(esp32["setup"]["Pines"][cnt]["t"],"TAC")) == 0){

            if(esp32["variables"]["statusAPS"]){

    

            }

        }else if((strcmp(esp32["setup"]["Pines"][cnt]["t"],"TAN")) == 0){

            

        }else if((strcmp(esp32["setup"]["Pines"][cnt]["t"],"CAC")) == 0){

            if(esp32["variables"]["statusAPS"]){

                checkInfoCor(esp32["setup"]["Pines"][cnt],getCurrent(getPositionADS(int(atoi(esp32["setup"]["Pines"][cnt]["p"]))),VccAds,constanteVAds,int(atoi(esp32["setup"]["Pines"][cnt]["vars"]["constanteCorriente"]))));

            }

        }else if((strcmp(esp32["setup"]["Pines"][cnt]["t"],"CAN")) == 0){

            checkInfoCor(esp32["setup"]["Pines"][cnt],getCurrent(analogRead(int(atoi(esp32["setup"]["Pines"][cnt]["p"]))),Vcc,constanteV,int(atoi(esp32["setup"]["Pines"][cnt]["vars"]["constanteCorriente"]))));

        }else if((strcmp(esp32["setup"]["Pines"][cnt]["t"],"CDI")) == 0){

            checkInfo(esp32["setup"]["Pines"][cnt],getCurrent(digitalRead(int(atoi(esp32["setup"]["Pines"][cnt]["p"]))),Vcc,constanteV,int(atoi(esp32["setup"]["Pines"][cnt]["vars"]["constanteCorriente"]))));

        }else if((strcmp(esp32["setup"]["Pines"][cnt]["t"],"EST")) == 0){

            if (digitalRead(int(atoi(esp32["setup"]["Pines"][cnt]["p"])))){
                if ((strcmp(esp32["setup"]["Pines"][cnt]["vars"]["openClose"],"1"))==0){
                    esp32["setup"]["Pines"][cnt]["vars"]["openClose"] = "0";
                    Serial.println(esp32["setup"]["Pines"][cnt]);
                    esp32["setup"]["Pines"][cnt]["sendServer"]["Fecha"] = getDateTime();
                    esp32["setup"]["Pines"][cnt]["sendServer"]["Valor"] = "1";
                    esp32["setup"]["Pines"][cnt]["sendServer"]["GPIO"] = JSON.stringify(esp32["setup"]["Pines"][cnt]["p"]).c_str();
                    sendInfoWebSocket("stateChanged",esp32["setup"]["Pines"][cnt]["sendServer"]);
                }
            }else{
                if ((strcmp(esp32["setup"]["Pines"][cnt]["vars"]["openClose"],"0"))==0){
                    esp32["setup"]["Pines"][cnt]["vars"]["openClose"] = "1";
                    Serial.println(esp32["setup"]["Pines"][cnt]);
                    esp32["setup"]["Pines"][cnt]["sendServer"]["Fecha"] = getDateTime();
                    esp32["setup"]["Pines"][cnt]["sendServer"]["Valor"] = "0";
                    esp32["setup"]["Pines"][cnt]["sendServer"]["GPIO"] = JSON.stringify(esp32["setup"]["Pines"][cnt]["p"]).c_str();
                    sendInfoWebSocket("stateChanged",esp32["setup"]["Pines"][cnt]["sendServer"]);
                }
            }

        }
    }
}




if(numberOfDevices > 0 ){

    sensors.requestTemperatures(); // Send the command to get temperatures

    // Loop through each device, print out temperature data
    for(int i=0;i<numberOfDevices; i++){
        // Search the wire for address
        if(sensors.getAddress(tempDeviceAddress, i)){
            float tempC = sensors.getTempC(tempDeviceAddress);
            // Serial.println(tempC);
            // Serial.println(jsonDigitales[i]);
            if (int(atoi(jsonDigitales[i]["vars"]["lastRegister"])) != int(tempC)){
                jsonDigitales[i]["vars"]["lastRegister"] = "0";
                jsonDigitales[i]["vars"]["lastRegister"] = String(int(tempC));
                jsonDigitales[i]["sendServer"]["Fecha"] = getDateTime();
                jsonDigitales[i]["sendServer"]["Valor"] = String(int(tempC));
                jsonDigitales[i]["sendServer"]["GPIO"] = JSON.stringify(jsonDigitales[i]["p"]).c_str();
                enviarDigitales = true;
                sendInfoWebSocket("stateChanged",jsonDigitales[i]["sendServer"]);
                Serial.print("Sensor: ");
                Serial.println(jsonDigitales[i]);
            }
        }
    }

// if(enviarDigitales){
// enviarDigitales = false;
// sendInfoWebSocket("stateChanged",jsonDigitales);
// }

}
if(WiFi.status() != WL_CONNECTED){

    textDrawError();

}else{
    textDraw();

}
ArduinoOTA.handle();

}`

so thats the problem basically

JAndrassy · 2022-06-24T04:44:20Z

JAndrassy
Jun 24, 2022
Maintainer

you use the ArduinoOTA bundled with the esp32 core, not this ArduinoOTA library

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

OTA cannot be seen in the arduino ide #160

Uh oh!

{{title}}

Uh oh!

Replies: 1 comment

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

OTA cannot be seen in the arduino ide #160

Uh oh!

jagonzalezga Jun 23, 2022

Replies: 1 comment

Uh oh!

JAndrassy Jun 24, 2022 Maintainer

jagonzalezga
Jun 23, 2022

JAndrassy
Jun 24, 2022
Maintainer