esp32 tank sensor gauge using esp-now

esp32 tank sensor gauge using esp-now on a boat.

The project is to create a “touchless” tank level gauge. “Touchless in this case means a sensor does not need ot go inside the tank. While it is for my own boat, the idea is it will be easy to install and use and potentially a product could be made from it. It should work for water tanks, fuel tanks and even blackwater tanks as long as they are not metal tanks. The basic functionality is to have five “sensors”, aluminum tape that will show full, 3/4, 1/2, 1/4 and empty. Maybe on empty all the LEDs flash and a buzzer sounds. So far it works experimentally but not in the tank yet. It should be able to be readily expanded to 2, 3, 4 or more tanks for just the price of another ESP32 dev kit, under $5.

UPDATE February 2022 – Still a ways to go, but It will be made as a product that can test up to 3 tanks (maybe 5). The sensors will just be aluminum tape and each tank will have an esp32 which will only need 12 volts, no other wires. If it is hard to get 12 volts to it, then it could be run off of a 6 volt battery pack, could be rechargeable, if let’s say it is not easy to get 12 volts to the tank in the bow. The LED display and “control” unit will go in a convenient visible place and, again, will just need a “hot” and a “ground” wire carrying 12 volts. Or again, a battery back if it is difficult to provide boat power. All units will be polarity protected and will run on 6 or 12 volts. Boat power, 4 AA batteries or a LiOn pack.

A high percentage of this code probably came from someone else. I do not know how to write code, but I can sometimes paste things together that work. Even if the code shown here did not come from one of the sources below, I most likely learned how to make it work with help from them. My apologies to anyone I missed. Please make use of anything you see here, but do not count on good coding practice as I have just done what was needed to make it work. But it does work, unless otherwise noted. Thanks to everyone who has shared their knowledge and good luck to those who are learning. https://www.jarutex.com/index.php/2021/12/19/8868/ https://www.arduino.cc/ https://www.sparkfun.com/ https://randomnerdtutorials.com/ https://youtu.be/3BWSSpcn95A https://stackoverflow.com/ https://youtu.be/684KSAvYbw4 https://exploreembedded.com/ https://www.youtube.com/watch?v=JmvMvIphMnY&t https://prosperityconsulting.com

It is still a work in progress, but here is the code. While the code may not be elegant, it works! . I would like to work on the sensitivity and some “smoothing” but so far, I have not cracked the mysterious esp32 internal “touch” functions.

// SENDER AND CONTROL UNIT. 
//mostly the code comes directly from the ESP32  documentation but with lots of study and insights from //the  https://randomnerdtutorials.com/ website.
// this is the "sender" module but I am thinking of swapping them around.  In other words putting the //"smarts" in the LED display unit and having the unit at the tank(s) just send raw data. 

#include <esp_now.h>
#include <WiFi.h>
#include <Preferences.h>  // library to set up write-to-flash function 

Preferences preferences;  // Assignment to set up write-to-flash function 


  //d12 T9 - d4 T0  - d15 T3  - d13 T4  -  d12 T5  the TouchPin number and pin number (jsut for reference)

// situp variables for checking "LED" staus
bool l1 = 0;
bool l2 = 0;
bool l3 = 0;
bool l4 = 0;
bool l5 = 0;

int padding = 4; //CALBRATION FACTOR (times.001) threshold value. set to present sensor reading to allow for drift

int  buttonStatus = 0; // initialize button 

int  currentSensorVal1;  // the latest reading of the sensors
int  currentSensorVal2;
int  currentSensorVal3;
int  currentSensorVal4;
int  currentSensorVal5;

int  threshHoldValue1;  // INITIALIZE VARIABLE TO STORE  drySensorValue plus a margin for error 
int  threshHoldValue2;
int  threshHoldValue3;
int  threshHoldValue4;
int  threshHoldValue5;

// Global copy of slave
esp_now_peer_info_t slave;
#define CHANNEL 1   //  must match this value on slave
#define PRINTSCANRESULTS 0
#define DELETEBEFOREPAIR 0

