(RTC_SW_SYS_RST),boot:0x8 (SPI_FAST_FLASH_BOOT)

[d4rkpunk69]

I don't know what happened to this but it keeps rebooting, my module is heltec lora 32 v3 and I used concurrency theoretically using 2 cores
My pin configurations are as follows

// Ultrasonic Sensor Pins
#define TRIG_PIN 12
#define ECHO_PIN 13

// Relay and Solenoid Pins
#define RAIN_SOLENOID_PIN 6     // Solenoid valve for rainwater tank
#define DEEPWELL_SOLENOID_PIN 5 // Solenoid valve for deepwell tank
#define PUMP_RELAY_PIN 7        // Pump relay

my full code

#include <Arduino.h>
#include <heltec_unofficial.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/semphr.h>

// ============= Configuration =============
// Ultrasonic Sensor Pins (for Main Tank)
#define TRIG_PIN 12
#define ECHO_PIN 13

// Relay and Solenoid Pins
#define RAIN_SOLENOID_PIN 6     // Solenoid valve for rainwater tank
#define DEEPWELL_SOLENOID_PIN 5 // Solenoid valve for deepwell tank
#define PUMP_RELAY_PIN 7        // Pump relay

// Timing Configuration
#define DATA_TIMEOUT 300000     // Data timeout (5 minutes in ms)
#define VALVE_PUMP_DELAY 5000   // Delay between valve open and pump start (5 seconds)
#define CONFIRMATION_DELAY 2000 // Delay between confirmations (2 seconds)

// LoRa Configuration
#define LORA_FREQUENCY 915.0
#define LORA_SPREADING_FACTOR 9
#define LORA_BANDWIDTH 125.0
#define LORA_CODING_RATE 5
#define LORA_SYNC_WORD 0xF3
#define NODE_ID 1               // This is Node 1 (Main Tank)

// Tank Configuration
#define NUM_TANKS 3             // Main (0), Deepwell (1), Rainwater (2)
#define TANK_HEIGHT_CM 100.0
#define LOW_WATER_THRESHOLD 20.0 // 20% water level is considered low
#define HIGH_WATER_THRESHOLD 80.0 // 80% water level is considered full

// ============= Data Structures =============
// LoRa Packet Structure
#pragma pack(push, 1)
struct LoraPacket {
    uint8_t nodeID;
    float distance_cm;
    float battery_v;
    uint8_t checksum;
};
#pragma pack(pop)

// Tank Data Structure
struct TankData {
    float distance;
    float waterLevel;           // Water level as percentage
    unsigned long lastUpdate;
    bool valid;
};

// System Status Enumeration
enum SystemStatus {
    STATUS_DEFAULT,             // Normal operation
    STATUS_LOW_WATER,           // Main tank is low, selecting source
    STATUS_CONFIRMING_SOURCE,   // Confirming selected source
    STATUS_FILLING              // Filling main tank from selected source
};

// Water Source Enumeration
enum WaterSource {
    SOURCE_NONE,
    SOURCE_DEEPWELL,
    SOURCE_RAINWATER
};

// ============= Global Variables =============
TankData tanks[NUM_TANKS] = {0};
SystemStatus currentStatus = STATUS_DEFAULT;
WaterSource selectedSource = SOURCE_NONE;
int confirmationCount = 0;
unsigned long lastConfirmationTime = 0;
bool pumpActive = false;

// Mutex for thread safety
SemaphoreHandle_t tankDataMutex = NULL;

// Task handles
TaskHandle_t loraTaskHandle = NULL;
TaskHandle_t displayTaskHandle = NULL;
TaskHandle_t sensorTaskHandle = NULL;
TaskHandle_t controlTaskHandle = NULL;

// ============= Function Prototypes =============
// Task Functions
void loraTask(void *parameter);
void displayTask(void *parameter);
void sensorTask(void *parameter);
void controlTask(void *parameter);

// LoRa Functions
uint8_t calculateChecksum(LoraPacket& packet);
void sendMainTankData();

// Sensor Functions
float readUltrasonicDistance();
float calculateWaterLevel(float distance);

// Control Functions
void selectWaterSource();
void confirmWaterSource();
void activateWaterSource();
void deactivateWaterSource();

// UI Functions
void showMessage(const String& msg, int delayTime);
void updateDisplay();

