Integrating MQTT-based sketch into OTA sketch on ESP32 breaks OTA

danielmc1 · March 27, 2024, 7:43pm

Hi,

Recently I moved a sketch that once ran on an Arduino Nano to an ESP32 and modified the sketch to use MQTT instead of receiving DCC commands over a wired model railway DCC bus - this then fires off I2C data to another completely separate device that moves multiple turnouts via servos. All went very smoothly considering this was the first time I'd tried programming and using an ESP32. The arduino IDE made this very easy.

As i continue to tweak the code, the location of the ESP32 makes it very akward to access for USB updates, but have discovered the OTA code that allows me to update the sketch over the network via a browser. The example OTA code I found online (looks very similar to the example in the IDE) works perfectly after entering my own wifi credetials. All I had to do was add my own code to the example code, but this is where it falls over...

Now when I enter the ip address into a browser, it is unable to load the page.

I've tried commenting out some lines that look like duplicates in lines from each sketch, but the only thing that restores access to the web page is commenting out the calling of the mqttconnect() function and also the reconnect functions.

Is there something obvious preventing this from working, or am I simply not able to use OTA, MQTT, webserver, wifi and I2C libraries all at the same time...?

Also in line 64, there is a reference to a web address in the OTA code - my intended network will not have internet access - is this going to cause a problem...?

Many thanks in advance for any pointers.

Daniel

#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>
#include <Update.h>

const char* host = "ESP32-TurnoutBoard-B";
const char* ssid = "XXXXX";
const char* password = "XXXXXX";


WebServer server(80);

/*
 * Login page
 */

const char* loginIndex =
  "<form name='loginForm'>"
  "<table width='20%' bgcolor='A09F9F' align='center'>"
  "<tr>"
  "<td colspan=2>"
  "<center><font size=4><b>ESP32 Login Page</b></font></center>"
  "<br>"
  "</td>"
  "<br>"
  "<br>"
  "</tr>"
  "<td>Username:</td>"
  "<td><input type='text' size=25 name='userid'><br></td>"
  "</tr>"
  "<br>"
  "<br>"
  "<tr>"
  "<td>Password:</td>"
  "<td><input type='Password' size=25 name='pwd'><br></td>"
  "<br>"
  "<br>"
  "</tr>"
  "<tr>"
  "<td><input type='submit' onclick='check(this.form)' value='Login'></td>"
  "</tr>"
  "</table>"
  "</form>"
  "<script>"
  "function check(form)"
  "{"
  "if(form.userid.value=='admin' && form.pwd.value=='admin')"
  "{"
  "window.open('/serverIndex')"
  "}"
  "else"
  "{"
  " alert('Error Password or Username')/*displays error message*/"
  "}"
  "}"
  "</script>";

/*
 * Server Index Page
 */

const char* serverIndex =
  "<script src='https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>"
  "<form method='POST' action='#' enctype='multipart/form-data' id='upload_form'>"
  "<input type='file' name='update'>"
  "<input type='submit' value='Update'>"
  "</form>"
  "<div id='prg'>progress: 0%</div>"
  "<script>"
  "$('form').submit(function(e){"
  "e.preventDefault();"
  "var form = $('#upload_form')[0];"
  "var data = new FormData(form);"
  " $.ajax({"
  "url: '/update',"
  "type: 'POST',"
  "data: data,"
  "contentType: false,"
  "processData:false,"
  "xhr: function() {"
  "var xhr = new window.XMLHttpRequest();"
  "xhr.upload.addEventListener('progress', function(evt) {"
  "if (evt.lengthComputable) {"
  "var per = evt.loaded / evt.total;"
  "$('#prg').html('progress: ' + Math.round(per*100) + '%');"
  "}"
  "}, false);"
  "return xhr;"
  "},"
  "success:function(d, s) {"
  "console.log('success!')"
  "},"
  "error: function (a, b, c) {"
  "}"
  "});"
  "});"
  "</script>";

//MQTT DECODER CODE

