Final Project
Process

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

const char* ssid     = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

const char* mqtt_server       = "broker.hivemq.com";
const char* topic_eco2        = "nicole/monitor/eco2";
const char* topic_tvoc        = "nicole/monitor/tvoc";
const char* topic_temperature = "nicole/monitor/temperatura";
const char* topic_humidity    = "nicole/monitor/humedad";

// API de calidad del aire exterior (Puebla)
const char* owm_api_key = "YOUR_API_KEY";
const float LAT =  19.0414;
const float LON = -98.2063;

#define SERVO_PIN     D0
#define NEOPIXEL_PIN  D1
#define BUTTON_PIN    D2

#define ANGLE_OPEN    0
#define ANGLE_MEDIUM  80
#define ANGLE_CLOSED  120
#define STEP_DELAY_MS 12

#define NUM_PIXELS      1
#define BRIGHTNESS      60
#define BLINK_INTERVAL  400

// umbrales de calidad segun eCO2
#define ECO2_GOOD    600
#define ECO2_MEDIUM  1000

#define COLOR_YELLOW_WARM Adafruit_NeoPixel::Color(255, 160, 0)
#define COLOR_GREEN       Adafruit_NeoPixel::Color(  0, 200, 0)
#define COLOR_ORANGE      Adafruit_NeoPixel::Color(255, 140, 0)
#define COLOR_RED         Adafruit_NeoPixel::Color(180,   0, 0)

enum AirQuality { AIR_GOOD, AIR_MEDIUM, AIR_BAD, AIR_UNKNOWN };

WiFiClient        espClient;
PubSubClient      mqttClient(espClient);
ScioSense_ENS160  ens160(0x53);
Adafruit_AHTX0    aht21;
Servo             myServo;
Adafruit_NeoPixel pixel(NUM_PIXELS, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);

AirQuality lastLocalQuality  = AIR_UNKNOWN;
AirQuality outdoorAirQuality = AIR_UNKNOWN;
int        currentAngle      = ANGLE_OPEN;

// boton
bool          actionPending   = false;
bool          buttonLedActive = false;
int           lastRawReading  = HIGH;
bool          stableState     = HIGH;
unsigned long lastBounceTime  = 0;
const unsigned long DEBOUNCE_MS = 50;

// parpadeo para calidad media
bool          blinkOn     = false;
unsigned long lastBlinkMs = 0;

unsigned long lastSensorMs = 0;
unsigned long lastApiMs    = 0;
const unsigned long SENSOR_INTERVAL_MS =  2000;
const unsigned long API_INTERVAL_MS    = 60000;

void       setup_wifi();
void       reconnect_mqtt();
void       readAndPublish();
AirQuality classifyAir(uint16_t eco2);
void       applyQuality(AirQuality q);
void       updateLED();
void       moveServoSmooth(int from, int to);
void       checkButton();
void       fetchOutdoorAQI();
AirQuality parseAQI(int aqi);

void setup() {
  Serial.begin(115200);
  delay(1000);

  pinMode(BUTTON_PIN, INPUT_PULLUP);

  pixel.begin();
  pixel.setBrightness(BRIGHTNESS);
  pixel.clear();
  pixel.show();

  myServo.setPeriodHertz(50);
  myServo.attach(SERVO_PIN, 500, 2400);
  myServo.write(ANGLE_OPEN);
  currentAngle = ANGLE_OPEN;
  delay(800);

  Wire.begin(D4, D5);
  if (!aht21.begin()) {
    Serial.println("Error: AHT21 no encontrado");
    while (1) delay(500);
  }
  if (!ens160.begin()) {
    Serial.println("Error: ENS160 no encontrado");
    while (1) delay(500);
  }
  ens160.setMode(ENS160_OPMODE_STD);

  setup_wifi();
  mqttClient.setServer(mqtt_server, 1883);
  fetchOutdoorAQI();

  Serial.println("Sistema listo");
}

void loop() {
  if (!mqttClient.connected()) reconnect_mqtt();
  mqttClient.loop();

  checkButton();
  if (actionPending) {
    actionPending   = false;
    buttonLedActive = !buttonLedActive;

    if (buttonLedActive) {
      pixel.setPixelColor(0, COLOR_YELLOW_WARM);
      pixel.show();
    } else {
      updateLED();
    }
  }

  // parpadeo naranja cuando el aire es regular
  if (!buttonLedActive && lastLocalQuality == AIR_MEDIUM) {
    if (millis() - lastBlinkMs >= BLINK_INTERVAL) {
      lastBlinkMs = millis();
      blinkOn     = !blinkOn;
      pixel.setPixelColor(0, blinkOn ? COLOR_ORANGE : 0);
      pixel.show();
    }
  }

  if (millis() - lastSensorMs >= SENSOR_INTERVAL_MS) {
    lastSensorMs = millis();
    readAndPublish();
  }

  if (millis() - lastApiMs >= API_INTERVAL_MS) {
    lastApiMs = millis();
    fetchOutdoorAQI();
  }
}

void setup_wifi() {
  Serial.print("Conectando a WiFi");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi conectado: " + WiFi.localIP().toString());
}