// ============= Main Arduino Functions =============
void setup() {
    // Initialize hardware
    heltec_ve(true);
    heltec_setup();
    
    // Configure sensor pins
    pinMode(TRIG_PIN, OUTPUT);
    pinMode(ECHO_PIN, INPUT);
    
    // Configure relay and solenoid pins
    pinMode(RAIN_SOLENOID_PIN, OUTPUT);
    pinMode(DEEPWELL_SOLENOID_PIN, OUTPUT);
    pinMode(PUMP_RELAY_PIN, OUTPUT);
    
    // Initialize outputs to OFF
    digitalWrite(RAIN_SOLENOID_PIN, LOW);
    digitalWrite(DEEPWELL_SOLENOID_PIN, LOW);
    digitalWrite(PUMP_RELAY_PIN, LOW);
    
    // Create mutex for thread safety
    tankDataMutex = xSemaphoreCreateMutex();
    
    // Display startup message
    showMessage("Starting Node 1...", 1000);
    
    // Initialize LoRa
    int state = radio.begin(LORA_FREQUENCY);
    if(state == RADIOLIB_ERR_NONE) {
        radio.setSpreadingFactor(LORA_SPREADING_FACTOR);
        radio.setBandwidth(LORA_BANDWIDTH);
        radio.setCodingRate(LORA_CODING_RATE);
        radio.setSyncWord(LORA_SYNC_WORD);
        
        showMessage("LoRa Ready", 1000);
    } else {
        showMessage("LoRa Error: " + String(state), 0);
        while(1) { delay(1000); } // Halt with error
    }
    
    // Create tasks pinned to specific cores
    xTaskCreatePinnedToCore(
        loraTask,
        "LoRaTask",
        4096,
        NULL,
        1,
        &loraTaskHandle,
        0  // Run on Core 0
    );
    
    xTaskCreatePinnedToCore(
        displayTask,
        "DisplayTask",
        4096,
        NULL,
        2,  // Higher priority for display
        &displayTaskHandle,
        1  // Run on Core 1
    );
    
    xTaskCreatePinnedToCore(
        sensorTask,
        "SensorTask",
        2048,
        NULL,
        1,
        &sensorTaskHandle,
        0  // Run on Core 0
    );
    
    xTaskCreatePinnedToCore(
        controlTask,
        "ControlTask",
        2048,
        NULL,
        1,
        &controlTaskHandle,
        0  // Run on Core 0
    );
}

void loop() {
    // Empty loop - tasks handle everything
    vTaskDelay(1000 / portTICK_PERIOD_MS);
}

// ============= Task Implementations =============
void loraTask(void *parameter) {
    while(true) {
        // Receive data from other nodes
        uint8_t data[sizeof(LoraPacket)];
        int state = radio.receive(data, sizeof(LoraPacket));
        
        if(state == RADIOLIB_ERR_NONE) {
            LoraPacket* packet = (LoraPacket*)data;
            
            // Process packets from Deepwell (Node 2) and Rainwater (Node 3)
            if(packet->nodeID == 2 || packet->nodeID == 3) {
                uint8_t receivedChecksum = packet->checksum;
                packet->checksum = 0;
                
                if(calculateChecksum(*packet) == receivedChecksum) {
                    // Take mutex before accessing shared data
                    if(xSemaphoreTake(tankDataMutex, portMAX_DELAY)) {
                        int index = packet->nodeID - 1; // Node 2 -> index 1, Node 3 -> index 2
                        tanks[index].distance = packet->distance_cm;
                        tanks[index].waterLevel = calculateWaterLevel(packet->distance_cm);
                        tanks[index].lastUpdate = millis();
                        tanks[index].valid = true;
                        xSemaphoreGive(tankDataMutex);
                    }
                }
            }
        }
        
        // Send main tank data periodically
        static unsigned long lastSendTime = 0;
        if (millis() - lastSendTime > 10000) { // Every 10 seconds
            sendMainTankData();
            lastSendTime = millis();
        }
        
        // Small delay to prevent task starvation
        vTaskDelay(10 / portTICK_PERIOD_MS);
    }
}