// Init ESP Now with fallback
void InitESPNow() {
	WiFi.disconnect();
	if (esp_now_init() == ESP_OK) {
		Serial.println("ESPNow Init Success");
	} else {
		Serial.println("ESPNow Init Failed");
		ESP.restart();
	}
}

// Scan for slaves in AP mode
void ScanForSlave() {
	int8_t scanResults = WiFi.scanNetworks();
	// reset on each scan
	bool slaveFound = 0;
	memset(&slave, 0, sizeof(slave));

	Serial.println("");
	if (scanResults == 0) {
		Serial.println("No WiFi devices in AP Mode found");
	} else {
		Serial.print("Found "); Serial.print(scanResults); Serial.println(" devices ");
		for (int i = 0; i < scanResults; ++i) {
			// Print SSID and RSSI for each device found
			String SSID = WiFi.SSID(i);
			int32_t RSSI = WiFi.RSSI(i);
			String BSSIDstr = WiFi.BSSIDstr(i);

			if (PRINTSCANRESULTS) {
				Serial.print(i + 1);
				Serial.print(": ");
				Serial.print(SSID);
				Serial.print(" (");
				Serial.print(RSSI);
				Serial.print(")");
				Serial.println("");
			}
			delay(10);
			// Check if the current device starts with `Slave`
			if (SSID.indexOf("Slave") == 0) {
				// SSID of interest
				Serial.println("Found a Slave.");
				Serial.print(i + 1); Serial.print(": "); Serial.print(SSID); Serial.print(" ["); Serial.print(BSSIDstr); Serial.print("]"); Serial.print(" ("); Serial.print(RSSI); Serial.print(")"); Serial.println("");
				// Get BSSID => Mac Address of the Slave
				int mac[6];
				if (6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x", &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5])) {
					for (int ii = 0; ii < 6; ++ii) {
						slave.peer_addr[ii] = (uint8_t)mac[ii];
					}
				}

				slave.channel = CHANNEL; // pick a channel
				slave.encrypt = 0; // no encryption

				slaveFound = 1;
				// we are planning to have only one slave in this example;
				// Hence, break after we find one, to be a bit efficient
				break;
			}
		}
	}

	if (slaveFound) {
		Serial.println("Slave Found, processing..");
	} else {
		Serial.println("Slave Not Found, trying again.");
	}

	// clean up ram
	WiFi.scanDelete();
}

