LEDs not syncing for basic example on ESP32-WROOM-32

[robinpdev]

Hi, i just tested the basic example on 2 ESP32-WROOM-32 .

This is the output:

[ESPNowMeshClock] Initializing timer...
[ESPNowMeshClock] Chip: ESP32-D0WD-V3
[ESPNowMeshClock] CPU Freq: 240 MHz
[ESPNowMeshClock] Timer test: lu -> lu (diff: lu us)
[ESPNowMeshClock] Started.
[PULSE] Mesh time: 4278358544 µs (4278358 ms)
ALONE
[MeshClock SYNC] Direct set forward. Offset: ld us, Delta: ld us
State Change: SYNCED - Successfully synchronized with mesh!
[PULSE] Mesh time: 4330801850 µs (4330801 ms)
SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by ld us)
[PULSE] Mesh time: 4331801796 µs (4331801 ms)
SYNCED ✓
[PULSE] Mesh time: 4332801796 µs (4332801 ms)
SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by ld us)
[PULSE] Mesh time: 4333801796 µs (4333801 ms)
SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by ld us)
[PULSE] Mesh time: 4334801796 µs (4334801 ms)
SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by ld us)
[PULSE] Mesh time: 4335801796 µs (4335801 ms)
SYNCED ✓

Everything seems to be working in the output but the LEDs are not syncing correctly (not even close) even though when i look at the serial output, the clocks do seem to be synced at least within a second of each other.

the lu and ld in the output is just a case of some printf format not supported by the implementation of printf in my platform, here's my platformio config:

[env:upesy_wroom]
lib_deps =
    https://github.com/Hemisphere-Project/ESPNowMeshClock.git
platform = espressif32
framework = arduino
board = upesy_wroom
monitor_speed = 115200

Do you know what could cause this? any debugging advice is appreciated.
@Maigre

[Maigre]

that's weird, could you send your full test code ?

also i pushed an update with enhanced logging to fix the implementation issue of printf on your platform.
You should now see proper [MeshClock SYNC] No adjustment (remote behind by xxxx us) messages, which should help confirm that devices are in sync..

[Maigre]

also are you sure you are using meshClock.meshMillis(); and not millis(); to on/off the LEDs ?
millis(); is the local clock and is not synced.
meshClock.meshMillis(); is the shared clock synced with others.

once you are there, you can use meshClock.meshMicros(); if you need sub-millisecond accuracy.

[robinpdev]

Thanks for the help, i updated using pio pkg update and reuploaded

Output:

=== ESPNowMeshClock Basic Example ===
Starting mesh clock synchronization...
Sync LED on GPIO 2