void displayTask(void *parameter) {
    while(true) {
        // Update display
        if(xSemaphoreTake(tankDataMutex, portMAX_DELAY)) {
            updateDisplay();
            xSemaphoreGive(tankDataMutex);
        }
        
        // Update display every 100ms
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

void sensorTask(void *parameter) {
    while(true) {
        // Read main tank level
        float distance = readUltrasonicDistance();
        float waterLevel = calculateWaterLevel(distance);
        
        // Update main tank data with mutex protection
        if(xSemaphoreTake(tankDataMutex, portMAX_DELAY)) {
            tanks[0].distance = distance;
            tanks[0].waterLevel = waterLevel;
            tanks[0].lastUpdate = millis();
            tanks[0].valid = true;
            xSemaphoreGive(tankDataMutex);
        }
        
        // Check every second
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void controlTask(void *parameter) {
    while(true) {
        if(xSemaphoreTake(tankDataMutex, portMAX_DELAY)) {
            // State machine for tank control
            switch(currentStatus) {
                case STATUS_DEFAULT:
                    // Check if main tank is low
                    if(tanks[0].valid && tanks[0].waterLevel < LOW_WATER_THRESHOLD) {
                        currentStatus = STATUS_LOW_WATER;
                    }
                    break;
                    
                case STATUS_LOW_WATER:
                    // Select water source
                    selectWaterSource();
                    break;
                    
                case STATUS_CONFIRMING_SOURCE:
                    // Auto-confirmation after delay
                    if(millis() - lastConfirmationTime > CONFIRMATION_DELAY) {
                        confirmWaterSource();
                    }
                    break;
                    
                case STATUS_FILLING:
                    // Check if valve is open and pump needs to be started
                    if(!pumpActive && (millis() - lastConfirmationTime > VALVE_PUMP_DELAY)) {
                        // Start pump after delay
                        digitalWrite(PUMP_RELAY_PIN, HIGH);
                        pumpActive = true;
                    }
                    
                    // Check if main tank is full enough to stop filling
                    if(tanks[0].waterLevel > HIGH_WATER_THRESHOLD) {
                        deactivateWaterSource();
                        currentStatus = STATUS_DEFAULT;
                    }
                    break;
            }
            
            xSemaphoreGive(tankDataMutex);
        }
        
        // Check every 100ms
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

// ============= LoRa Functions =============
uint8_t calculateChecksum(LoraPacket& packet) {
    uint8_t sum = 0;
    const uint8_t* data = (uint8_t*)&packet;
    for(size_t i = 0; i < sizeof(packet) - 1; i++) {
        sum ^= data[i];
    }
    return sum;
}

void sendMainTankData() {
    if(tanks[0].valid) {
        LoraPacket packet;
        packet.nodeID = NODE_ID;
        packet.distance_cm = tanks[0].distance;
        packet.battery_v = 0; // Not used in this implementation
        packet.checksum = 0;
        packet.checksum = calculateChecksum(packet);
        
        radio.transmit((uint8_t*)&packet, sizeof(packet));
    }
}

// ============= Sensor Functions =============
float readUltrasonicDistance() {
    // Clear the trigger pin
    digitalWrite(TRIG_PIN, LOW);
    delayMicroseconds(2);
    
    // Set the trigger pin high for 10 microseconds
    digitalWrite(TRIG_PIN, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG_PIN, LOW);
    
    // Read the echo pin, returns the sound wave travel time in microseconds
    long duration = pulseIn(ECHO_PIN, HIGH);
    
    // Calculate the distance
    float distance_cm = duration * 0.034 / 2;
    
    // Constrain to valid range
    return constrain(distance_cm, 0, TANK_HEIGHT_CM);
}

float calculateWaterLevel(float distance) {
    float waterLevel = ((TANK_HEIGHT_CM - distance) / TANK_HEIGHT_CM) * 100.0;
    return constrain(waterLevel, 0, 100);
}

// ============= Control Functions =============
void selectWaterSource() {
    // Check if both sources are valid
    if(tanks[1].valid && tanks[2].valid && 
       (millis() - tanks[1].lastUpdate < DATA_TIMEOUT) && 
       (millis() - tanks[2].lastUpdate < DATA_TIMEOUT)) {
        // Choose the source with higher water level
        if(tanks[1].waterLevel > tanks[2].waterLevel) {
            selectedSource = SOURCE_DEEPWELL;
        } else {
            selectedSource = SOURCE_RAINWATER;
        }
    } 
    // Check if only deepwell is valid
    else if(tanks[1].valid && (millis() - tanks[1].lastUpdate < DATA_TIMEOUT)) {
        selectedSource = SOURCE_DEEPWELL;
    } 
    // Check if only rainwater is valid
    else if(tanks[2].valid && (millis() - tanks[2].lastUpdate < DATA_TIMEOUT)) {
        selectedSource = SOURCE_RAINWATER;
    } 
    // No valid sources
    else {
        selectedSource = SOURCE_NONE;
        return;
    }
    
    // Start confirmation process
    currentStatus = STATUS_CONFIRMING_SOURCE;
    confirmationCount = 0;
    lastConfirmationTime = millis();
}

void confirmWaterSource() {
    confirmationCount++;
    lastConfirmationTime = millis();
    
    if(confirmationCount >= 3) {
        // Three confirmations received, activate the source
        activateWaterSource();
        currentStatus = STATUS_FILLING;
    }
}

void activateWaterSource() {
    // Turn off all valves first
    digitalWrite(RAIN_SOLENOID_PIN, LOW);
    digitalWrite(DEEPWELL_SOLENOID_PIN, LOW);
    digitalWrite(PUMP_RELAY_PIN, LOW);
    pumpActive = false;
    
    // Activate the selected valve
    if(selectedSource == SOURCE_DEEPWELL) {
        digitalWrite(DEEPWELL_SOLENOID_PIN, HIGH);
    } else if(selectedSource == SOURCE_RAINWATER) {
        digitalWrite(RAIN_SOLENOID_PIN, HIGH);
    }
    
    // Record time of valve activation
    lastConfirmationTime = millis();
}

void deactivateWaterSource() {
    // Turn off all outputs
    digitalWrite(RAIN_SOLENOID_PIN, LOW);
    digitalWrite(DEEPWELL_SOLENOID_PIN, LOW);
    digitalWrite(PUMP_RELAY_PIN, LOW);
    
    // Reset variables
    selectedSource = SOURCE_NONE;
    confirmationCount = 0;
    pumpActive = false;
}

// ============= UI Functions =============
void showMessage(const String& msg, int delayTime) {
    display.clear();
    display.setTextAlignment(TEXT_ALIGN_CENTER);
    display.drawString(64, 24, msg);
    display.display();
    if(delayTime > 0) {
        delay(delayTime);
    }
}

void updateDisplay() {
    display.clear();
    
    // Display status at the top
    display.setTextAlignment(TEXT_ALIGN_LEFT);
    
    // Show current status
    String statusText = "Status - Default (Auto Select)";
    if(currentStatus == STATUS_LOW_WATER) {
        statusText = "Status - Low Water";
    } else if(currentStatus == STATUS_CONFIRMING_SOURCE) {
        statusText = "Status - Confirming Source";
    } else if(currentStatus == STATUS_FILLING) {
        statusText = "Status - Filling";
    }
    display.drawString(0, 0, statusText);
    display.drawHorizontalLine(0, 10, 128);
    
    // Display tank levels as requested
    display.drawString(0, 15, "Main tank - " + String(tanks[0].waterLevel, 1) + "% (this module) node 1");
    display.drawString(0, 25, "Deepwell - " + String(tanks[1].valid ? String(tanks[1].waterLevel, 1) : "??") + "% (receive from lora)");
    display.drawString(0, 35, "Rainwater - " + String(tanks[2].valid ? String(tanks[2].waterLevel, 1) : "??") + "% (receive from lora)");
    
    // If in confirmation mode, show which tank is selected and confirmation count
    if(currentStatus == STATUS_CONFIRMING_SOURCE) {
        String sourceText = "Selected: ";
        if(selectedSource == SOURCE_DEEPWELL) {
            sourceText += "Deepwell";
        } else if(selectedSource == SOURCE_RAINWATER) {
            sourceText += "Rainwater";
        }
        display.drawString(0, 45, sourceText + " (" + String(confirmationCount) + "/3)");
    }
    
    // If in filling mode, show which tank is being used
    if(currentStatus == STATUS_FILLING) {
        String sourceText = "Using: ";
        if(selectedSource == SOURCE_DEEPWELL) {
            sourceText += "Deepwell";
        } else if(selectedSource == SOURCE_RAINWATER) {
            sourceText += "Rainwater";
        }
        display.drawString(0, 45, sourceText + (pumpActive ? " (Pump ON)" : " (Valve Open)"));
    }
    
    display.display();
}