const int jmri_mqtt_1 = 4;
const int jmri_mqtt_2 = 5;
const int jmri_mqtt_3 = 6;
const int jmri_mqtt_4 = 7;
const int jmri_mqtt_5 = 8;
const int jmri_mqtt_6 = 9;
const int jmri_mqtt_7 = 10;
const int jmri_mqtt_8 = 103;
const int jmri_mqtt_9 = 104;
const int jmri_mqtt_10 = 105;
const int jmri_mqtt_11 = 106;
const int jmri_mqtt_12 = 201;


// MQTT STUFF
#if defined(ESP8266)
#include <ESP8266WiFi.h>
#else
#include <WiFi.h>
#endif
#if defined(ESP8266)
#include <ESP8266WebServer.h>
#else
#include <WebServer.h>
#endif

#include <PubSubClient.h>

const char* mqtt_server = "192.168.0.101";  //mqtt server
//const char* ssid = "TSR";
//const char* password = "573bde3e5e";

//WiFiClient esp_BoardB;
WiFiClient ESP32_TurnoutBoard_B;
//PubSubClient client(esp_BoardB);  //lib required for mqtt
PubSubClient client(ESP32_TurnoutBoard_B);  //lib required for mqtt


//int LED = 02;



// MEGAPOINTS STUFF
#define NUMACCESSORIES 12            // Enter the number of accessories here
const byte ServoControllerAddr = 2;  // Set the servo controller address

#include <Wire.h>


byte commandbyteone;
byte maskbyteone;
byte commandbytetwo;
byte maskbytetwo;

int byteonecurrentvalue = 0;
int bytetwocurrentvalue = 0;

long previousMillis = 0;
long interval = 200;

int ledpin = 2;

/*
 * setup function
 */
void setup(void) {
  //pinMode(led, OUTPUT);

  Serial.begin(115200);

  // Connect to WiFi network
  WiFi.begin(ssid, password);
  Serial.println("");

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  /*use mdns for host name resolution*/
  if (!MDNS.begin(host)) {  //http://esp32.local
    Serial.println("Error setting up MDNS responder!");
    while (1) {
      delay(1000);
    }
  }
  Serial.println("mDNS responder started");
  /*return index page which is stored in serverIndex */
  server.on("/", HTTP_GET, []() {
    server.sendHeader("Connection", "close");
    server.send(200, "text/html", loginIndex);
  });
  server.on("/serverIndex", HTTP_GET, []() {
    server.sendHeader("Connection", "close");
    server.send(200, "text/html", serverIndex);
  });
  /*handling uploading firmware file */
  server.on(
    "/update", HTTP_POST, []() {
      server.sendHeader("Connection", "close");
      server.send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");
      ESP.restart();
    },
    []() {
      HTTPUpload& upload = server.upload();
      if (upload.status == UPLOAD_FILE_START) {
        Serial.printf("Update: %s\n", upload.filename.c_str());
        if (!Update.begin(UPDATE_SIZE_UNKNOWN)) {  //start with max available size
          Update.printError(Serial);
        }
      } else if (upload.status == UPLOAD_FILE_WRITE) {
        /* flashing firmware to ESP*/
        if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
          Update.printError(Serial);
        }
      } else if (upload.status == UPLOAD_FILE_END) {
        if (Update.end(true)) {  //true to set the size to the current progress
          Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);
        } else {
          Update.printError(Serial);
        }
      }
    });
  server.begin();


  //MQTT STUFF

  //Serial.begin(115200);
  pinMode(LED, OUTPUT);
  digitalWrite(LED, LOW);
  //WiFi.begin(ssid, password);
  Serial.println("connected");

  client.setServer(mqtt_server, 1883);  //connecting to mqtt server
  client.setCallback(callback);
  //delay(5000);

  connectmqtt();

  // MEGAPOINTS STUFF
  //Serial.begin(115200);
  Wire.begin();
}


