Projeto Fases da Lua

Projeto Fases da Lua

O projeto Fases da Lua nasceu da ideia de unir luminária, tecnologia e paixão por astronomia. Ele consiste em uma Lua inteligente capaz de exibir suas fases mesmo em dias nublados.

A Lua foi projetada como um quadro plano. Quando desligada, não chama atenção. Ao ser ligada, a iluminação interna atravessa camadas impressas em relevo, criando o efeito de crateras e sombras conforme a espessura do material.

Lista de materiais

1x BlackBoard Edge H
1x Cabo USB Micro-B
1x Mini Protoboard (170 pontos)
Jumpers Macho-Macho pacote com 40 unidades
Fita de LED endereçável WS2812 5050 ? 1 m
Utilizados 39 LEDs (aprox. 65 cm)
Filamento PLA Cinza Creality

O sistema utiliza conexão Wi-Fi para determinar a fase real da Lua.

Ao ligar:
- Pisca verde: conexão Wi-Fi bem-sucedida
- Pisca vermelho continuamente: erro de conexão

Após a conexão:
- Executa todas as fases da Lua
- Realiza testes RGB
- Determina a fase real com base na localização
- Atualiza automaticamente a cada 3 horas

Existe um botão físico para testes rápidos e demonstração do projeto.

Impressão 3D

O projeto utiliza duas peças impressas em 3D: a caixa frontal com a Lua e a tampa traseira.

Use o botão abaixo para fazer o download dos arquivos STL (compactados em 7-Zip).

Arquivos STL (7z)

A Lua foi criada por meio de litofania, utilizando imagem de alta resolução convertida no site itslitho.com. O relevo negativo permite que apenas áreas específicas sejam iluminadas.

Configurações de impressão:
- Altura de camada: 0,16 mm
- Preenchimento: 100%

A montagem é dividida em corpo e tampa. Uma folha de papel sulfite posicionada internamente atua como difusor de luz.

Circuito

Quando você for prender a fita de LED no anel atrás da lua, faça isso no sentido anti-horário. Para realizar este projeto, montamos um circuito conforme o esquema abaixo.

Código

O código abaixo foi desenvolvido especificamente para este projeto. Dependendo da sua aplicação, pode ser necessário realizar adaptações.


/* ============================================================
   Projeto002 LUA -  (Wi-Fi + Cidade + USNO + WS2812 + Botão)
   ------------------------------------------------------------
   Mantém tudo que já funcionou:
     - Wi-Fi OK/FAIL com piscas
     - WS2812 no GPIO13
     - Botão no GPIO14 (segurar 2s => teste 2 rodadas)
     - Fases em branco + fade
     - Modo cores ao final do teste

   CORREÇÃO NOVA:
     - A fase da lua NÃO é mais "aproximada".
     - Agora é fase REAL via Internet:
         Cidade -> (Nominatim) lat/lon -> (USNO) curphase

   Autor: Robocore - Casemonstro
   ============================================================ */

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
#include <time.h>
#include <Adafruit_NeoPixel.h>


/* =========================
   1) CONFIGURAÇÃO DO USUÁRIO
========================= */
const char* WIFI_SSID = "Sua_REDE_Wifi";
const char* WIFI_PASS = "Sua_Senha";

// Escreva bem específico: "São Paulo, SP, Brasil"
String CITY_NAME = "São Paulo, SP, Brasil";

// Fuso Brasil UTC-3 e sem DST
const int TZ = -3;
const bool DST = false;

/* =========================
   2) PINOS / HARDWARE
========================= */
#define PIN_LED_DATA  13
#define PIN_BTN       14
#define NUM_LEDS      39

Adafruit_NeoPixel strip(NUM_LEDS, PIN_LED_DATA, NEO_GRB + NEO_KHZ800);

/* =========================
   3) TEMPOS / BRILHOS
========================= */
const uint8_t BRILHO_GLOBAL = 100; // se alimentar os LEDs por USB, use 40~80

