Arvore de Natal 3D com LEDs

Projeto

Está sem ideia de presente de Natal. A RoboCore pode te ajudar. Bóra fazer!Esse projeto une impressão 3D + Arduino pra transformar criatividade em tecnologia.

View this post on Instagram

A post shared by RoboCore Tecnologia (@robocore)

Lista de materiais

1x BlackBoard UNO R3
1x Protoboard 400 Pontos
1x Jumpers Macho-Macho x40 Unidades
1x Chave Momentânea (PushButton) - Pacote com 10 unidades
11x Resistor 220 Ohm (presente no Kit Resistor 500)
1x Espaguete Termoretrátil - 1 metro (1.00 mm)
1x LED 5mm Vermelho (10 unidades)
1x LED 5mm Amarelo (10 unidades)
1x LED 5mm Verde (10 unidades)
1x LED 5mm Azul (10 unidades)
1x Fio esmaltado

Impressão 3D

Use os botões abaixo para fazer o download da árvore para a impressão 3D.

Arquivo 3MF Arquivo STL

Código

O código abaixo foi desenvolvido para a nossa aplicação, e por isso, dependendo do seu projeto, pode ser que seja necessário algumas adaptações.

/*
  ARVORE DE NATAL 3D + ARDUINO (v2 - com modo "ambiente")
  -------------------------------------------------------
  - 1 botao alterna modos:

      0 = TUDO APAGADO (estado inicial ao ligar)
      1 = AMBIENTE: só a estrela pulsando fraquinha
      2 = Efeito 1 (respirar + pisca alternado)
      3 = Efeito 2 (chase / correndo + flash na estrela)
      4 = Efeito 3 (ondas PWM + pisca digital mais rapido)

  - Estrela em PWM no pino 11
  - Corpo com:
      * LEDs PWM (fade): pinos pwmPins[]
      * LEDs digitais (liga/desliga): pinos digPins[]

  Observacoes:
  - Arduino UNO/Nano PWM: 3,5,6,9,10,11
  - Como a estrela vai no 11, NAO use o 11 em pwmPins[].
  - Botao usando INPUT_PULLUP: solto=HIGH, apertado=LOW.
*/

#include <Arduino.h>

// =======================
// CONFIGURACAO DE PINOS
// =======================

const uint8_t PIN_BTN  = 2;   // botao (um lado no pino 2, outro no GND)
const uint8_t PIN_STAR = 11;  // estrela (PWM)

// LEDs PWM do corpo (fade). IMPORTANTE: NAO incluir o 11 aqui!
const uint8_t pwmPins[] = {3, 5, 6, 9, 10};
const uint8_t PWM_COUNT = sizeof(pwmPins) / sizeof(pwmPins[0]);

// LEDs digitais do corpo (liga/desliga)
const uint8_t digPins[] = {4, 7, 8, 12, 13};
const uint8_t DIG_COUNT = sizeof(digPins) / sizeof(digPins[0]);

// =======================
// ESTADO DO SISTEMA
// =======================

// Agora temos 5 modos: 0..4
uint8_t mode = 0;
const uint8_t MODE_COUNT = 5;

// Debounce do botao
bool lastBtnRead = HIGH;
bool btnStable   = HIGH;
unsigned long lastDebounceMs = 0;
const unsigned long DEBOUNCE_MS = 35;

// =======================
// FUNCOES AUXILIARES
// =======================

// Desliga apenas os LEDs do corpo (PWM + digitais)
void bodyAllOff() {
  for (uint8_t i = 0; i < PWM_COUNT; i++) {
    analogWrite(pwmPins[i], 0);
  }
  for (uint8_t i = 0; i < DIG_COUNT; i++) {
    digitalWrite(digPins[i], LOW);
  }
}

// Desliga TUDO (corpo + estrela)
void allOff() {
  bodyAllOff();
  analogWrite(PIN_STAR, 0);
}

// Estrela em "ambiente": pulsando fraquinha (modo 1)
void starAmbient(unsigned long nowMs) {
  const unsigned long period = 2600; // ms (pulso lento)
  unsigned long t = nowMs % period;

  // onda triangular 0..255..0
  int tri = (t < period / 2)
              ? (int)(t * 255UL / (period / 2))
              : (int)((period - t) * 255UL / (period / 2));

  // brilho fraco: 8..60 (ajuste se quiser)
  int v = 8 + (tri * 52) / 255;
  analogWrite(PIN_STAR, v);
}

