Caso práctico: Contador de personas con ESP32

#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

// ---------------------------------------------------------
// Pin Definitions
// ---------------------------------------------------------
#define SENSOR_A_PIN 32 // Outside sensor
#define SENSOR_B_PIN 33 // Inside sensor
#define LED_PIN 2       // Status LED

// ---------------------------------------------------------
// BLE Configuration
// ---------------------------------------------------------
// Generate custom UUIDs using a tool like uuidgenerator.net
#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

BLEServer* pServer = nullptr;
BLECharacteristic* pCharacteristic = nullptr;
bool deviceConnected = false;
bool oldDeviceConnected = false;

// ---------------------------------------------------------
// Application State
// ---------------------------------------------------------
int peopleCount = 0;

enum DirectionState {
    STATE_IDLE,
    STATE_A_BROKEN_FIRST,
    STATE_B_BROKEN_FIRST,
    STATE_WAIT_CLEAR_ENTER,
    STATE_WAIT_CLEAR_EXIT
};

DirectionState currentState = STATE_IDLE;

// ---------------------------------------------------------
// BLE Server Callbacks
// ---------------------------------------------------------
class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
      Serial.println("BLE Client Connected");
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
      Serial.println("BLE Client Disconnected");
    }
};

// ---------------------------------------------------------
// Helper Functions
// ---------------------------------------------------------
void updateBLECount() {
    if (deviceConnected && pCharacteristic != nullptr) {
        // Format the count as a readable string for easy validation
        char countStr[32];
        snprintf(countStr, sizeof(countStr), "Occupancy: %d", peopleCount);
        pCharacteristic->setValue((uint8_t*)countStr, strlen(countStr));
        pCharacteristic->notify();
        Serial.print("BLE Updated: ");
        Serial.println(countStr);
    }
}

void blinkLED() {
    digitalWrite(LED_PIN, HIGH);
    delay(200);
    digitalWrite(LED_PIN, LOW);
}

// ---------------------------------------------------------
// Setup
// ---------------------------------------------------------
void setup() {
    Serial.begin(115200);
    Serial.println("Starting BLE Doorway People Counter...");

    // Initialize Pins
    pinMode(SENSOR_A_PIN, INPUT_PULLUP);
    pinMode(SENSOR_B_PIN, INPUT_PULLUP);
    pinMode(LED_PIN, OUTPUT);
    digitalWrite(LED_PIN, LOW);

    // Initialize BLE
    BLEDevice::init("ESP32_Counter");
    pServer = BLEDevice::createServer();
    pServer->setCallbacks(new MyServerCallbacks());

    BLEService *pService = pServer->createService(SERVICE_UUID);

    // Create Characteristic with Read and Notify properties
    pCharacteristic = pService->createCharacteristic(
                        CHARACTERISTIC_UUID,
                        BLECharacteristic::PROPERTY_READ   |
                        BLECharacteristic::PROPERTY_NOTIFY
                      );

    // Add CCCD descriptor for notifications
    pCharacteristic->addDescriptor(new BLE2902());

    // Set initial value
    char initStr[32];
    snprintf(initStr, sizeof(initStr), "Occupancy: %d", peopleCount);
    pCharacteristic->setValue((uint8_t*)initStr, strlen(initStr));

    pService->start();

    // Start advertising
    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
    pAdvertising->addServiceUUID(SERVICE_UUID);
    pAdvertising->setScanResponse(false);
    pAdvertising->setMinPreferred(0x0);
    BLEDevice::startAdvertising();

    Serial.println("BLE Advertising started. Waiting for connections...");
}

// ---------------------------------------------------------
// Main Loop
// ---------------------------------------------------------
void loop() {
    // Handle BLE disconnection/reconnection gracefully
    if (!deviceConnected && oldDeviceConnected) {
        delay(500); // Give the bluetooth stack the chance to get things ready
        pServer->startAdvertising(); 
        Serial.println("Restarted BLE advertising");
        oldDeviceConnected = deviceConnected;
    }
    if (deviceConnected && !oldDeviceConnected) {
        oldDeviceConnected = deviceConnected;
    }

    // Read sensor states (LOW means the beam is broken)
    bool aBroken = (digitalRead(SENSOR_A_PIN) == LOW);
    bool bBroken = (digitalRead(SENSOR_B_PIN) == LOW);

    // State Machine for Directional Counting
    switch (currentState) {
        case STATE_IDLE:
            if (aBroken && !bBroken) {
                currentState = STATE_A_BROKEN_FIRST;
                Serial.println("State: A Broken (Potential Entry)");
            } else if (bBroken && !aBroken) {
                currentState = STATE_B_BROKEN_FIRST;
                Serial.println("State: B Broken (Potential Exit)");
            }
            break;

        case STATE_A_BROKEN_FIRST:
            // If B breaks while A is or was broken, person is moving forward
            if (bBroken) {
                currentState = STATE_WAIT_CLEAR_ENTER;
                Serial.println("State: B Broken (Completing Entry)");
            } else if (!aBroken && !bBroken) {
                // False alarm, person backed out before breaking B
                currentState = STATE_IDLE;
                Serial.println("State: Idle (False Alarm A)");
            }
            break;

        case STATE_B_BROKEN_FIRST:
            // If A breaks while B is or was broken, person is moving outward
            if (aBroken) {
                currentState = STATE_WAIT_CLEAR_EXIT;
                Serial.println("State: A Broken (Completing Exit)");
            } else if (!aBroken && !bBroken) {
                // False alarm, person backed out before breaking A
                currentState = STATE_IDLE;
                Serial.println("State: Idle (False Alarm B)");
            }
            break;

        case STATE_WAIT_CLEAR_ENTER:
            // Wait for both sensors to clear before counting to avoid multiple counts
            if (!aBroken && !bBroken) {
                peopleCount++;
                Serial.print("Person Entered! Total: ");
                Serial.println(peopleCount);
                updateBLECount();
                blinkLED();
                currentState = STATE_IDLE;
            }
            break;

        case STATE_WAIT_CLEAR_EXIT:
            // Wait for both sensors to clear before counting
            if (!aBroken && !bBroken) {
                if (peopleCount > 0) {
                    peopleCount--;
                }
                Serial.print("Person Exited! Total: ");
                Serial.println(peopleCount);
                updateBLECount();
                blinkLED();
                currentState = STATE_IDLE;
            }
            break;
    }

    // Small delay for debouncing and CPU yield
    delay(20);
}