// Intensidade em branco por fase
const uint8_t W_NOVA  = 8;     // halo bem fraco
const uint8_t W_MEIA  = 140;   // crescente/minguante
const uint8_t W_CHEIA = 255;   // cheia

// Wi-Fi/NTP
const unsigned long WIFI_TIMEOUT_MS = 12000;
const unsigned long NTP_TIMEOUT_MS  = 12000;

// Botão
const unsigned long HOLD_TEST_MS = 2000;

// Teste
const unsigned long TEMPO_FASE_MS = 5000;

// Fade
const int FADE_STEPS = 25;
const unsigned long FADE_STEP_DELAY_MS = 20; // 25*20ms = 500ms

// Atualização do modo real (reconsulta USNO)
// Correção: a cada 3 horas
const unsigned long REAL_UPDATE_MS = 3UL * 60UL * 60UL * 1000UL; // 3h

/* =========================
   4) ESTADOS
========================= */
enum Phase4 { LUA_NOVA = 0, LUA_CRESCENTE = 1, LUA_CHEIA = 2, LUA_MINGUANTE = 3 };

Phase4 faseAtual = LUA_NOVA;
bool wifiOK = false;
unsigned long lastRealUpdateAt = 0;

// Botão
bool btnPrev = HIGH;
unsigned long btnPressedAt = 0;
bool holdTriggered = false;

// Geocoding cache
bool haveCoords = false;
double cachedLat = 0.0, cachedLon = 0.0;

/* ============================================================
   5) FUNÇÕES BÁSICAS (LED)
   ============================================================ */
void apagarTudo() { strip.clear(); strip.show(); }

void ligarTodosRGB(uint8_t r, uint8_t g, uint8_t b) {
  for (int i = 0; i < NUM_LEDS; i++) strip.setPixelColor(i, strip.Color(r, g, b));
  strip.show();
}

// Desenha a fase em branco (com scale para fade)
void desenharFase(Phase4 fase, uint8_t scale) {
  strip.clear();

  uint8_t base = 0;
  if (fase == LUA_NOVA) base = W_NOVA;
  else if (fase == LUA_CHEIA) base = W_CHEIA;
  else base = W_MEIA;

  uint8_t w = (uint8_t)((uint16_t)base * scale / 255);

  if (fase == LUA_NOVA || fase == LUA_CHEIA) {
    for (int i = 0; i < NUM_LEDS; i++) strip.setPixelColor(i, strip.Color(w, w, w));
  } else if (fase == LUA_CRESCENTE) {
    // Metade ESQUERDA: 20..38 (como nos seus testes)
    for (int i = 20; i < NUM_LEDS; i++) strip.setPixelColor(i, strip.Color(w, w, w));
  } else { // LUA_MINGUANTE
    // Metade DIREITA: 0..19
    for (int i = 0; i <= 19; i++) strip.setPixelColor(i, strip.Color(w, w, w));
  }

  strip.show();
}

// Fade simples entre fases
void transicaoFade(Phase4 next) {
  // Fade OUT fase atual
  for (int s = FADE_STEPS; s >= 0; s--) {
    uint8_t scale = (uint8_t)(255UL * s / FADE_STEPS);
    desenharFase(faseAtual, scale);
    delay(FADE_STEP_DELAY_MS);
    yield();
  }
  // Fade IN nova fase
  for (int s = 0; s <= FADE_STEPS; s++) {
    uint8_t scale = (uint8_t)(255UL * s / FADE_STEPS);
    desenharFase(next, scale);
    delay(FADE_STEP_DELAY_MS);
    yield();
  }
  faseAtual = next;
}

void piscarCheiaCor2x(uint8_t r, uint8_t g, uint8_t b, const char* msg) {
  Serial.println(msg);
  for (int i = 0; i < 2; i++) {
    ligarTodosRGB(r, g, b);
    delay(250);
    apagarTudo();
    delay(250);
    yield();
  }
}

