OpenMicro.ino

/*
 * OpenMicro - Controles fisicos, razonamiento e indicador RGB de estado
 *
 * Hardware:
 *   - Pulsador de dictado normalmente abierto entre D2 y GND.
 *   - Pulsador de envio normalmente abierto entre D3 y GND.
 *   - Pulsadores de tarea anterior/siguiente entre D4/D5 y GND.
 *   - Potenciometro de 10 kohm: extremos a 5V/GND y cursor a A0.
 *   - LED RGB de catodo comun: R-D9, G-D10 y B-D11, cada canal mediante 220 ohm.
 *
 * Protocolo serie a 115200 baudios:
 *   Arduino -> host: BUTTON PRESS/RELEASE, BUTTON 2 PRESS/RELEASE,
 *                     TASK PREVIOUS PRESS/RELEASE y TASK NEXT PRESS/RELEASE.
 *                     REASONING LOW/MEDIUM/HIGH/XHIGH.
 *                     [DEBUG] POT raw=... filtered=... level=... cada 500 ms.
 *   Host -> Arduino: LED OFF, IDLE, WORKING, COMPLETE, NEEDS_INPUT, ERROR,
 *                    DICTATION o FLASH_ACTION (todos con el prefijo "LED ").
 */

#ifndef LED_BUILTIN
#define LED_BUILTIN 13
#endif

constexpr uint8_t BUTTON_PINS[] = {2, 3, 4, 5};
constexpr uint8_t BUTTON_COUNT = sizeof(BUTTON_PINS) / sizeof(BUTTON_PINS[0]);
constexpr uint8_t RGB_RED_PIN = 9;
constexpr uint8_t RGB_GREEN_PIN = 10;
constexpr uint8_t RGB_BLUE_PIN = 11;
constexpr uint8_t REASONING_POT_PIN = A0;
constexpr unsigned long BLINK_INTERVAL_MS = 500;
constexpr unsigned long DEBOUNCE_INTERVAL_MS = 30;
constexpr unsigned long SERIAL_WAIT_MS = 3000;
constexpr unsigned long RGB_UPDATE_INTERVAL_MS = 10;
constexpr unsigned long POT_SAMPLE_INTERVAL_MS = 10;
constexpr unsigned long POT_STARTUP_DELAY_MS = 100;
constexpr unsigned long POT_DIAGNOSTIC_INTERVAL_MS = 500;
constexpr unsigned long WORKING_PULSE_PERIOD_MS = 1600;
constexpr unsigned long ACTION_FLASH_MS = 300;
constexpr uint8_t SERIAL_COMMAND_CAPACITY = 32;
constexpr uint16_t POT_ZONE_WIDTH = 256;
constexpr uint16_t POT_HYSTERESIS = 20;

enum class LedStatus : uint8_t {
  Off,
  Idle,
  Working,
  Complete,
  NeedsInput,
  Error,
  Dictation,
};

enum class ReasoningLevel : uint8_t {
  Low,
  Medium,
  High,
  ExtraHigh,
};

unsigned long lastBlinkMs = 0;
unsigned long lastRgbUpdateMs = 0;
unsigned long lastPotSampleMs = 0;
unsigned long lastPotDiagnosticMs = 0;
unsigned long heartbeatCount = 0;
unsigned long lastButtonChangeMs[BUTTON_COUNT] = {};
unsigned long actionFlashUntilMs = 0;
bool builtinLedState = false;
bool rawButtonStates[BUTTON_COUNT] = {};
bool stableButtonStates[BUTTON_COUNT] = {};
LedStatus ledStatus = LedStatus::Off;
char serialCommand[SERIAL_COMMAND_CAPACITY] = {};
uint8_t serialCommandLength = 0;
bool serialCommandOverflow = false;
uint8_t lastRed = 255;
uint8_t lastGreen = 255;
uint8_t lastBlue = 255;
uint16_t rawPotReading = 0;
uint16_t filteredPotReading = 0;
ReasoningLevel reasoningLevel = ReasoningLevel::Low;
bool reasoningLevelReady = false;

void setRgb(const uint8_t red, const uint8_t green, const uint8_t blue) {
  if (red == lastRed && green == lastGreen && blue == lastBlue) {
    return;
  }

  analogWrite(RGB_RED_PIN, red);
  analogWrite(RGB_GREEN_PIN, green);
  analogWrite(RGB_BLUE_PIN, blue);
  lastRed = red;
  lastGreen = green;
  lastBlue = blue;
}

