I2c crashes when controlling relay

[harsh267]

Hardware:

Board: ESP32 Dev Module wroom
IDE name: Arduino IDE?
Flash Frequency: 40Mh
PSRAM enabled: no
Upload Speed: 115200
Computer OS: Windows 10

Description:

Hi I have Bme280 ,Bh170 and rtc connected to my I2c on esp32 .
I also have 4 channel 5v coil relay connected using uln2003.
The code works perfect . When i turn on/off the relay at high frequency or occasionally the i2c sensors start sending garbage values BH170 will send zero and BMe 280 humidity will go to 100% . Analog sensors will keep on sending data and relays will keep on responding and occasionally while flipping the relays on/off the I2c might recover and start sending proper data.
Do not understand why it is happening . Trying to put mosfet irfz44n to reset the i2c.

Sketch:

#include <MQ135.h>

/*
@ harshit --> AIR-GROW
*/
#include <FS.h>
#include <PubSubClient.h>
#if defined(ESP8266)
#include <ESP8266WiFi.h>
#else
#include <WiFi.h>
#include <SPIFFS.h>
#endif
#include <DNSServer.h>
#if defined(ESP8266)
#include <ESP8266WebServer.h>
#else
#include <WebServer.h>
#endif

#include <WiFiManager.h>
#include <ArduinoJson.h>
#include <BH1750.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

#include <WiFiClient.h>
#include <ESPmDNS.h>
#include <Update.h>
//#include <SparkFunCCS811.h>
#include <ArduinoOTA.h>
#include <EEPROM.h>

BH1750 lightMeter;
WiFiClient wifiClient;
PubSubClient client(wifiClient);
WebServer server(81);//81 port handles OTA

char mqtt_server[] = "159.89.168.123";
//char mqtt_server[40] = "demo.thingsboard.io";
char mqtt_port[6] = "1883";
char token[33] = "harshit1";
const char* host = "airgrow"; //for OTA airgrow.local:81
/////////////////////////////////////////////////////////////////

/// The load resistance on the board
#define RLOAD 10.0
/// Calibration resistance at atmospheric CO2 level
#define RZERO 76.63
/// Parameters for calculating ppm of CO2 from sensor resistance
#define PARA 116.6020682
#define PARB 2.769034857

/// Parameters to model temperature and humidity dependence
#define CORA 0.00035
#define CORB 0.02718
#define CORC 1.39538
#define CORD 0.0018

/// Atmospheric CO2 level for calibration purposes
#define ATMOCO2 397.13

/*
@HARSHIT -> Relay pin
*/
#define GPIO18 18
#define GPIO19 19
#define GPIO23 23
#define GPIO05 05

// We assume that all GPIOs are LOW
boolean gpioState[] = {false, false, false, false};
// Timer execution flag
bool set_action = false;
// Timer handler
hw_timer_t * timer = NULL;

unsigned long noWifi = 0;
unsigned long noServer = 0;
int i2cError = 0;

int gpioPins[] = { 18, 19, 23, 5 };
/*
@HARSHIT -->touch pins
*/
int threshold = 40;

bool touch0detected = false;
bool touch3detected = false;
bool touch4detected = false;
bool touch5detected = false;

void gotTouch0() {
touch0detected = true;
}

void gotTouch3() {
touch3detected = true;
}

void gotTouch4() {
touch4detected = true;
}

void gotTouch5() {
touch5detected = true;
}

int i2cPower = 34;
//////////////////////////////////////////////////////////////
/*
@HARSHIT -->proximity sensor
/
int sensor = 16;
int relayInput = 39;
int val = 0; //to store sensor status
int state = LOW; //by default no motion detected
////////////////////////////////////////////////////////
/
@HARSHIT -->water temperature
/
#define ONE_WIRE_BUS 17
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
float tempC = 0.0;
/////////////////////////////////////////////////////////
/
@HARSHIT -->ultraSonic
*/
const int trigPin = 27;
const int echoPin = 26;
long duration;
int distance;

bool setRelay = false;
int relay1Address = 4;
int relay2Address = 5;
int relay3Address = 6;
/////////////////////////////////////////////////////////
/*
@HARSHIT -->BME280
/
#define I2C_SDA 21
#define I2C_SCL 22
#define SEALEVELPRESSURE_HPA (1013.25)
#define BME280_ADD 0x76
#define co2Zero 55
Adafruit_BME280 bme; // I2C
/////////////////////////////////////////////////////////
/
@HARSHIT -->CCS0811
*/