/* ============================================================
   6) Wi-Fi + NTP (com yield para evitar watchdog)
   ============================================================ */
bool conectarWiFi() {
  Serial.println("[WIFI] Conectando...");
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);

  unsigned long start = millis();
  while (WiFi.status() != WL_CONNECTED && (millis() - start) < WIFI_TIMEOUT_MS) {
    delay(150);
    yield();
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.print("[WIFI] OK. IP: ");
    Serial.println(WiFi.localIP());
    return true;
  }

  Serial.println("[WIFI] FAIL (timeout).");
  return false;
}

bool sincronizarNTP() {
  Serial.println("[NTP] Sincronizando...");
  configTime(TZ * 3600, 0, "pool.ntp.org", "time.google.com", "a.st1.ntp.br");

  unsigned long start = millis();
  while ((millis() - start) < NTP_TIMEOUT_MS) {
    time_t now = time(nullptr);
    if (now > 100000) {
      struct tm t;
      localtime_r(&now, &t);
      Serial.printf("[NTP] OK: %02d/%02d/%04d %02d:%02d:%02d\n",
                    t.tm_mday, t.tm_mon + 1, t.tm_year + 1900,
                    t.tm_hour, t.tm_min, t.tm_sec);
      return true;
    }
    delay(250);
    yield();
  }

  Serial.println("[NTP] FAIL (sem hora válida).");
  return false;
}

/* ============================================================
   7) CIDADE -> lat/lon (Nominatim)
   ============================================================ */
String urlEncode(const String& s) {
  String out;
  const char *hex = "0123456789ABCDEF";
  for (size_t i = 0; i < s.length(); i++) {
    char c = s[i];
    if (isalnum((unsigned char)c) || c == '-' || c == '_' || c == '.' || c == '~') out += c;
    else if (c == ' ') out += "%20";
    else {
      out += '%';
      out += hex[(c >> 4) & 0xF];
      out += hex[c & 0xF];
    }
  }
  return out;
}

// Parse simples: pega o primeiro "lat":"..." e "lon":"..."
String jsonGetString(const String& json, const char* key) {
  String pat = String("\"") + key + "\":";
  int p = json.indexOf(pat);
  if (p < 0) return "";
  int a = json.indexOf('"', p + pat.length());
  if (a < 0) return "";
  int b = json.indexOf('"', a + 1);
  if (b < 0) return "";
  return json.substring(a + 1, b);
}

bool geocodeCityNominatim(const String& city, double &lat, double &lon) {
  WiFiClientSecure client;
  client.setInsecure();

  String url = "https://nominatim.openstreetmap.org/search?format=json&limit=1&q=" + urlEncode(city);

  HTTPClient http;
  if (!http.begin(client, url)) return false;

  http.addHeader("User-Agent", "Projeto002-LuaFases/1.0 (ESP32; contato: exemplo@exemplo.com)");

  int code = http.GET();
  if (code != 200) {
    Serial.printf("[GEO] HTTP %d\n", code);
    http.end();
    return false;
  }

  String body = http.getString();
  http.end();

  String latS = jsonGetString(body, "lat");
  String lonS = jsonGetString(body, "lon");
  if (latS.length() == 0 || lonS.length() == 0) return false;

  lat = latS.toDouble();
  lon = lonS.toDouble();
  return true;
}

/* ============================================================
   8) fase real (USNO) via curphase
   ============================================================ */