void updateRgb(const unsigned long nowMs) {
  if (nowMs - lastRgbUpdateMs < RGB_UPDATE_INTERVAL_MS) {
    return;
  }
  lastRgbUpdateMs = nowMs;

  if (static_cast<long>(actionFlashUntilMs - nowMs) > 0) {
    setRgb(0, 220, 0);
    return;
  }

  switch (ledStatus) {
    case LedStatus::Off:
      setRgb(0, 0, 0);
      break;
    case LedStatus::Idle:
      setRgb(72, 72, 72);
      break;
    case LedStatus::Working: {
      const unsigned long phase = nowMs % WORKING_PULSE_PERIOD_MS;
      const unsigned long halfPeriod = WORKING_PULSE_PERIOD_MS / 2;
      const unsigned long ramp = phase < halfPeriod ? phase
                                                    : WORKING_PULSE_PERIOD_MS - phase;
      const uint8_t blue = 12 + (ramp * 168UL) / halfPeriod;
      setRgb(0, 0, blue);
      break;
    }
    case LedStatus::Complete:
      setRgb(0, 160, 0);
      break;
    case LedStatus::NeedsInput:
      setRgb(180, 55, 0);
      break;
    case LedStatus::Error:
      setRgb(180, 0, 0);
      break;
    case LedStatus::Dictation:
      setRgb(0, 0, 180);
      break;
  }
}

void applyLedCommand(const char* command) {
  if (strcmp(command, "LED OFF") == 0) {
    ledStatus = LedStatus::Off;
  } else if (strcmp(command, "LED IDLE") == 0) {
    ledStatus = LedStatus::Idle;
  } else if (strcmp(command, "LED WORKING") == 0) {
    ledStatus = LedStatus::Working;
  } else if (strcmp(command, "LED COMPLETE") == 0) {
    ledStatus = LedStatus::Complete;
  } else if (strcmp(command, "LED NEEDS_INPUT") == 0) {
    ledStatus = LedStatus::NeedsInput;
  } else if (strcmp(command, "LED ERROR") == 0) {
    ledStatus = LedStatus::Error;
  } else if (strcmp(command, "LED DICTATION") == 0) {
    ledStatus = LedStatus::Dictation;
  } else if (strcmp(command, "LED FLASH_ACTION") == 0) {
    actionFlashUntilMs = millis() + ACTION_FLASH_MS;
    return;
  } else {
    return;
  }

  actionFlashUntilMs = 0;
  updateRgb(millis());
}

void readSerialCommands() {
  while (Serial.available() > 0) {
    const char received = static_cast<char>(Serial.read());

    if (received == '\r') {
      continue;
    }
    if (received == '\n') {
      if (!serialCommandOverflow) {
        serialCommand[serialCommandLength] = '\0';
        applyLedCommand(serialCommand);
      }
      serialCommandLength = 0;
      serialCommandOverflow = false;
      continue;
    }
    if (serialCommandOverflow) {
      continue;
    }
    if (serialCommandLength < SERIAL_COMMAND_CAPACITY - 1) {
      serialCommand[serialCommandLength++] = received;
    } else {
      // Descarta una linea demasiado larga sin desbordar el buffer.
      serialCommandLength = 0;
      serialCommandOverflow = true;
    }
  }
}

void updateBuiltinLed() {
  bool anyButtonPressed = false;
  for (uint8_t index = 0; index < BUTTON_COUNT; ++index) {
    anyButtonPressed = anyButtonPressed || stableButtonStates[index] == LOW;
  }
  digitalWrite(LED_BUILTIN, anyButtonPressed || builtinLedState ? HIGH : LOW);
}

void printReasoningLevelName() {
  switch (reasoningLevel) {
    case ReasoningLevel::Low:
      Serial.print(F("LOW"));
      break;
    case ReasoningLevel::Medium:
      Serial.print(F("MEDIUM"));
      break;
    case ReasoningLevel::High:
      Serial.print(F("HIGH"));
      break;
    case ReasoningLevel::ExtraHigh:
      Serial.print(F("XHIGH"));
      break;
  }
}

void printReasoningLevel() {
  Serial.print(F("REASONING "));
  printReasoningLevelName();
  Serial.println();
}

ReasoningLevel reasoningLevelForReading(const uint16_t reading) {
  const uint8_t currentLevel = static_cast<uint8_t>(reasoningLevel);

  if (currentLevel < 3 &&
      reading >= (currentLevel + 1) * POT_ZONE_WIDTH + POT_HYSTERESIS) {
    return static_cast<ReasoningLevel>(currentLevel + 1);
  }
  if (currentLevel > 0 &&
      reading + POT_HYSTERESIS < currentLevel * POT_ZONE_WIDTH) {
    return static_cast<ReasoningLevel>(currentLevel - 1);
  }
  return reasoningLevel;
}