void callback(char* topic, byte* payload, unsigned int length) {
  // check the incoming message for closed or thrown
  // we only subscribed to turnout messages, so it should be one or the other

  //print the topic
  Serial.print("Message arrived [" + String(topic) + "] ");
  //Serial.print(topic); Not sure if this will work - untested

  // terminate the byte array
  payload[length] = 0;
  //save and print the payload to a string called msg
  String msg = String((char*)payload);
  Serial.println(msg);

  //create a char* (no idea what the * is by the way) to save the turnout number when converted from the String in a little while.
  char* turnoutNumChar;
  //Create an int to save the turnout number in, in proper integer format
  int turnoutNum;
  // Create a boolean variable to save the requested turnout state to in either 0 or 1. This will be converted from the byte payload in a little while.
  boolean turnoutState;

  //Determin whether the topic contains the work 'turnout' somewhere in it.
  if (String(topic).indexOf("turnout") >= 0) {
    Serial.println("The word TURNOUT has been found in the received topic.");
    //extract turnout number here from the location in the topic string the turnout number always starts from and copy to the turnout char 'turnoutNumChar'
    turnoutNumChar = &(topic[14]);
    Serial.print("char turnoutNumChar = ");
    Serial.println(turnoutNumChar);
    //Turn the the turnout number, currently in char format to a proper int format and save it in the turnoutNum variable.
    turnoutNum = atoi(turnoutNumChar);
    Serial.print("int turnoutNum = ");
    Serial.println(turnoutNum);
    //save thrown/closed state as boolean here
    if (msg == "CLOSED") {
      turnoutState = 0;
      Serial.println("Turnout state set to CLOSED");
    } else if (msg == "THROWN") {
      turnoutState = 1;
      Serial.println("Turnout state set to THROWN");
    }
  }

  //call functions here and send turnoutstate as argument

  //MEGAPOINTS CHANNEL 1 of 12
  if (turnoutNum == jmri_mqtt_1) {
    Mega_ch_1(turnoutState);
  }
  //MEGAPOINTS CHANNEL 2 of 12
  if (turnoutNum == jmri_mqtt_2) {
    Mega_ch_2(turnoutState);
  }

  //MEGAPOINTS CHANNEL 3 of 12
  if (turnoutNum == jmri_mqtt_3) {
    Mega_ch_3(turnoutState);
  }

  //MEGAPOINTS CHANNEL 4 of 12
  if (turnoutNum == jmri_mqtt_4) {
    Mega_ch_4(turnoutState);
  }

  //MEGAPOINTS CHANNEL 5 of 12
  if (turnoutNum == jmri_mqtt_5) {
    Mega_ch_5(turnoutState);
  }

  //MEGAPOINTS CHANNEL 6 of 12
  if (turnoutNum == jmri_mqtt_6) {
    Mega_ch_6(turnoutState);
  }

  //MEGAPOINTS CHANNEL 7 of 12
  if (turnoutNum == jmri_mqtt_7) {
    Mega_ch_7(turnoutState);
  }

  //MEGAPOINTS CHANNEL 8 of 12
  if (turnoutNum == jmri_mqtt_8) {
    Mega_ch_8(turnoutState);
  }

  //MEGAPOINTS CHANNEL 9 of 12
  if (turnoutNum == jmri_mqtt_9) {
    Mega_ch_9(turnoutState);
  }

  //MEGAPOINTS CHANNEL 10 of 12
  if (turnoutNum == jmri_mqtt_10) {
    Mega_ch_10(turnoutState);
  }

  //MEGAPOINTS CHANNEL 11 of 12
  if (turnoutNum == jmri_mqtt_11) {
    Mega_ch_11(turnoutState);
  }

  //MEGAPOINTS CHANNEL 12 of 12
  if (turnoutNum == jmri_mqtt_12) {
    Mega_ch_12(turnoutState);
  }
}