#define CCS811_ADDR 0x5A //Default I2C Address
//CCS811 myCCS811(CCS811_ADDR);
MQ135 mq135_sensor = MQ135(35);
/////////////////////////////////////////////////////////
unsigned long lastSend;
String temperature = "10", humidity = "10", altitude = "10", pressure = "10", light = "10", co = "10", ppm = "10", touch0, touch3, touch4, touch5, pir;

//flag for saving data
bool shouldSaveConfig = false;

/*
@HARSHIT
/
//callback notifying us of the need to save config
void saveConfigCallback () {
Serial.println("Should save config");
shouldSaveConfig = true;
}
/
@HARSHIT OTA-UI
*/

const char* loginIndex = "

"
""
""
"

Air-Grow Login Page" " " "</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=='airgrow' && form.pwd.value=='Admin1234')" "{" "window.open('/serverIndex')" "}" "else" "{" " alert('Error Password or Username')/*displays error message*/" "}" "}" "</script>"; const char* serverIndex = "<script src='https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>" "" "" "" "" " progress: 0% " "<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>"; ////////////////////////////////////////////////////////// /* @HARSHIT / void setup() { // put your setup code here, to run once: pinMode(i2cPower, OUTPUT); digitalWrite(i2cPower, HIGH); Serial.begin(115200); Serial.println(); // mq135_sensor = MQ135(35); / harshit -> Relay make GPIO OUT */ pinMode(GPIO18, OUTPUT); pinMode(GPIO19, OUTPUT); pinMode(GPIO23, OUTPUT); pinMode(GPIO05, OUTPUT); digitalWrite(GPIO18, HIGH); digitalWrite(GPIO19, HIGH); digitalWrite(GPIO23, HIGH); digitalWrite(GPIO05, HIGH); if (!EEPROM.begin(64)) { Serial.println("EEPROM ERROR"); delay(3000); ESP.restart(); } bool r1State = (int)EEPROM.read(relay1Address) == 1 ? true : false; bool r2State = (int)EEPROM.read(relay2Address) == 1 ? true : false; bool r3State = (int)EEPROM.read(relay3Address) == 1 ? true : false; Serial.println("relay1: " + String(r1State) + ", relay2: " + String(r2State) + ", relay3: " + String(r3State)); set_gpio_status(gpioPins[0], r1State, 0); set_gpio_status(gpioPins[2], r2State, 0); set_gpio_status(gpioPins[3], r3State, 0); /* @HARSHIT BH1750 */ Wire.begin(); // lightMeter.begin(); /* touch pins */ touchAttachInterrupt(T0, gotTouch0, threshold); touchAttachInterrupt(T3, gotTouch3, threshold); touchAttachInterrupt(T4, gotTouch4, threshold); touchAttachInterrupt(T5, gotTouch5, threshold); /* @HARSHIT pinmode and relayinput for proximity sensors */ pinMode(sensor, INPUT); pinMode(relayInput, OUTPUT); ////////////////////////////////////////////////////////// /* @HARSHIT water temp */ sensors.begin(); // locate devices on the bus Serial.print("Locating devices..."); Serial.print("Found "); Serial.print(sensors.getDeviceCount(), DEC); Serial.println(" devices."); // report parasite power requirements Serial.print("Parasite power is: "); if (sensors.isParasitePowerMode()) { Serial.println("ON"); } else { Serial.println("OFF"); } /////////////////////////////////////////////////////////// /* @HARSHIT ultraonic / pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output pinMode(echoPin, INPUT); // Sets the echoPin as an Input ////////////////////////////////////////////////////////////// / @HARSHIT BME280 / // bool status; // // // default settings // // (you can also pass in a Wire library object like &Wire2) int status = bme.begin(BME280_ADD); if (!status) { Serial.println("Could not find a valid BME280 sensor, check wiring!"); while (1); delay(100); } ///////////////////////////////////////////////////////////////////// / @HARSHIT CCS0811 */ // CCS811Core::status returnCode = myCCS811.begin(); // Serial.print("begin exited with: "); // printDriverError( returnCode ); // Serial.println(); ///////////////////////////////////////////////////////////////////// //clean FS, for testing // SPIFFS.format(); //read configuration from FS json Serial.println("mounting FS..."); if (SPIFFS.begin()) { Serial.println("mounted file system"); if (SPIFFS.exists("/config.json")) { //file exists, reading and loading Serial.println("reading config file"); File configFile = SPIFFS.open("/config.json", "r"); if (configFile) { Serial.println("opened config file"); size_t size = configFile.size(); // Allocate a buffer to store contents of the file. std::unique_ptr<char[]> buf(new char[size]); configFile.readBytes(buf.get(), size); DynamicJsonBuffer jsonBuffer; JsonObject& json = jsonBuffer.parseObject(buf.get()); json.printTo(Serial); if (json.success()) { Serial.println("\nparsed json"); strcpy(mqtt_server, json["mqtt_server"]); strcpy(mqtt_port, json["mqtt_port"]); strcpy(token, json["token"]); } else { Serial.println("failed to load json config"); } } } } else { Serial.println("failed to mount FS"); } //end read Serial.println(token); Serial.println(mqtt_server); WiFiManagerParameter custom_mqtt_server("server", "mqtt server", mqtt_server, 40); WiFiManagerParameter custom_mqtt_port("port", "mqtt port", mqtt_port, 5); WiFiManagerParameter custom_token("token", "token", token, 34); WiFiManager wifiManager; wifiManager.setSaveConfigCallback(saveConfigCallback); //add all your parameters here wifiManager.addParameter(&custom_mqtt_server); wifiManager.addParameter(&custom_mqtt_port); wifiManager.addParameter(&custom_token); wifiManager.setMinimumSignalQuality(); if (!wifiManager.autoConnect("AIR_GROW_v1")) { //version maintaince of FIRMWARE Serial.println("failed to connect and hit timeout"); delay(3000); //reset and try again, or maybe put it to deep sleep ESP.restart(); delay(5000); } //if you get here you have connected to the WiFi Serial.println("connected to wifi"); //read updated parameters strcpy(mqtt_server, custom_mqtt_server.getValue()); strcpy(mqtt_port, custom_mqtt_port.getValue()); strcpy(token, custom_token.getValue()); //save the custom parameters to FS if (shouldSaveConfig) { Serial.println("saving config"); DynamicJsonBuffer jsonBuffer; JsonObject& json = jsonBuffer.createObject(); json["mqtt_server"] = mqtt_server; json["mqtt_port"] = mqtt_port; json["token"] = token; File configFile = SPIFFS.open("/config.json", "w"); if (!configFile) { Serial.println("failed to open config file for writing"); } json.prettyPrintTo(Serial); json.printTo(configFile); configFile.close(); //end save } Serial.println("local ip"); Serial.println(WiFi.localIP()); Serial.println(WiFi.gatewayIP()); Serial.println(WiFi.subnetMask()); ArduinoOTA.setHostname("myesp32"); // No authentication by default ArduinoOTA.setPassword("admin"); /* Zero Config routing protocol, need bonjour services for IP to HOSTNAME mapping */ /use mdns for host name resolution/ if (!MDNS.begin(host)) { 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(); Serial.println("OTA Updates ready at 81 port"); //////////////////////////////////////////////////////////////////////////////// /* @HARSHIT mqtt connectivity / client.setServer(mqtt_server, 1883); / harshit -> Relay regisster MQTT callback */ client.setCallback(on_message); client.connect("ID", token , NULL); if (client.connected()) { Serial.println("connected to mqtt"); /* harshit : Relay stuff subscribe topic to get GPIO event */ // Subscribing to receive RPC requests client.subscribe("v1/devices/me/rpc/request/+"); // Starting timer interrupt StartTimer(); } lastSend = 0; } /* harshit: Timer interrupt start */ void StartTimer(void) { timer = timerBegin(0, 80, true); timerAttachInterrupt(timer, &fnTimerSensorData, true); timerAlarmWrite(timer, 5000000, true); timerAlarmEnable(timer); Serial.println("Timer started"); } /* harshit: Timer interrupt stop */ void StopTimer(void) { timerDetachInterrupt(timer); timerStop(timer); timerAlarmDisable(timer); timerEnd(timer); timer = NULL; Serial.println("Timer stopped"); } void reconnect() { while (!client.connected()) { Serial.println("Attempting MQTT connection..."); if (noServer == 0) { noServer = millis(); } else if (millis() - noServer >= 120000) { ESP.restart(); } client.connect("ID", token, NULL); if ( client.connected ()) { Serial.println("connected"); } else { Serial.print("failed, rc="); Serial.print(client.state()); Serial.println(" try again in 2seconds"); // Wait 5 seconds before retrying delay(2000); } } } /* harshit -> Relay MQTT message callback / // The callback for when a PUBLISH message is received from the server. void on_message(char topic, uint8_t* payload, unsigned int length) { // Stop the timer StopTimer(); Serial.println("On message"); char json[length + 1]; strncpy (json, (char*)payload, length); json[length] = '\0'; Serial.print("Topic: "); Serial.println(topic); Serial.print("Message: "); Serial.println(json); // Decode JSON request StaticJsonBuffer<200> jsonBuffer; JsonObject& data = jsonBuffer.parseObject((char*)json); if (!data.success()) { Serial.println("parseObject() failed"); return; } // Check request method String methodName = String((const char*)data["method"]); if (methodName.equals("getGpioStatus")) { // Reply with GPIO status String responseTopic = String(topic); responseTopic.replace("request", "response"); client.publish(responseTopic.c_str(), get_gpio_status().c_str()); } else if (methodName.equals("setGpioStatus")) { // Update GPIO status and reply set_gpio_status(data["params"]["pin"], data["params"]["enabled"], 1); String responseTopic = String(topic); responseTopic.replace("request", "response"); client.publish(responseTopic.c_str(), get_gpio_status().c_str()); client.publish("v1/devices/me/attributes", get_gpio_status().c_str()); } // Start the timer StartTimer(); } /* harshit: Get gpio status */ String get_gpio_status() { // Prepare gpios JSON payload string StaticJsonBuffer<200> jsonBuffer; JsonObject& data = jsonBuffer.createObject(); data[String(GPIO19)] = gpioState[0] ? true : false; data[String(GPIO18)] = gpioState[1] ? true : false; data[String(GPIO23)] = gpioState[2] ? true : false; data[String(GPIO05)] = gpioState[3] ? true : false; char payload[256]; data.printTo(payload, sizeof(payload)); String strPayload = String(payload); Serial.print("Get gpio status: "); Serial.println(strPayload); return strPayload; } /* harshit: Set gpio status */ void set_gpio_status(int pin, boolean enabled, int flag) { if (pin == GPIO18) { // Output GPIOs state digitalWrite(GPIO18, enabled ? LOW : HIGH); // EEPROM.write(relay1Address, enabled ? 1:0); // Update GPIOs state gpioState[1] = enabled; } else if (pin == GPIO19) { // Output GPIOs state digitalWrite(GPIO19, enabled ? LOW : HIGH); // EEPROM.write(relay1Address, enabled ? 1:0); // Update GPIOs state gpioState[0] = enabled; } else if (pin == GPIO23) { // Output GPIOs state digitalWrite(GPIO23, enabled ? LOW : HIGH); // EEPROM.write(relay2Address, enabled ? 1:0); // Update GPIOs state gpioState[2] = enabled; } else if (pin == GPIO05) { // Output GPIOs state digitalWrite(GPIO05, enabled ? LOW : HIGH); // EEPROM.write(relay3Address, enabled ? 1:0); // Update GPIOs state gpioState[3] = enabled; } if (flag == 1) { setRelay = true; //pointer2 } // EEPROM.commit(); } //void set_gpio_status(int pin, boolean enabled) { // if (pin == GPIO18) { // // Output GPIOs state // digitalWrite(GPIO18, enabled ? LOW : HIGH); // // Update GPIOs state // gpioState[1] = enabled; // } // else if (pin == GPIO19) { // // Output GPIOs state // digitalWrite(GPIO19, enabled ? LOW : HIGH); // // Update GPIOs state // gpioState[0] = enabled; // } // else if (pin == GPIO23) { // // Output GPIOs state // digitalWrite(GPIO23, enabled ? LOW : HIGH); // // Update GPIOs state // gpioState[2] = enabled; // } else if (pin == GPIO05) { // // Output GPIOs state // digitalWrite(GPIO05, enabled ? LOW : HIGH); // // Update GPIOs state // gpioState[3] = enabled; // } //} void loop() { server.handleClient(); if (WiFi.status() != WL_CONNECTED) { if (noWifi == 0) { noWifi = millis(); } else { if (millis() - noWifi >= 120000) { ESP.restart(); } } } else { noWifi = 0; } if (setRelay) { Serial.println("WRITING TO EEPROM "); EEPROM.write(relay1Address, gpioState[0] == true ? 1 : 0); EEPROM.write(relay2Address, gpioState[2] == true ? 1 : 0); EEPROM.write(relay3Address, gpioState[3] == true ? 1 : 0); EEPROM.commit(); setRelay = false; Serial.println("1: " + String(EEPROM.read(relay1Address)) + ", 2: " + String(EEPROM.read(relay2Address)) + ", 3: " + String(EEPROM.read(relay3Address))); } if (!client.connected()) { reconnect(); client.subscribe("v1/devices/me/rpc/request/+"); } else { noServer = 0; } client.loop(); ////////////////////////////////////////////////////////////////////////////////// /* @HARSHIT --> touch pins */ if (set_action == true) { touch0 = touchRead(T0); if (touch0detected) { touch0detected = false; Serial.println("Touch 0 detected"); } touch3 = touchRead(T3); if (touch3detected) { touch3detected = false; Serial.println("Touch 3 detected"); } touch4 = touchRead(T4); if (touch4detected) { touch4detected = false; Serial.println("Touch 4 detected"); } touch5 = touchRead(T5); if (touch5detected) { touch5detected = false; Serial.println("Touch 5 detected"); } ////////////////////////////////////////////////////////////////////////////////// /* pir sensor */ val = digitalRead(sensor); // read sensor value if (val == HIGH) { // check if the sensor is HIGH pir = "1"; digitalWrite(relayInput, HIGH); // turn relay ON delay(100); // delay 100 milliseconds if (state == LOW) { Serial.println("Motion detected!"); state = HIGH; // update variable state to HIGH } } else { pir = "0"; digitalWrite(relayInput, LOW); // turn relay OFF delay(200); // delay 200 milliseconds if (state == HIGH) { Serial.println("Motion stopped!"); state = LOW; // update variable state to LOW } } //////////////////////////////////////////////////////////////////////////////////////// /* water tewmperature */ Serial.print("Getting temperatures...\n\r"); Serial.print("Requesting temperatures..."); sensors.requestTemperatures(); // Send the command to get temperatures Serial.println("DONE"); // After we got the temperatures, we can print them here. // We use the function ByIndex, and as an example get the temperature from the first sensor only. Serial.print("Temperature for the thermometer "); Serial.println(sensors.getTempCByIndex(0)); tempC = sensors.getTempCByIndex(0); //////////////////////////////////////////////////////////////////////////////////////// /* ultraSonic */ // Clears the trigPin digitalWrite(trigPin, LOW); delayMicroseconds(2); // Sets the trigPin on HIGH state for 10 micro seconds digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); // Reads the echoPin, returns the sound wave travel time in microseconds duration = pulseIn(echoPin, HIGH); // Calculating the distance distance = duration * 0.034 / 2; // Prints the distance on the Serial Monitor Serial.print("Distance: "); Serial.println(distance); //////////////////////////////////////////////////////////////////////////////////////// /* @harshit bme280 */ printValues(); delay(500); ////////////////////////////////////////////////////////////////////////////////////////// /* CCS811 */ // printccsData(); delay(500); ///////////////////////////////////////////////////////////////////////////////////////// /* Light Intensity (Lux) Sensor BH1750 */ // uint16_t lux = lightMeter.readLightLevel(); uint16_t lux = 0; Serial.print("Light: "); Serial.print(lux); Serial.println(" lx"); light = lux; ////////////////////////////////////////////////////////////////////////////////////////// if (set_action == true) { SensorsValues(); delay(100); payload_data(); } set_action = false; } delay(1); } /* @HARSHIT --> printing BME280 DATA */ void printValues() { Serial.print("Temperature = "); Serial.print(bme.readTemperature()); Serial.println(" *C"); float t = bme.readTemperature(); Serial.print("Pressure = "); Serial.print(bme.readPressure() / 100.0F); Serial.println(" hPa"); float p = (bme.readPressure() / 100.0F); Serial.print("Approx. Altitude = "); Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA)); Serial.println(" m"); float a = bme.readAltitude(SEALEVELPRESSURE_HPA); Serial.print("Humidity = "); Serial.print(bme.readHumidity()); Serial.println(" %"); float h = bme.readHumidity(); if (t < 0.0 ) { i2cError++; Serial.println("i2c error " + String(i2cError)); if(i2cError == 15){ digitalWrite(i2cPower, LOW); delay(1000); digitalWrite(i2cPower, HIGH); } } else { i2cError = 0; pressure = (bme.readPressure() / 100.0F); altitude = bme.readAltitude(SEALEVELPRESSURE_HPA); temperature = bme.readTemperature(); humidity = bme.readHumidity(); } Serial.println(); } //////////////////////////////////////////////////////////////////////////////////////////////// /* CCS811 */ void printccsData() { // if (myCCS811.dataAvailable()) // { // myCCS811.readAlgorithmResults(); // printInfoSerial(); // float BMEtempC = bme.readTemperature(); // float BMEhumid = bme.readHumidity(); // myCCS811.setEnvironmentalData(BMEhumid, BMEtempC); // Serial.println("Environmental data applied!"); //delay(1000); // } // else if (myCCS811.checkForStatusError()) // { //If the CCS811 found an internal error, print it. // printSensorError(); // } } void printInfoSerial() { // getCO2() gets the previously read data from the library // Serial.println("CCS811 data:"); // Serial.print(" CO2 concentration : "); // Serial.print(myCCS811.getCO2()); // Serial.println(" ppm"); // co = myCCS811.getCO2(); // //// getTVOC() gets the previously read data from the library // Serial.print(" TVOC concentration : "); // Serial.print(myCCS811.getTVOC()); // Serial.println(" ppb"); // ppm = myCCS811.getTVOC(); } //void printDriverError( CCS811Core::status errorCode ) //{ // switch ( errorCode ) // { // case CCS811Core::SENSOR_SUCCESS: // Serial.print("SUCCESS"); // break; // case CCS811Core::SENSOR_ID_ERROR: // Serial.print("ID_ERROR"); // break; // case CCS811Core::SENSOR_I2C_ERROR: // Serial.print("I2C_ERROR"); // break; // case CCS811Core::SENSOR_INTERNAL_ERROR: // Serial.print("INTERNAL_ERROR"); // break; // case CCS811Core::SENSOR_GENERIC_ERROR: // Serial.print("GENERIC_ERROR"); // break; // default: // Serial.print("Unspecified error."); // } //} void printSensorError() { // uint8_t error = myCCS811.getErrorRegister(); // // if ( error == 0xFF ) //comm error // { // Serial.println("Failed to get ERROR_ID register."); // } // else // { // Serial.print("Error: "); // if (error & 1 << 5) Serial.print("HeaterSupply"); // if (error & 1 << 4) Serial.print("HeaterFault"); // if (error & 1 << 3) Serial.print("MaxResistance"); // if (error & 1 << 2) Serial.print("MeasModeInvalid"); // if (error & 1 << 1) Serial.print("ReadRegInvalid"); // if (error & 1 << 0) Serial.print("MsgInvalid"); // Serial.println(); // } } //////////////////////////////////////////////////////////////////////////////////////////////// /* @HARSHIT -->parsing Payload in JSON FORM */ void SensorsValues() { String payload = "{"; payload += ""WTemp":"; payload += tempC; payload += ","; payload += ""Altitude":"; payload += altitude; payload += ","; payload += ""Pressure":"; payload += pressure; payload += ","; payload += ""T0":"; payload += touch0; payload += ","; payload += ""T3":"; payload += touch3; payload += ","; payload += ""T4":"; payload += touch4; payload += ","; payload += ""T5":"; payload += touch5; payload += "}"; // Send payload char attributes[payload.length() + 1]; payload.toCharArray( attributes, payload.length() + 1); client.publish( "v1/devices/me/telemetry", attributes ); // TOPIC for MQTT "v1/devices/me/telemetry" Serial.println(" "); Serial.println(" first payload published"); Serial.println( attributes ); } void payload_data() { readCO2(); String payload1 = "{"; payload1 += ""light":"; payload1 += light; payload1 += ","; payload1 += ""CO2":"; payload1 += co; payload1 += ","; payload1 += ""TVOC":"; payload1 += ppm; payload1 += ","; payload1 += ""temperature":"; payload1 += temperature; payload1 += ","; payload1 += ""Humidity":"; payload1 += humidity; payload1 += ","; payload1 += ""PIR":"; payload1 += pir; payload1 += ","; payload1 += ""Distance":"; payload1 += distance; payload1 += "}"; char attributes1[payload1.length() + 1]; payload1.toCharArray( attributes1, payload1.length() + 1 ); client.publish( "v1/devices/me/telemetry", attributes1 ); // TOPIC for MQTT "v1/devices/me/telemetry" Serial.println(" "); Serial.println(" second payload published "); Serial.println( attributes1 ); } void readCO2() { // float rzero = mq135_sensor.getRZero(); // float correctedRZero = mq135_sensor.getCorrectedRZero(temperature.toFloat(), humidity.toFloat()); // float resistance = mq135_sensor.getResistance(); // float ppm = mq135_sensor.getPPM(); // float correctedPPM = mq135_sensor.getCorrectedPPM(temperature.toFloat(), humidity.toFloat()); // Serial.print("MQ135 RZero: "); // Serial.print(rzero); // Serial.print("\t Corrected RZero: "); // Serial.print(correctedRZero); // Serial.print("\t Resistance: "); // Serial.print(resistance); // Serial.print("\t PPM: "); // Serial.print(ppm); // Serial.print("\t Corrected PPM: "); // Serial.print(correctedPPM); // Serial.print("ppm @ temp/hum: "); // Serial.print(temperature); // Serial.print("/"); // Serial.print(humidity); // Serial.println("%"); // co = String(correctedPPM); // Serial.println(co); int co2now[10]; //int array for co2 readings int co2raw = 0; //int for raw value of co2 int co2comp = 0; //int for compensated co2 int co2ppm = 0; //int for calculated ppm int zzz = 0; //int for averaging int grafX = 0; //int for x value of graph // display.clearDisplay(); //clear display @ beginning of each loop for (int x = 0; x < 10; x++) { //samplpe co2 10x over 2 seconds co2now[x] = analogRead(35); delay(10); } for (int x = 0; x < 10; x++) { //add samples together zzz = zzz + co2now[x]; } co2raw = zzz / 10; //divide samples by 10 co2comp = (co2raw - co2Zero); //get compensated value if ( co2comp > 1024) { Serial.println("Co2 jumping"); } else { Serial.println("CO 2 comp " + String(co2comp)); co2ppm = map(co2comp, 0, 1023, 498, 9000); co = String(co2ppm * 10); } } /* harshit: Timer interrupt function */ void fnTimerSensorData() { set_action = true; } //c //bme on