void reconnect_mqtt() {
  while (!mqttClient.connected()) {
    Serial.print("Conectando MQTT...");
    String id = "XIAO_C6_Nicole_" + String(random(0xffff), HEX);
    if (mqttClient.connect(id.c_str())) {
      Serial.println(" listo");
    } else {
      Serial.print(" fallo rc=");
      Serial.print(mqttClient.state());
      Serial.println(", reintentando en 3s");
      delay(3000);
    }
  }
}

void readAndPublish() {
  sensors_event_t evtHum, evtTemp;
  aht21.getEvent(&evtHum, &evtTemp);

  float temperature = evtTemp.temperature;
  float humidity    = evtHum.relative_humidity;

  ens160.set_envdata210(
    (uint16_t)((temperature + 273.15f) * 64.0f),
    (uint16_t)(humidity * 512.0f)
  );

  if (!ens160.measure(true)) {
    Serial.println("ENS160 esperando lectura...");
    return;
  }

  uint16_t eco2 = ens160.geteCO2();
  uint16_t tvoc = ens160.getTVOC();

  Serial.printf("Temp: %.1f°C  Hum: %.1f%%  eCO2: %u ppm  TVOC: %u ppb\n",
                temperature, humidity, eco2, tvoc);

  char buf[12];
  sprintf(buf, "%u",   eco2);        mqttClient.publish(topic_eco2,        buf);
  sprintf(buf, "%u",   tvoc);        mqttClient.publish(topic_tvoc,        buf);
  sprintf(buf, "%.1f", temperature); mqttClient.publish(topic_temperature, buf);
  sprintf(buf, "%.1f", humidity);    mqttClient.publish(topic_humidity,    buf);

  AirQuality q = classifyAir(eco2);
  if (q != lastLocalQuality) {
    applyQuality(q);
    lastLocalQuality = q;
  }
}

AirQuality classifyAir(uint16_t eco2) {
  if (eco2 < ECO2_GOOD)   return AIR_GOOD;
  if (eco2 < ECO2_MEDIUM) return AIR_MEDIUM;
  return AIR_BAD;
}

void applyQuality(AirQuality q) {
  int targetAngle;

  switch (q) {
    case AIR_GOOD:
      targetAngle = ANGLE_OPEN;
      Serial.println("Aire bueno, flor abierta");
      break;
    case AIR_MEDIUM:
      targetAngle = ANGLE_MEDIUM;
      blinkOn     = true;
      lastBlinkMs = millis();
      Serial.println("Aire regular, flor a mitad");
      break;
    case AIR_BAD:
    default:
      targetAngle = ANGLE_CLOSED;
      Serial.println("Aire malo, flor cerrada");
      break;
  }

  moveServoSmooth(currentAngle, targetAngle);
  if (!buttonLedActive) updateLED();
}

void updateLED() {
  switch (lastLocalQuality) {
    case AIR_GOOD:
      pixel.setPixelColor(0, 0);
      pixel.show();
      break;
    case AIR_MEDIUM:
      pixel.setPixelColor(0, COLOR_ORANGE);
      pixel.show();
      break;
    case AIR_BAD: {
      // color segun calidad exterior que devuelve la API
      uint32_t color;
      switch (outdoorAirQuality) {
        case AIR_GOOD:   color = COLOR_GREEN;  break;
        case AIR_MEDIUM: color = COLOR_ORANGE; break;
        default:         color = COLOR_RED;    break;
      }
      pixel.setPixelColor(0, color);
      pixel.show();
      break;
    }
    default:
      pixel.setPixelColor(0, 0);
      pixel.show();
      break;
  }
}

void moveServoSmooth(int from, int to) {
  to = constrain(to, ANGLE_OPEN, ANGLE_CLOSED);
  int step = (to > from) ? 1 : -1;
  for (int angle = from; angle != to; angle += step) {
    myServo.write(angle);
    currentAngle = angle;
    delay(STEP_DELAY_MS);
  }
  myServo.write(to);
  currentAngle = to;
}

void checkButton() {
  int reading = digitalRead(BUTTON_PIN);
  if (reading != lastRawReading) {
    lastBounceTime = millis();
    lastRawReading = reading;
  }
  if ((millis() - lastBounceTime) > DEBOUNCE_MS) {
    bool newStable = (bool)reading;
    if (newStable != stableState) {
      stableState = newStable;
      if (stableState == LOW) actionPending = true;
    }
  }
}

void fetchOutdoorAQI() {
  if (WiFi.status() != WL_CONNECTED) return;

  char url[180];
  snprintf(url, sizeof(url),
    "http://api.openweathermap.org/data/2.5/air_pollution?lat=%.4f&lon=%.4f&appid=%s",
    LAT, LON, owm_api_key);

  HTTPClient http;
  http.begin(url);
  int code = http.GET();

  if (code == 200) {
    String payload = http.getString();
    int idx = payload.indexOf("\"aqi\":");
    if (idx != -1) {
      int aqi = payload.charAt(idx + 6) - '0';
      outdoorAirQuality = parseAQI(aqi);
      Serial.printf("AQI exterior: %d\n", aqi);
      if (lastLocalQuality == AIR_BAD && !buttonLedActive) updateLED();
    }
  } else {
    Serial.printf("Error al obtener AQI: HTTP %d\n", code);
  }
  http.end();
}

AirQuality parseAQI(int aqi) {
  if (aqi <= 2) return AIR_GOOD;
  if (aqi == 3) return AIR_MEDIUM;
  return AIR_BAD;
}