void reconnect() {

  while (!client.connected()) {
    Serial.println("Attempting MQTT connection...");
    WiFi.begin(ssid, password);
    delay(4000);
    if (client.connect("ESP32-TurnoutBoard-B")) {
      Serial.println("connected");
      // Once connected, publish an announcement...
      client.publish("ESP32-TurnoutBoard-B/status", "connected", true);
      // ... and resubscribe
      client.subscribe("track/turnout/#");

    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      client.publish("ESP32-TurnoutBoard-B/status", "disconnected", true);
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void loop(void) {
  server.handleClient();

  // put your main code here, to run repeatedly:
  if (!client.connected()) {
    reconnect();
  }

  client.loop();
}


// MORE MQTT STUFF
void connectmqtt() {
  WiFi.begin(ssid, password);
  delay(4000);
  client.connect("ESP32-TurnoutBoard-B");  // ESP will connect to mqtt broker with clientID
  {
    Serial.println("connected to MQTT");
    // Once connected, publish an announcement...

    // ... and resubscribe
    client.subscribe("track/turnout/#");  //topic=Demo
    client.publish("ESP32-TurnoutBoard-B/status", "connected", true);

    if (!client.connected()) {
      reconnect();
    }
  }
}

void Mega_ch_1(boolean turnoutState) {
  if (turnoutState == 1) {

    maskbyteone = 1;
    commandbyteone = 1;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    //Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 1 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 1;
    commandbyteone = 0;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 1 CLOSED");
  }
}


void Mega_ch_2(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 2;
    commandbyteone = 2;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    //Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 2 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 2;
    commandbyteone = 0;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 2 CLOSED");
  }
}

void Mega_ch_3(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 4;
    commandbyteone = 4;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    //Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 3 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 4;
    commandbyteone = 0;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 3 CLOSED");
  }
}

void Mega_ch_4(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 8;
    commandbyteone = 8;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    //Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 4 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 8;
    commandbyteone = 0;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 4 CLOSED");
  }
}

void Mega_ch_5(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 16;
    commandbyteone = 16;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    //Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 5 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 16;
    commandbyteone = 0;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 5 CLOSED");
  }
}

void Mega_ch_6(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 32;
    commandbyteone = 32;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    //Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 6 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 32;
    commandbyteone = 0;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 6 CLOSED");
  }
}

void Mega_ch_7(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 64;
    commandbyteone = 64;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    //Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 7 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 64;
    commandbyteone = 0;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 7 CLOSED");
  }
}

void Mega_ch_8(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 128;
    commandbyteone = 128;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    //Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 8 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 128;
    commandbyteone = 0;
    maskbytetwo = 0;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 8 CLOSED");
  }
}

void Mega_ch_9(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 0;
    commandbyteone = 0;
    maskbytetwo = 1;
    commandbytetwo = 1;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 9 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 0;
    commandbyteone = 0;
    maskbytetwo = 1;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 9 CLOSED");
  }
}

void Mega_ch_10(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 0;
    commandbyteone = 0;
    maskbytetwo = 2;
    commandbytetwo = 2;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 10 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 0;
    commandbyteone = 0;
    maskbytetwo = 2;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 10 CLOSED");
  }
}

void Mega_ch_11(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 0;
    commandbyteone = 0;
    maskbytetwo = 4;
    commandbytetwo = 4;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 11 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 0;
    commandbyteone = 0;
    maskbytetwo = 4;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 11 CLOSED");
  }
}

void Mega_ch_12(boolean turnoutState) {
  if (turnoutState == 1) {
    maskbyteone = 0;
    commandbyteone = 0;
    maskbytetwo = 8;
    commandbytetwo = 8;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 12 THROWN");

  } else if (turnoutState == 0) {
    maskbyteone = 0;
    commandbyteone = 0;
    maskbytetwo = 8;
    commandbytetwo = 0;



    Wire.beginTransmission(ServoControllerAddr);
    Wire.write((byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone));
    Wire.write((bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo));
    Wire.endTransmission();
    byteonecurrentvalue = (byteonecurrentvalue & ~maskbyteone) | (commandbyteone & maskbyteone);
    bytetwocurrentvalue = (bytetwocurrentvalue & ~maskbytetwo) | (commandbytetwo & maskbytetwo);

    Serial.println("Megapoints Channel 12 CLOSED");
  }
}

system · September 23, 2024, 7:43pm

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

Topic		Replies	Views
EspMQTTClient Update OTA Fail Networking, Protocols, and Devices	8	442	July 23, 2023
Next stupid problem connecting to IOT Cloud Cloud IoT	41	412	November 11, 2025
Is it possible to do OTA update for the ESP32 using Arduino IDE 2.0.x via Ethernet instead of WiFi? Uploading	48	4790	February 29, 2024
ESP32 All in One WiFi / BLE / OTA / MQTT / WebSerial Programming	13	414	June 8, 2025
Replacement for IFTTT for mailbox notifier General Guidance	24	276	August 17, 2025

Integrating MQTT-based sketch into OTA sketch on ESP32 breaks OTA

Related topics