bool fetchMoonCurphaseUSNO(int year, int month, int day, double lat, double lon, String &curphaseOut) {
  WiFiClientSecure client;
  client.setInsecure();

  String url = "https://aa.usno.navy.mil/api/rstt/oneday?date=";
  url += String(year) + "-" + String(month) + "-" + String(day);
  url += "&coords=" + String(lat, 6) + "," + String(lon, 6);
  url += "&tz=" + String(TZ);
  url += "&dst=" + String(DST ? "true" : "false");

  HTTPClient http;
  if (!http.begin(client, url)) return false;

  int code = http.GET();
  if (code != 200) {
    Serial.printf("[USNO] HTTP %d\n", code);
    http.end();
    return false;
  }

  String body = http.getString();
  http.end();

  String cur = jsonGetString(body, "curphase");
  if (cur.length() == 0) return false;

  curphaseOut = cur;
  return true;
}

Phase4 mapCurphaseTo4(const String& curphase) {
  String s = curphase;
  s.toLowerCase();

  if (s.indexOf("new") >= 0)  return LUA_NOVA;
  if (s.indexOf("full") >= 0) return LUA_CHEIA;
  if (s.indexOf("wax") >= 0)  return LUA_CRESCENTE;
  if (s.indexOf("wan") >= 0)  return LUA_MINGUANTE;

  return LUA_CRESCENTE;
}

/* ============================================================
   9) MODO REAL (fase real via cidade + USNO)
   ============================================================ */
bool updateRealMoonDisplay(bool forceGeocode) {
  if (!wifiOK) return false;

  time_t now = time(nullptr);
  if (now <= 100000) {
    Serial.println("[REAL] Tempo inválido, tentando NTP...");
    if (!sincronizarNTP()) return false;
    now = time(nullptr);
    if (now <= 100000) return false;
  }

  struct tm t;
  localtime_r(&now, &t);
  int year  = t.tm_year + 1900;
  int month = t.tm_mon + 1;
  int day   = t.tm_mday;

  if (!haveCoords || forceGeocode) {
    Serial.printf("[GEO] Convertendo cidade -> coords: %s\n", CITY_NAME.c_str());
    if (!geocodeCityNominatim(CITY_NAME, cachedLat, cachedLon)) {
      Serial.println("[GEO] Falhou. Dica: use 'Cidade, Estado, País'.");
      return false;
    }
    haveCoords = true;
    Serial.printf("[GEO] OK lat=%.6f lon=%.6f\n", cachedLat, cachedLon);
    delay(1100);
  }

  String curphase;
  if (!fetchMoonCurphaseUSNO(year, month, day, cachedLat, cachedLon, curphase)) {
    Serial.println("[USNO] Falhou ao obter curphase.");
    return false;
  }

  Phase4 p = mapCurphaseTo4(curphase);

  Serial.println("------------------------------------------------");
  Serial.printf("[REAL] Data: %02d/%02d/%04d\n", day, month, year);
  Serial.printf("[REAL] USNO curphase: %s\n", curphase.c_str());
  Serial.printf("[REAL] Mapeado p/ 4 fases: %d (0 Nova,1 Crescente,2 Cheia,3 Minguante)\n", (int)p);
  Serial.println("------------------------------------------------");

  if (p != faseAtual) {
    Serial.println("[REAL] Troca com fade...");
    transicaoFade(p);
  } else {
    desenharFase(faseAtual, 255);
  }

  return true;
}

/* ============================================================
   10) BOTÃO (segurar 2s)
   ============================================================ */
bool botaoSegurado2s() {
  bool btnNow = digitalRead(PIN_BTN);

  if (btnPrev == HIGH && btnNow == LOW) {
    btnPressedAt = millis();
    holdTriggered = false;
    Serial.println("[BOTAO] Pressionado (contando 2s)...");
  }

  if (btnNow == LOW && !holdTriggered) {
    if (millis() - btnPressedAt >= HOLD_TEST_MS) {
      holdTriggered = true;
      Serial.println("[BOTAO] OK -> Segurou 2s (iniciar TESTE).");
      btnPrev = btnNow;
      return true;
    }
  }

  btnPrev = btnNow;
  return false;
}

/* ============================================================
   11) MODO TESTE (1 rodada) + CORES FINAL
   ============================================================ */