void updateReasoningPot(const unsigned long nowMs) {
  if (nowMs - lastPotSampleMs < POT_SAMPLE_INTERVAL_MS) {
    return;
  }
  lastPotSampleMs = nowMs;

  rawPotReading = analogRead(REASONING_POT_PIN);
  if (!reasoningLevelReady) {
    filteredPotReading = rawPotReading;
    if (nowMs < POT_STARTUP_DELAY_MS) {
      return;
    }
    const uint8_t initialLevel = filteredPotReading / POT_ZONE_WIDTH;
    reasoningLevel = static_cast<ReasoningLevel>(initialLevel > 3 ? 3
                                                                  : initialLevel);
    reasoningLevelReady = true;
    printReasoningLevel();
    return;
  }

  // Filtro IIR: reduce el ruido del ADC sin bloquear botones, RGB ni serie.
  filteredPotReading =
      (filteredPotReading * 7UL + static_cast<unsigned long>(rawPotReading)) /
      8UL;
  const ReasoningLevel nextLevel =
      reasoningLevelForReading(filteredPotReading);
  if (nextLevel != reasoningLevel) {
    reasoningLevel = nextLevel;
    printReasoningLevel();
  }
}

void updatePotDiagnostics(const unsigned long nowMs) {
  if (!reasoningLevelReady ||
      nowMs - lastPotDiagnosticMs < POT_DIAGNOSTIC_INTERVAL_MS) {
    return;
  }
  lastPotDiagnosticMs = nowMs;

  Serial.print(F("[DEBUG] POT raw="));
  Serial.print(rawPotReading);
  Serial.print(F(" filtered="));
  Serial.print(filteredPotReading);
  Serial.print(F(" level="));
  printReasoningLevelName();
  Serial.println();
}

void printButtonEvent(const uint8_t index) {
  if (index == 0) {
    Serial.println(stableButtonStates[index] == LOW ? F("BUTTON PRESS")
                                                    : F("BUTTON RELEASE"));
    return;
  }

  if (index == 1) {
    Serial.println(stableButtonStates[index] == LOW ? F("BUTTON 2 PRESS")
                                                    : F("BUTTON 2 RELEASE"));
    return;
  }

  if (index == 2) {
    Serial.println(stableButtonStates[index] == LOW
                       ? F("TASK PREVIOUS PRESS")
                       : F("TASK PREVIOUS RELEASE"));
    return;
  }

  Serial.println(stableButtonStates[index] == LOW ? F("TASK NEXT PRESS")
                                                  : F("TASK NEXT RELEASE"));
}

void updateButton(const uint8_t index, const unsigned long nowMs) {
  const bool currentButtonState = digitalRead(BUTTON_PINS[index]);

  if (currentButtonState != rawButtonStates[index]) {
    rawButtonStates[index] = currentButtonState;
    lastButtonChangeMs[index] = nowMs;
  }

  if (rawButtonStates[index] != stableButtonStates[index] &&
      nowMs - lastButtonChangeMs[index] >= DEBOUNCE_INTERVAL_MS) {
    stableButtonStates[index] = rawButtonStates[index];
    printButtonEvent(index);
    updateBuiltinLed();
  }
}

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(RGB_RED_PIN, OUTPUT);
  pinMode(RGB_GREEN_PIN, OUTPUT);
  pinMode(RGB_BLUE_PIN, OUTPUT);
  pinMode(REASONING_POT_PIN, INPUT);
  setRgb(0, 0, 0);

  for (uint8_t index = 0; index < BUTTON_COUNT; ++index) {
    pinMode(BUTTON_PINS[index], INPUT_PULLUP);
    rawButtonStates[index] = digitalRead(BUTTON_PINS[index]);
    stableButtonStates[index] = rawButtonStates[index];
  }
  digitalWrite(LED_BUILTIN, LOW);

  Serial.begin(115200);

  const unsigned long serialStartMs = millis();
  while (!Serial && millis() - serialStartMs < SERIAL_WAIT_MS) {
    // Espera limitada.
  }

  Serial.println();
  Serial.println(F("=== OpenMicro controles, razonamiento y estado RGB ==="));
  Serial.print(F("[OK] Arranque completado en "));
  Serial.print(millis());
  Serial.println(F(" ms"));
  Serial.println(F("[OK] Pulsadores D2-D5 con INPUT_PULLUP."));
  Serial.println(F("[OK] Potenciometro de razonamiento en A0."));
  Serial.println(F("[OK] LED RGB: R=D9, G=D10, B=D11, catodo comun a GND."));
  Serial.println(F("[INFO] El RGB permanece apagado hasta conectar el puente."));

  updateBuiltinLed();
}

void loop() {
  const unsigned long nowMs = millis();

  readSerialCommands();
  updateRgb(nowMs);
  updateReasoningPot(nowMs);
  updatePotDiagnostics(nowMs);

  for (uint8_t index = 0; index < BUTTON_COUNT; ++index) {
    updateButton(index, nowMs);
  }

  if (nowMs - lastBlinkMs >= BLINK_INTERVAL_MS) {
    lastBlinkMs = nowMs;
    builtinLedState = !builtinLedState;
    updateBuiltinLed();

    if (!builtinLedState) {
      ++heartbeatCount;
      Serial.print(F("[OK] heartbeat "));
      Serial.print(heartbeatCount);
      Serial.print(F(" | uptime: "));
      Serial.print(nowMs);
      Serial.println(F(" ms"));
    }
  }
}