// Pisca os LEDs digitais alternando
void digitalBlinkAlternate(unsigned long nowMs, unsigned long speedMs) {
  bool phase = ((nowMs / speedMs) % 2) == 0;
  for (uint8_t i = 0; i < DIG_COUNT; i++) {
    bool on = (i % 2 == 0) ? phase : !phase;
    digitalWrite(digPins[i], on ? HIGH : LOW);
  }
}

// Leitura do botao com debounce
void readButton() {
  bool r = digitalRead(PIN_BTN);

  if (r != lastBtnRead) {
    lastDebounceMs = millis();
    lastBtnRead = r;
  }

  if ((millis() - lastDebounceMs) > DEBOUNCE_MS) {
    if (r != btnStable) {
      btnStable = r;

      if (btnStable == LOW) {
        // vai para o proximo modo
        mode = (mode + 1) % MODE_COUNT;

        // limpa tudo ao trocar de modo para evitar "sobras"
        // (depois cada modo liga o que precisar)
        allOff();
      }
    }
  }
}

// =======================
// EFEITOS
// =======================

void effect1(unsigned long nowMs) {
  const unsigned long period = 2000;
  unsigned long t = nowMs % period;

  int v = (t < period / 2)
            ? (int)(t * 255UL / (period / 2))
            : (int)((period - t) * 255UL / (period / 2));

  // estrela: respira forte, com minimo
  int starVal = 40 + (v * 215) / 255; // 40..255
  analogWrite(PIN_STAR, starVal);

  // PWM corpo: degrade
  for (uint8_t i = 0; i < PWM_COUNT; i++) {
    int vi = v - (int)i * 30;
    if (vi < 0) vi = 0;
    analogWrite(pwmPins[i], vi);
  }

  // digitais piscam alternado
  digitalBlinkAlternate(nowMs, 220);
}

void effect2(unsigned long nowMs) {
  // chase digitais
  for (uint8_t i = 0; i < DIG_COUNT; i++) digitalWrite(digPins[i], LOW);
  uint8_t step = (nowMs / 120) % DIG_COUNT;
  digitalWrite(digPins[step], HIGH);

  // rastro PWM
  uint8_t pstep = (nowMs / 120) % PWM_COUNT;
  for (uint8_t i = 0; i < PWM_COUNT; i++) {
    int dist = (int)i - (int)pstep;
    if (dist < 0) dist = -dist;

    int val = 255 - dist * 90;
    if (val < 0) val = 0;
    analogWrite(pwmPins[i], val);
  }

  // estrela: flash + minimo
  unsigned long tt = nowMs % 1000;
  int sv = (tt < 140) ? (255 - (int)(tt * 255UL / 140)) : 30;
  analogWrite(PIN_STAR, sv);
}

void effect3(unsigned long nowMs) {
  digitalBlinkAlternate(nowMs, 140);

  // estrela pulso lento forte
  const unsigned long sp = 3000;
  unsigned long ts = nowMs % sp;

  int sv = (ts < sp / 2)
             ? (int)(ts * 255UL / (sp / 2))
             : (int)((sp - ts) * 255UL / (sp / 2));

  int starVal = 80 + (sv * 175) / 255;
  analogWrite(PIN_STAR, starVal);

  // PWM corpo ondas defasadas
  const unsigned long p = 1400;
  for (uint8_t i = 0; i < PWM_COUNT; i++) {
    unsigned long t = (nowMs + (unsigned long)i * 180) % p;

    int v = (t < p / 2)
              ? (int)(t * 255UL / (p / 2))
              : (int)((p - t) * 255UL / (p / 2));

    analogWrite(pwmPins[i], v);
  }
}

// =======================
// SETUP / LOOP
// =======================

void setup() {
  pinMode(PIN_BTN, INPUT_PULLUP);

  pinMode(PIN_STAR, OUTPUT);
  for (uint8_t i = 0; i < PWM_COUNT; i++) pinMode(pwmPins[i], OUTPUT);
  for (uint8_t i = 0; i < DIG_COUNT; i++) pinMode(digPins[i], OUTPUT);

  // Estado inicial: TUDO APAGADO
  allOff();
  mode = 0;
}

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

  if (mode == 0) {
    // 0 = tudo apagado
    allOff();
  }
  else if (mode == 1) {
    // 1 = ambiente: só estrela pulsando fraca
    bodyAllOff();
    starAmbient(nowMs);
  }
  else if (mode == 2) {
    effect1(nowMs);
  }
  else if (mode == 3) {
    effect2(nowMs);
  }
  else { // mode == 4
    effect3(nowMs);
  }
}