[stickbreaker]

edit your issue to make it more readable:

• add three back ticks ```c++ on a separate line before your code,
• add three back ticks ``` on a separate line after your code.

Relays are really hard on the electrical environment of a microprocessor, you are seeing an EMP event. You need to filter the power line between your relay driver and the esp32. Add some big caps to your 5v rail probably 470uf to 1000uf, perhaps an inductor between 5V and the ULN2003
.
Software wise, with the current V1.0.1Rc2 you can use Wire.begin() to recycle the i2c bus if it is hung. If one of the slave i2c devices are locked up you will have to powercycle them or use their built in hardware reset features if they have them.

// if i2c error detected try
if( ! Wire.begin() ) { // failed to recycle i2c bus with existing parameters.
  Serial.printf(" i2c bus recycle failed error =%d(%s)\n",Wire.lastError(),Wire.getErrorText(Wire.lastError()));
}

Chuck.

[TopiRinkinen]

One often needed component is a diode from relay pin to GND/VCC.

If the relay has one pin fixed on GND and the other pin is driven by ULN2003, then you need diode from non-GND pin to GND ( GND ->|- ULN2003, "->|-" is diode).

If the relay has one pin fixed on VCC, the diode is from relay GND pin to VCC (ULN2003 ->|- VCC), and the datasheet of ULN2003 reveals that the diode is already there. And a several µF capacitor between ULN2003.COM and GND.

Or transient suppressor diode (TVS, TRANSZORB) between relay coil pins (correct polarity or bipolar TVS, and correct voltage of TVS).

[stickbreaker]

closed due to inactivity.