// Check if the slave is already paired with the master.
// If not, pair the slave with master
bool manageSlave() {
	if (slave.channel == CHANNEL) {
		if (DELETEBEFOREPAIR) {
			deletePeer();
		}

		Serial.print("Slave Status: ");
		// check if the peer exists
		bool exists = esp_now_is_peer_exist(slave.peer_addr);
		if (exists) {
			// Slave already paired.
			Serial.println("Already Paired");
			return true;
		} else {
			// Slave not paired, attempt pair
			esp_err_t addStatus = esp_now_add_peer(&slave);
			if (addStatus == ESP_OK) {
				// Pair success
				Serial.println("Pair success");
				return true;
			} else if (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {
				// How did we get so far!!
				Serial.println("ESPNOW Not Init");
				return false;
			} else if (addStatus == ESP_ERR_ESPNOW_ARG) {
				Serial.println("Invalid Argument");
				return false;
			} else if (addStatus == ESP_ERR_ESPNOW_FULL) {
				Serial.println("Peer list full");
				return false;
			} else if (addStatus == ESP_ERR_ESPNOW_NO_MEM) {
				Serial.println("Out of memory");
				return false;
			} else if (addStatus == ESP_ERR_ESPNOW_EXIST) {
				Serial.println("Peer Exists");
				return true;
			} else {
				Serial.println("Not sure what happened");
				return false;
			}
		}
	} else {
		// No slave found to process
		Serial.println("No Slave found to process");
		return false;
	}
}

void deletePeer() {
	esp_err_t delStatus = esp_now_del_peer(slave.peer_addr);
	Serial.print("Slave Delete Status: ");
	if (delStatus == ESP_OK) {
		// Delete success
		Serial.println("Success");
	} else if (delStatus == ESP_ERR_ESPNOW_NOT_INIT) {
		// How did we get so far!!
		Serial.println("ESPNOW Not Init");
	} else if (delStatus == ESP_ERR_ESPNOW_ARG) {
		Serial.println("Invalid Argument");
	} else if (delStatus == ESP_ERR_ESPNOW_NOT_FOUND) {
		Serial.println("Peer not found.");
	} else {
		Serial.println("Not sure what happened");
	}
}
uint8_t data = 0;

// callback when data is sent from Master to Slave
void OnDataSent(const uint8_t* mac_addr, esp_now_send_status_t status) {
	char macStr[18];
	snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
			 mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
	Serial.print("Last Packet Sent to: "); Serial.println(macStr);
	Serial.print("Last Packet Send Status: "); Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}
// void wifi code end 

void setup()  {	
	Serial.begin(115200);	
	preferences.begin("calibration", false);// Line to make nonvolitile memory work NO ERROR REPORTED IF MISSING!
	WiFi.mode(WIFI_STA); //Set device in STA mode to begin with
	Serial.println("ESPNow/Basic/Master Example");
	// This is the mac address of the Master in Station Mode
	Serial.print("STA MAC: "); Serial.println(WiFi.macAddress());
	// Init ESPNow with a fallback logic
	InitESPNow();
	// Once ESPNow is successfully Init, we will register for Send CB to
	// get the status of Trasnmitted packet
	esp_now_register_send_cb(OnDataSent);
	
	

	pinMode(26, INPUT_PULLUP);  // enable internal pull-up	for calibration pushbutton 
	  // enable led pins, 
	pinMode(21, OUTPUT);
	pinMode(22, OUTPUT);
	pinMode(23, OUTPUT);
	pinMode(24, OUTPUT);
	pinMode(25, OUTPUT);
	
}

void loop() {
	readAndReport();  // functions that read the data compare to the saved data and decide HIGH OR LOW for LEdS
	setUpConnections();  // wifi code from ESP32	
	// sendData();  //ESP32   sending funciton 
		
}  
// ==================================== end LOOP() ================================================

//----------------    ===============FUNCTIONS =========================================================
// send data FUNCTION (mostly writtee by ESP) ====================================
void sendData() {
	// Must match the receiver structure  NEW DW
	typedef struct struct_message {
	//		char dw_a[32]= "a"; 	//	int dw_b = 202;//		float dw_c = 26.9;	//	String dw_d = "this test";
 int dw_1 = l1;
 int dw_2 = l2;
 int dw_3 = l3;
 int dw_4 = l4;
 int dw_5 = l5;
  //  int dw_d = 1;
	//	bool dw_e = 1;
	} struct_message;
	
	// Create a struct_message called myData
	struct_message myData;

//	Serial.printf(" myData  a is chr         %s\n", myData.dw_a);
//	Serial.printf(" myData  b is int         %u\n", myData.dw_b);
//	Serial.printf(" myData  c is float       %f\n", myData.dw_c);
//	Serial.printf(" myData  d is string      %s\n", myData.dw_d);
//	Serial.printf(" myData  e is bool        %u\n", myData.dw_e);
//	Serial.print(myData.dw_a);
//	Serial.print(myData.dw_b);
//	Serial.print(myData.dw_c);
//	Serial.print(myData.dw_d);
//	Serial.print(myData.dw_e);
	//delay(300);


	const uint8_t* peer_addr = slave.peer_addr;
	Serial.print("Sending: "); Serial.println(data);
	esp_err_t result = esp_now_send(peer_addr, (uint8_t*) &myData, sizeof(myData));
	Serial.print("Send Status: ");
	if (result == ESP_OK) {
		Serial.println("Success");
	} else if (result == ESP_ERR_ESPNOW_NOT_INIT) {  //  How did we get so far!!
		Serial.println("ESPNOW not Init.");
	} else if (result == ESP_ERR_ESPNOW_ARG) { // Invalid Argument 
		Serial.println("Invalid Argument");
	} else if (result == ESP_ERR_ESPNOW_INTERNAL) { // Internal Error
		Serial.println("Internal Error");
	} else if (result == ESP_ERR_ESPNOW_NO_MEM) { // no mem
		Serial.println("ESP_ERR_ESPNOW_NO_MEM");
	} else if (result == ESP_ERR_ESPNOW_NOT_FOUND) {  // peer not found
		Serial.println("Peer not found.");
	} else {
		Serial.println("Not sure what happened");
	}
}


		void readAndReport() {   // code by dw to get values, compare them and turn on LEDs as needed.
		Serial.println("------------------- IN LOOP ");
	
		int  savedThreshHoldValue1;  // intialize the variables used for calibration *************
		int  savedThreshHoldValue2;
		int  savedThreshHoldValue3;
		int  savedThreshHoldValue4;
		int  savedThreshHoldValue5;

		// READ SENSOR THREASHOLD VALUES STORED AT LAST CALIBRATION. USED TO COMPARE TO CURRENT SENSOR READINGS
		savedThreshHoldValue1 = preferences.getInt("sensor1", savedThreshHoldValue1);
		savedThreshHoldValue2 = preferences.getInt("sensor2", savedThreshHoldValue2);
		savedThreshHoldValue3 = preferences.getInt("sensor3", savedThreshHoldValue3);
		savedThreshHoldValue4 = preferences.getInt("sensor4", savedThreshHoldValue4);
		savedThreshHoldValue5 = preferences.getInt("sensor5", savedThreshHoldValue5);
		Serial.print("====================saved value one   ");
		Serial.println(savedThreshHoldValue1);
		delay(800);

		currentSensorVal1 = touchRead(13); // read the sensors as the loop() iterates 
		delay(5);
		currentSensorVal2 = touchRead(32);  // watch for them to go below the stored threashold value
		delay(5);
		currentSensorVal3 = touchRead(15); 
		delay(5);
		currentSensorVal4 = touchRead(12); 
		delay(5);
		currentSensorVal5 = touchRead(33); 
		delay(5);

		Serial.println("||||||||||||||||||||||||||||||||||||||||||||||||||||");
		
		//Serial.println();
		Serial.println("         SAVED	CURRENT	DIFFERENCE =================");
		Serial.print("Value 1 > ");
		Serial.print(savedThreshHoldValue1);
		Serial.print("\t");
		Serial.print(currentSensorVal1);
		Serial.print("\t"); Serial.print("\t");
		Serial.println(savedThreshHoldValue1 - currentSensorVal1);

		Serial.print("Value 2 > ");		
		Serial.print(savedThreshHoldValue2);
		Serial.print("\t");	
		Serial.print(currentSensorVal2);
		Serial.print("\t"); Serial.print("\t");
		Serial.println(savedThreshHoldValue2 - currentSensorVal2);
		
		Serial.print("Value 3 > ");
		Serial.print(savedThreshHoldValue3);
		Serial.print("\t");
		Serial.print(currentSensorVal3);
		Serial.print("\t"); Serial.print("\t");
		Serial.println(savedThreshHoldValue3 - currentSensorVal3);

		Serial.print("Value 4 > ");
		Serial.print(savedThreshHoldValue4);
		Serial.print("\t");
		Serial.print(currentSensorVal4);
		Serial.print("\t"); Serial.print("\t");
		Serial.println(savedThreshHoldValue4 - currentSensorVal4);

		Serial.print("Value 5 > ");
		Serial.print(savedThreshHoldValue5);
		Serial.print("\t");
		Serial.print(currentSensorVal5);
		Serial.print("\t"); Serial.print("\t");
		Serial.println(savedThreshHoldValue5 - currentSensorVal5);
	/*
	//	Serial.print(" CURRENT  value 3 > ");
		Serial.println(currentSensorVal3);
	//	Serial.print(" SAVED  Value 4 > ");
		Serial.print(savedThreshHoldValue4);
		Serial.print(" CURRENT  value 4 > ");
		Serial.println(currentSensorVal4);
		Serial.print(" SAVED  Value 5 > ");
		Serial.print(savedThreshHoldValue5);
		Serial.print(" CURRENT  value 5 > ");
		Serial.println(currentSensorVal5);
		Serial.printf(" SAVED SAVED SAVED SAVED savedThreshHoldValue1 >     %u\n", savedThreshHoldValue1);
		Serial.printf(" SAVED SAVED SAVED SAVED savedThreshHoldValue1 >     %u\n", savedThreshHoldValue2);
		Serial.printf(" SAVED SAVED SAVED SAVED savedThreshHoldValue1 >     %u\n", savedThreshHoldValue3);
		Serial.printf(" SAVED SAVED SAVED SAVED savedThreshHoldValue1 >     %u\n", savedThreshHoldValue4);
		Serial.printf(" SAVED SAVED SAVED SAVED savedThreshHoldValue1 >     %u\n", savedThreshHoldValue5);
		
		Serial.println();
		Serial.printf("    ###################   CURRENTSensorVal1 >>>>     %u\n", currentSensorVal1);
		Serial.printf("    ###################   CURRENTSensorVal2 >>>>     %u\n", currentSensorVal2);
		Serial.printf("    ###################   CURRENTSensorVal3 >>>>     %u\n", currentSensorVal3);
		Serial.printf("    ###################   CURRENTSensorVal4 >>>>     %u\n", currentSensorVal4);
		Serial.printf("    ###################   CURRENTSensorVal5 >>>>     %u\n", currentSensorVal5);
		delay(500);
		*/
		
		int  pinValue = digitalRead(26); // added to get button press up here 
		delay(10); // quick and dirty debounce filter
		if (buttonStatus != pinValue) {
			buttonStatus = pinValue;
			Serial.println(buttonStatus);
		}
		if (buttonStatus == 0) {
			// RUN FUNCTION 
			threshHoldValue1 = PushButtonToSetDrySensor1(); // WAS ORIGINAL  run fuction to Capture 'dry' state then pad 
		}
		
		// end -- added to get button press up here 

		Serial.print("                 BUTTON STATUS  IS  >>>>>   : ");
		Serial.println(buttonStatus);


		if (currentSensorVal1 <= savedThreshHoldValue1) {
			Serial.println(" HIGH  HIGH                    HIGH   HIGH");
			digitalWrite(21, HIGH);
			l1 = 1;
		} else {
			Serial.println("LOW   LOW LOW                   LOW   LOW ");
			digitalWrite(21, LOW);
			l1 = 0;
		}
		if (currentSensorVal2 <= savedThreshHoldValue2) {
			Serial.println(" HIGH  HIGH                    HIGH   HIGH");
			digitalWrite(22, HIGH);
			l2 = 1;
		} else {
			Serial.println("LOW   LOW LOW                   LOW   LOW ");
			digitalWrite(22, LOW);
			l2 = 0;
		}
		if (currentSensorVal3 <= savedThreshHoldValue3) {
			Serial.println(" HIGH  HIGH                     HIGH   HIGH");
			digitalWrite(23, HIGH);
			l3 = 1;
		} else {
			Serial.println("LOW   LOW LOW                   LOW   LOW ");
			digitalWrite(23, LOW);
			l3 = 0;
		}
		if (currentSensorVal4 <= savedThreshHoldValue4) {
			Serial.println(" HIGH  HIGH                   HIGH   HIGH");
			digitalWrite(24, HIGH);
			l4 = 1;
		} else {
			Serial.println("LOW   LOW LOW                   LOW   LOW ");
			digitalWrite(24, LOW);
			l4 = 0;
		}
		if (currentSensorVal5 <= savedThreshHoldValue5) {
			Serial.println(" HIGH  HIGH                   HIGH   HIGH");
			digitalWrite(25, HIGH);
			l5 = 1;
		} else {
			Serial.println("LOW   LOW LOW                   LOW   LOW ");
			digitalWrite(25, LOW);
			l5 = 0;
		}


		Serial.print("    ##########   The Current Sensor Value 1 >>>> ");
		Serial.println(currentSensorVal1);
	//	delay(100);
	}


// **************************************** FUNCTIONS  *********************************************
	//  CALABRATION FUNCTION
int  PushButtonToSetDrySensor1() {   // PUSH BUTTON TO COLLECT CURRENT SENSOR VALUES AND SAVE TO NONVOLITIAL MEMORY
	Serial.println("NOW INSIDE   PushButtonToSetDrySensor1()");
	delay(500);

	threshHoldValue1 = currentSensorVal1 -  padding; //sensor on analog in 0
	threshHoldValue2 = currentSensorVal2 -  padding;
	threshHoldValue3 = currentSensorVal3 -  padding;
	threshHoldValue4 = currentSensorVal4 -  padding;
	threshHoldValue5 = currentSensorVal5 -  padding;

	Serial.println(" BUTTON IS PUSHED ================     ");
	Serial.print("    VALUE OF   threshHoldValue1 ======   ");
	Serial.println(threshHoldValue1);
	Serial.print("    VALUE OF   threshHoldValueTWO == ===  ");
	Serial.println(threshHoldValue2);

	delay(500);

	// save the threshHoldvalue in eeprom 
	dwEeprommRoutine(threshHoldValue1, threshHoldValue2, threshHoldValue3, threshHoldValue4, threshHoldValue5);

}


// FUNCTION ******************************* READ WRITE TO EEPROM  FUCTION **************************
//void dwEeprommRoutine(int  savedThreshHoldValue1, int  savedThreshHoldValue2, int savedThreshHoldValue3, int  savedThreshHoldValue4, int  savedThreshHoldValue5) 
void dwEeprommRoutine(int  threshHoldValue1, int  threshHoldValue2, int savedThreshHoldValue3, int  savedThreshHoldValue4, int  savedThreshHoldValue5)
{
	Serial.println("IN EEPROM FUNCTION === IN EEPROM FUNCTION ===  ");
	Serial.println("IN EEPROM FUNCTION === IN EEPROM FUNCTION === -");
	Serial.println("IN EEPROM FUNCTION === IN EEPROM FUNCTION === --");
	delay(500);
	Serial.print("  threshHoldValue1  IN EEPROM           +++++     ");
	Serial.print(threshHoldValue1);
	Serial.print("  threshHoldValue2  IN EEPROM           +++++     ");
	Serial.print(threshHoldValue2);

	//delay(100);	
	//int  maxx;
		
	Serial.print(" this is threshHoldValue1  >>>>>>>#########>> ");
	Serial.println(threshHoldValue1);
	Serial.print(" this is threshHoldValueTWO  >>>>>>>#########>> ");
	Serial.println(threshHoldValue2);
	Serial.print(" this is threshHoldValue3  >>>>>>>#########>> ");
	Serial.println(threshHoldValue3);
	Serial.print(" this is threshHoldValue4  >>>>>>>#########>> ");
	Serial.println(threshHoldValue4);
	Serial.print(" this is threshHoldValue5  >>>>>>>#########>> ");
	Serial.println(threshHoldValue5);

	delay(500);

	int  value = 1;
	if (value == 1);
	{// WRITE TO FLASH MEMOREY USING PREFERENCES FUCTION (REPLACED EEPROM FUNCTION)
		preferences.putInt("sensor1", threshHoldValue1);
		delay(50);
		preferences.putInt("sensor2", threshHoldValue2);
		delay(50);
		preferences.putInt("sensor3", threshHoldValue3);
		delay(50);
		preferences.putInt("sensor4", threshHoldValue4);
		delay(50);
		preferences.putInt("sensor5", threshHoldValue5);
		delay(50);

		Serial.print("SAVED in Prefereces threshHoldValue1        >>> ");
		Serial.println(threshHoldValue1);
		Serial.print("    is SAVED threshHoldValue2 >>>#######        ");
		Serial.println(threshHoldValue2);
		Serial.print("    is SAVED threshHoldValue3 >>>#######        ");
		Serial.println(threshHoldValue3);
		Serial.print("    is SAVED threshHoldValue4 >>>#######        ");
		Serial.println(threshHoldValue4);
		Serial.print("    is SAVED threshHoldValue5 >>>#######        ");
		Serial.println(threshHoldValue5);

		//delay(3100);
	}
}

// wifi code function from ESP32 code =================================================================
void setUpConnections() {
// bool setUpConnections() {
	// In the loop we scan for slave
	ScanForSlave();
	// If Slave is found, it would be populate in `slave` variable
	// We will check if `slave` is defined and then we proceed further
	if (slave.channel == CHANNEL) { // check if slave channel is defined
	  // `slave` is defined
	  // Add slave as peer if it has not been added already
		bool isPaired = manageSlave();
	//	return isPaired;
		if (isPaired) {
			// pair success or already paired
			// Send data to device
			sendData();
		} else {
			// slave pair failed
			Serial.println("Slave pair failed!");
		}
	} else {
		// No slave found to process
		
	}
	
	// wait for 3seconds to run the logic again
	delay(1000);
	
}

// /*
//=============FUNCTION ======== calulate level and send to reciever ==========================
uint8_t SendPinData() {
//uint8_t data = 0;
	
if (l1 == 1 && l2 == 1) {data = 200;  goto dwBreak;}
if (l1 == 0 && l2 == 1 && l3 == 1 ) { data = 180; goto dwBreak;  }
if (l1 == 0 && l2 == 0 && l3 == 1 && l4 == 1 ) {data = 160; goto dwBreak; }
 if (l1 == 0 && l2 == 0 && l3 == 0 && l4 == 1 && l5 == 1)  {	data = 140; goto dwBreak; }
 if (l1 == 0 && l2 == 0 && l3 == 0 && l4 == 0 && l5 == 0) {	data = 100;}
 else { data = 50; }
 dwBreak: // this is a LABLE . it seems it is created simply by using a colon ':' 
Serial.printf(" DATA DATA DATA DATA DATA DATA      ================ >     %u\n", data);

return data;
	}
//	*/
/**   LED gauge display unit (the dumb one).
   ESPNOW - Basic communication - Slave
   Date: 26th September 2017
   Author: Arvind Ravulavaru <https://github.com/arvindr21>
   Purpose: ESPNow Communication between a Master ESP32 and a Slave ESP32
   Description: This sketch consists of the code for the Slave module.
   Resources: (A bit outdated)
   a. https://espressif.com/sites/default/files/documentation/esp-now_user_guide_en.pdf
   b. http://www.esploradores.com/practica-6-conexion-esp-now/

   << This Device Slave >>

   Flow: Master
   Step 1 : ESPNow Init on Master and set it in STA mode
   Step 2 : Start scanning for Slave ESP32 (we have added a prefix of `slave` to the SSID of slave for an easy setup)
   Step 3 : Once found, add Slave as peer
   Step 4 : Register for send callback
   Step 5 : Start Transmitting data from Master to Slave

   Flow: Slave
   Step 1 : ESPNow Init on Slave
   Step 2 : Update the SSID of Slave with a prefix of `slave`
   Step 3 : Set Slave in AP mode
   Step 4 : Register for receive callback and wait for data
   Step 5 : Once data arrives, print it in the serial monitor

   Note: Master and Slave have been defined to easily understand the setup.
         Based on the ESPNOW API, there is no concept of Master and Slave.
         Any devices can act as master or salve.
*/

#include <esp_now.h>
#include <WiFi.h>

#define CHANNEL 1
 
  
// Init ESP Now with fallback
void InitESPNow() {
  WiFi.disconnect();
  if (esp_now_init() == ESP_OK) {
    Serial.println("ESPNow Init Success");
  }
  else {
    Serial.println("ESPNow Init Failed");
    // Retry InitESPNow, add a counte and then restart?
    // InitESPNow();
    // or Simply Restart
    ESP.restart();
  }
}

// config AP SSID
void configDeviceAP() {
  const char *SSID = "Slave_1";
  bool result = WiFi.softAP(SSID, "Slave_1_Password", CHANNEL, 0);
  if (!result) {
    Serial.println("AP Config failed.");
  } else {
    Serial.println("AP Config Success. Broadcasting with AP: " + String(SSID));
  }
}

void setup() {
  Serial.begin(115200);
  Serial.print("             I am here    ================================");
  pinMode(21, OUTPUT);
  pinMode(22, OUTPUT);
  pinMode(23, OUTPUT);
  pinMode(24, OUTPUT);
  pinMode(25, OUTPUT);
  Serial.println("ESPNow/Basic/Slave Example");
  //Set device in AP mode to begin with
  WiFi.mode(WIFI_AP);
  // configure device AP mode
  configDeviceAP();
  // This is the mac address of the Slave in AP Mode
  Serial.print("AP MAC: "); Serial.println(WiFi.softAPmacAddress());
  // Init ESPNow with a fallback logic
  InitESPNow();
  // Once ESPNow is successfully Init, we will register for recv CB to
  // get recv packer info.
  esp_now_register_recv_cb(OnDataRecv);
}
typedef struct struct_message {
   // char dw_a[32];
 //   int dw_b;
 //   float dw_c;
  //  String d;
 //   int dw_d;
 //   bool dw_e;
  //  bool a;
  //  bool b;
  //  bool c;
 //  
  //  bool e;
    int dw_1 = 1;
    int dw_2 = 1;
    int dw_3 = 1;
    int dw_4 = 1;
    int dw_5 = 1;
    
} struct_message;

struct_message myData;

// callback when data is recv from Master
//void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int data_len) {

//void OnDataRecv(const uint8_t* mac_addr, const uint8_t* myData, int data_len) {

void OnDataRecv(const uint8_t* mac_addr, const uint8_t* incomingData, int len){
    memcpy(&myData, incomingData, sizeof(myData));
   
    Serial.print("Bytes received: ");
    Serial.println(len);
  //  Serial.print("Char: ");
    Serial.print("dw_1: ");
    Serial.println(myData.dw_1);
    Serial.print("dw_2: ");
    Serial.println(myData.dw_2);
    Serial.print("dw_3: ");
    Serial.println(myData.dw_3);
    Serial.print("dw_4  ");
    Serial.println(myData.dw_4);
    Serial.print("dw_5   ");
    Serial.println(myData.dw_5);
    
    if (myData.dw_1 == 1) { digitalWrite(21, HIGH); 
    Serial.print("dw_1: in if statement ");
    Serial.println(myData.dw_1); 
    }
    delay(500);
    if (myData.dw_1 == 0) { digitalWrite(21, LOW);
    Serial.print("dw_1: in if statment ");
    Serial.println(myData.dw_1); 
    }
    delay(500);
    
    if (myData.dw_2 == 1) { digitalWrite(22, HIGH); }
    if (myData.dw_3 == 1) { digitalWrite(23, HIGH); }
    if (myData.dw_4 == 1) { digitalWrite(24, HIGH); }
    if (myData.dw_5 == 1) { digitalWrite(25, HIGH); }
    
    if (myData.dw_2 == 0) { digitalWrite(22, LOW); }
    if (myData.dw_3 == 0) { digitalWrite(23, LOW); }
    if (myData.dw_4 == 0) { digitalWrite(24, LOW); }
    if (myData.dw_5 == 0) { digitalWrite(25, LOW); }
   
   
  
  char macStr[18];
  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
           mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
  Serial.print("Last Packet Recv from: "); Serial.println(macStr);
 // Serial.print("Last Packet Recv Data: "); Serial.println(*data);
 // Serial.print("Last Packet Recv Data: "); Serial.println(myData);
  Serial.println("");
  Serial.println();
 
}
void loop() {
  //  Serial.print("  data without the * as whatever : "); Serial.println(data2);
 // digitalWrite(21, HIGH);
// digitalWrite(21, LOW);
// delay(1000);
// digitalWrite(21, HIGH);
// delay(1000);
 // Serial.print("             I am here    ================================");
  
  /*
  if (*data = 200 ) {
  digitalWrite(21, HIGH);
   digitalWrite(22, HIGH);
   digitalWrite(23, HIGH);
   digitalWrite(24, HIGH);
   digitalWrite(25, HIGH);
  }
  
  // Chill
  */
}
Latest posts by Don Winchell (see all)
Please share it. Thanks!