[ESPNowMeshClock] Initializing timer...
[ESPNowMeshClock] Chip: ESP32-D0WD-V3
[ESPNowMeshClock] CPU Freq: 240 MHz
[ESPNowMeshClock] Timer test: 4278289493 -> 4278290496 (diff: 1003 us)
[ESPNowMeshClock] Started.
[PULSE] Mesh time: lu µs (4278363969 ms) - State: ALONE
[MeshClock SYNC] Direct set forward. Offset: 395786820 us, Delta: 395786820 us
>>> State Change: SYNCED - Successfully synchronized with mesh!
[PULSE] Mesh time: lu µs (379523230 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786842 us, Step: 22 us, Delta: 89 us
[PULSE] Mesh time: lu µs (380523018 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786867 us, Step: 25 us, Delta: 102 us
[PULSE] Mesh time: lu µs (381523065 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786878 us, Step: 11 us, Delta: 44 us
[PULSE] Mesh time: lu µs (382523076 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786891 us, Step: 13 us, Delta: 52 us
[PULSE] Mesh time: lu µs (383523089 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786898 us, Step: 7 us, Delta: 29 us
[PULSE] Mesh time: lu µs (384523096 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786901 us, Step: 3 us, Delta: 13 us
[PULSE] Mesh time: lu µs (385523099 ms) - State: SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by 2853 us)
[PULSE] Mesh time: lu µs (386523099 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786907 us, Step: 6 us, Delta: 27 us
[PULSE] Mesh time: lu µs (387523105 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786907 us, Step: 0 us, Delta: 3 us
[PULSE] Mesh time: lu µs (388523105 ms) - State: SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by 2 us)
[PULSE] Mesh time: lu µs (389523105 ms) - State: SYNCED ✓
[MeshClock SYNC] Slewed forward. Offset: 395786946 us, Step: 39 us, Delta: 157 us
[PULSE] Mesh time: lu µs (390523144 ms) - State: SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by 45 us)
[PULSE] Mesh time: lu µs (391523144 ms) - State: SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by 27 us)
[PULSE] Mesh time: lu µs (392523144 ms) - State: SYNCED ✓
[MeshClock SYNC] No adjustment (remote behind by 46 us)
[PULSE] Mesh time: lu µs (393523144 ms) - State: SYNCED ✓

The code (the basic example in this repo):

/*
 * ESPNowMeshClock - Basic Sync Example
 * 
 * This example demonstrates the basic usage of the ESPNowMeshClock library.
 * It shows how to:
 * - Initialize the mesh clock
 * - Monitor synchronization state
 * - Use mesh-synchronized time for coordinated actions
 * - Validate sync accuracy with LED pulses (visual or oscilloscope)
 * 
 * Upload this sketch to multiple ESP32 boards and watch them synchronize!
 * The LED will pulse for 100ms every second in perfect sync across all nodes.
 */

#include <ESPNowMeshClock.h>

// Pin configuration - adjust for your board
#define SYNC_LED_PIN 2  // GPIO2 (built-in LED on most ESP32 boards)

// Create mesh clock with default settings:
// - 1000ms broadcast interval (±10% random variation)
// - 0.25 slew rate for smooth adjustments
// - 10ms large step threshold
// - 5000ms sync timeout
ESPNowMeshClock meshClock;

void setup() {
    Serial.begin(115200);
    delay(1000);
    
    // Configure LED pin
    pinMode(SYNC_LED_PIN, OUTPUT);
    digitalWrite(SYNC_LED_PIN, LOW);
    
    Serial.println("\n=== ESPNowMeshClock Basic Example ===");
    Serial.println("Starting mesh clock synchronization...");
    Serial.printf("Sync LED on GPIO %d\n\n", SYNC_LED_PIN);
    
    // Initialize the mesh clock
    meshClock.begin();
}

void loop() {
    // IMPORTANT: Call this regularly to handle broadcasts
    meshClock.loop();
    
    // Monitor and display sync state changes
    static SyncState lastState = SyncState::ALONE;
    SyncState currentState = meshClock.getSyncState();
    
    if (currentState != lastState) {
        lastState = currentState;
        
        Serial.print(">>> State Change: ");
        switch(currentState) {
            case SyncState::ALONE:
                Serial.println("ALONE - Waiting for first sync message...");
                break;
            case SyncState::SYNCED:
                Serial.println("SYNCED - Successfully synchronized with mesh!");
                break;
            case SyncState::LOST:
                Serial.println("LOST - No sync messages received recently!");
                break;
        }
    }
    
    // Synchronized LED pulse every second
    // All nodes will pulse their LED at EXACTLY the same time
    // Perfect for visual validation or oscilloscope measurement
    static uint32_t lastPulse = 0;
    uint32_t meshMs = meshClock.meshMillis();
    
    // Check if it's time for a pulse (every 1000ms)
    if (meshMs - lastPulse >= 1000) {
        lastPulse = meshMs;
        
        // HIGH for 100ms - DO THIS FIRST before any Serial.print
        digitalWrite(SYNC_LED_PIN, HIGH);
        uint64_t meshUs = meshClock.meshMicros();  // Capture precise time
        delayMicroseconds(100000);  // 100ms = 100,000µs
        digitalWrite(SYNC_LED_PIN, LOW);
        
        // Now safe to print (after pin changes to preserve timing accuracy)
        Serial.printf("[PULSE] Mesh time: %llu µs (%u ms) - State: ", 
                      meshUs, meshMs);
        
        switch(currentState) {
            case SyncState::ALONE:
                Serial.println("ALONE");
                break;
            case SyncState::SYNCED:
                Serial.println("SYNCED ✓");
                break;
            case SyncState::LOST:
                Serial.println("LOST ⚠");
                break;
        }
    }
    
    delay(10);
}

platform.io remains unchanged, the leds stay unsynced

[robinpdev]

Nevermind, turns out the example code was the problem. If you read through it, it doesn't actually use the synced time value to schedule the next LED blink in sync with the other nodes, it just uses it as you would use the normal millis() method.

This is the fixed code:

/*
 * ESPNowMeshClock - Basic Sync Example
 * 
 * This example demonstrates the basic usage of the ESPNowMeshClock library.
 * It shows how to:
 * - Initialize the mesh clock
 * - Monitor synchronization state
 * - Use mesh-synchronized time for coordinated actions
 * - Validate sync accuracy with LED pulses (visual or oscilloscope)
 * 
 * Upload this sketch to multiple ESP32 boards and watch them synchronize!
 * The LED will pulse for 100ms every second in perfect sync across all nodes.
 */

#include <ESPNowMeshClock.h>

// Pin configuration - adjust for your board
#define SYNC_LED_PIN 2  // GPIO2 (built-in LED on most ESP32 boards)

// Create mesh clock with default settings:
// - 1000ms broadcast interval (±10% random variation)
// - 0.25 slew rate for smooth adjustments
// - 10ms large step threshold
// - 5000ms sync timeout
ESPNowMeshClock meshClock;

uint32_t nextPulse = 0;

void setup() {
    Serial.begin(115200);
    delay(1000);
    
    // Configure LED pin
    pinMode(SYNC_LED_PIN, OUTPUT);
    digitalWrite(SYNC_LED_PIN, LOW);
    
    Serial.println("\n=== ESPNowMeshClock Basic Example ===");
    Serial.println("Starting mesh clock synchronization...");
    Serial.printf("Sync LED on GPIO %d\n\n", SYNC_LED_PIN);
    
    // Initialize the mesh clock
    meshClock.begin();
}

void loop() {
    // IMPORTANT: Call this regularly to handle broadcasts
    meshClock.loop();
    
    // Monitor and display sync state changes
    static SyncState lastState = SyncState::ALONE;
    SyncState currentState = meshClock.getSyncState();
    
    if (currentState != lastState) {
        lastState = currentState;
        
        Serial.print(">>> State Change: ");
        switch(currentState) {
            case SyncState::ALONE:
                Serial.println("ALONE - Waiting for first sync message...");
                break;
            case SyncState::SYNCED:
                Serial.println("SYNCED - Successfully synchronized with mesh!");
                break;
            case SyncState::LOST:
                Serial.println("LOST - No sync messages received recently!");
                break;
        }
    }
    
    // Synchronized LED pulse every second
    // All nodes will pulse their LED at EXACTLY the same time
    // Perfect for visual validation or oscilloscope measurement
    uint32_t meshMs = meshClock.meshMillis();
    long offset = (long)meshMs - (long)nextPulse;
    
    // Check if it's time for a pulse (every 1000ms)
    if (offset >= 0) {
        
        // HIGH for 100ms - DO THIS FIRST before any Serial.print
        digitalWrite(SYNC_LED_PIN, HIGH);
        uint64_t meshUs = meshClock.meshMicros();  // Capture precise time
        delay(100);  // 10ms = 100,000µs
        digitalWrite(SYNC_LED_PIN, LOW);
        
        // Now safe to print (after pin changes to preserve timing accuracy)
        Serial.printf("[PULSE] Mesh time: %llu µs (%llu ms) - State: ", 
                      meshUs, meshUs / 1000);
                      
        switch(currentState) {
            case SyncState::ALONE:
            Serial.println("ALONE");
            break;
            case SyncState::SYNCED:
            Serial.println("SYNCED ✓");
            break;
            case SyncState::LOST:
            Serial.println("LOST ⚠");
            break;
        }
        nextPulse = meshMs - (meshMs % 1000) + 1000;  // Schedule next pulse
    }
    
    delay(1);
}

It's still not perfect but it works, i'll probably submit a PR once i learn how to get the best accuracy out of this library.
Glad that it does work!