void modoCoresFinal() {
  Serial.println("[CORES] Verde 3s");
  ligarTodosRGB(0, 255, 0); delay(3000); yield();

  Serial.println("[CORES] Azul 3s");
  ligarTodosRGB(0, 0, 255); delay(3000); yield();

  Serial.println("[CORES] Vermelho 10s");
  ligarTodosRGB(255, 0, 0); delay(10000); yield();

  Serial.println("[CORES] OFF 5s");
  apagarTudo(); delay(5000); yield();
}

void rodarTesteUmaVez() {
  Serial.println("===== TESTE: Nova -> Crescente -> Cheia -> Minguante =====");

  transicaoFade(LUA_NOVA);      delay(TEMPO_FASE_MS); yield();
  transicaoFade(LUA_CRESCENTE); delay(TEMPO_FASE_MS); yield();
  transicaoFade(LUA_CHEIA);     delay(TEMPO_FASE_MS); yield();
  transicaoFade(LUA_MINGUANTE); delay(TEMPO_FASE_MS); yield();

  Serial.println("[TESTE] OFF 3s");
  apagarTudo(); delay(3000); yield();

  modoCoresFinal();
}

/* ============================================================
   12) Wi-Fi FAIL: pisca vermelho para sempre (sem watchdog)
   ============================================================ */
void loopWifiFail() {
  Serial.println("[FATAL] Sem WiFi -> piscando Cheia VERMELHA para sempre.");
  while (true) {
    ligarTodosRGB(255, 0, 0);
    delay(500);
    apagarTudo();
    delay(500);
    yield();
  }
}

/* ============================================================
   SETUP / LOOP
   ============================================================ */
void setup() {
  Serial.begin(115200);
  delay(200);

  pinMode(PIN_BTN, INPUT_PULLUP);

  strip.begin();
  strip.setBrightness(BRILHO_GLOBAL);
  apagarTudo();

  Serial.println("\n=== Projeto002 | FINAL (USNO real) ===");
  Serial.printf("LED DATA GPIO=%d | BOTAO GPIO=%d | LEDS=%d\n", PIN_LED_DATA, PIN_BTN, NUM_LEDS);
  Serial.printf("Cidade: %s\n", CITY_NAME.c_str());

  wifiOK = conectarWiFi();
  if (!wifiOK) {
    piscarCheiaCor2x(255, 0, 0, "[BOOT] WiFi FAIL -> Cheia VERMELHA 2x");
    loopWifiFail();
  }

  piscarCheiaCor2x(0, 255, 0, "[BOOT] WiFi OK -> Cheia VERDE 2x");

  sincronizarNTP();

  faseAtual = LUA_NOVA;
  desenharFase(faseAtual, 255);

  Serial.println("[BOOT] Demonstração: fases (branco) + RGB (3 rodadas)...");
  for (int i = 1; i <= 3; i++) {
    Serial.printf("[BOOT] Rodada %d/3\n", i);
    rodarTesteUmaVez();
  }
  Serial.println("[BOOT] Fim da demonstração -> consultando fase REAL e fixando no estado atual.");

  updateRealMoonDisplay(true);
  lastRealUpdateAt = millis();
}

void loop() {
  if (botaoSegurado2s()) {
    Serial.println("[TESTE] Rodando 2 rodadas...");
    rodarTesteUmaVez();
    rodarTesteUmaVez();

    Serial.println("[TESTE] Fim -> voltando ao REAL (reconsulta USNO).");
    sincronizarNTP();
    updateRealMoonDisplay(false);
    lastRealUpdateAt = millis();
  }

  if (millis() - lastRealUpdateAt >= REAL_UPDATE_MS) {
    Serial.println("[REAL] Atualização periódica (reconsulta USNO)...");
    updateRealMoonDisplay(false);
    lastRealUpdateAt = millis();
  }

  delay(20);
  yield();
}