Projeto da árvore de Natal do Arduino em três pequenas etapas!

Publicado em por
Tempo de leitura: 5 minutes

Crie sua própria bela árvore de LEDs de Natal do Arduino, que toca “Jingle Bells”

O inverno está aqui, está frio e venta, e todos os dias parece um ótimo dia para ficar na cama. Quer você celebre o Hanukkah ou o Natal, a temporada de festas está aqui para nos lembrar de nos reunirmos e iluminar a escuridão.
Hoje vamos fazer exatamente isso – mas com o Arduino.

Ao final deste projeto, você saberá como converter notas musicais para o código Arduino e tocar a campainha, como configurar LEDs em sua forma favorita e como fazê-los piscar de acordo com a música que você está tocando.

As letras miúdas – Para manter as coisas simples, presumo que tenha algum conhecimento em Arduino e familiaridade com o trabalho com LEDs e campainha.

Para este projeto, usei a “Adafruit-feather-32u4-bluefruit-LE”, uma placa compatível com Arduino projetada e fabricada pela Adafruit, mas você pode usar sua placa Arduino favorita como uma ‘Placa Pro Micro Atmega 32u4’

O código-fonte está disponível no GitHub do autor original, vamos examiná-lo parte por parte.

 

Agora, vamos trabalhar!

Etapa #1: Configurando os LEDs e o Buzzer

Mesmo que a árvore de Natal pareça complicada, na verdade ela é baseada neste diagrama simples. Quando você obtiver o básico, poderá adicionar LEDs e certificar-se de que eles estejam conectados corretamente ao GPIO relevante de um lado e ao GND do outro.
O importante é definir o grupo de LEDs que você deseja que pisque e conectá-los ao GPIO relevante.

// Leds
int counter = 0;
int buzzerPin = 9;
int GreenLEDs = 11; 
int RedLEDs_1 = 10;  
int RedLEDs_2 = 12;   
int OrangeLED = 13;                     
     
void buzzer_and_leds_setup()
{
  //Setup pin modes
  pinMode(buzzerPin, OUTPUT);
  pinMode(GreenLEDs, OUTPUT);
  pinMode(RedLEDs_1, OUTPUT);
  pinMode(RedLEDs_2, OUTPUT);
  pinMode(OrangeLED, OUTPUT);
}

 

Em minha árvore, conectei todos os 8 LEDs verdes e o LED amarelo ao GPIO #11. Esses LEDs construíram a própria árvore, e o amarelo representa uma estrela no topo dela.
Eu queria criar dois grupos diferentes de LEDs vermelhos e um LED laranja adicional. Meu código deve ser capaz de piscar os grupos de forma alternada. Para este assunto, eu os separei em GPIOs 10, 12 e 13 de acordo.

A cigarra foi conectada ao pino nº 9, que é um pino PWM.

 

Etapa #2: convertendo notas musicais em código Arduino

A primeira parte do código-fonte “jingle_bells.ino” é uma lista de números constantes, que representam as diferentes notas musicais e, mais especificamente, as frequências da campainha.

A segunda parte do código define duas matrizes correlativas, a primeira contém as notas e a segunda contém a duração de cada nota. Em vez de ter duas matrizes longas, dividi-as em algumas pequenas matrizes, para cada seção da música. Isso me ajudou no processo de depuração e também poderia reutilizá-los quando necessário (veja o uso de “first_notes[] ‘, por exemplo).
Como você pode pegar cada música e tocá-la na campainha? facilmente!
A primeira etapa é preencher a matriz de notas. Certifique-se de que todas as notas de que você precisa estão na faixa da campainha e que as frequências estão definidas no início do código. A segunda etapa é preencher a duração. Observe que a partitura contém essas informações e que as notas são particionadas em grupos de acordo com a duração somada. Você não precisa ser um músico para escrever o código, apenas mantenha as proporções razoáveis ​​:)
A imagem a seguir ajuda a ilustrar o processo de conversão de notas musicais em código.

Como converter notas em código Arduino.
const int c = 261;
const int d = 294;
const int e = 329;
const int f = 349;
const int g = 391;
const int gS = 415;
const int a = 440;
const int aS = 455;
const int b = 466;
const int cH = 523;
const int cSH = 554;
const int dH = 587;
const int dSH = 622;
const int eH = 659;
const int fH = 698;
const int fSH = 740;
const int gH = 784;
const int gSH = 830;
const int aH = 880; 

const unsigned int first_notes[]  = {e, e, e, e, e, e, e, g, c, d, e};
const unsigned int sec_notes[]    = {f, f, f, f, f, e, 
                                     e, e, e, e,
                                     d, d, e, d, g};
const unsigned int third_notes[]  = {f, f, f, f, f, e, e, e, e, g, g, f, d, c };
const unsigned int first_dur[]    = {250, 250, 500, 
                                    250, 250, 500, 
                                    250, 250, 350, 100, 
                                    1000};
const unsigned int sec_dur[]      = {250, 250, 300, 250, 
                                    250, 250, 250, 250, 
                                    250, 250, 250, 250, 
                                    250, 500, 500};
const unsigned int third_dur[]    = {250, 250, 250, 250, 
                                    250, 250, 250, 125, 125, 
                                    250, 250, 250, 250, 
                                    1000 };

 

Etapa #3: Tocando a música e LEDs piscando

void loop()
{
  // Tocar Jingle Bells
  play_song(first_notes, first_dur, sizeof(first_notes)/sizeof(int));
  play_song(sec_notes,   sec_dur,   sizeof(sec_notes)/sizeof(int));
  play_song(first_notes, first_dur, sizeof(first_notes)/sizeof(int));
  play_song(third_notes, third_dur, sizeof(third_notes)/sizeof(int));
  delay(1000);
}

void play_song(int notes[], unsigned int duration[], unsigned int arr_size)
{
  for (int i=0; i<arr_size; i++)
  {
    beep(notes[i], duration[i]);
  }
}

 

Ok, então temos as matrizes de nós e durações, agora tudo o que resta é reproduzi-los e piscar os LEDs.
Na foto, você pode ver como as notas são tocadas uma pela outra. Há uma suposição de que as matrizes têm o mesmo comprimento.

Já definimos quais grupos de LEDs estão conectados aos mesmos GPIOs. mas ainda precisamos decidir em que ordem os piscaríamos e se piscariam juntos ou não.
Eu queria que os LEDs verdes e o LED amarelo estivessem sempre LIGADOS. Eu também queria acender os LEDs em um padrão predefinido, de forma que, no final, todos os LEDs acendessem juntos.
Usei uma operação de módulo dentro da função de bipe (…), a fim de fazer um loop sobre os diferentes grupos de LEDs.

void beep(int note, int duration)
{
  // Tocar tom no b
uzzerPin
  tone(buzzerPin, note, duration);
  digitalWrite(GreenLEDs, HIGH);
  // Toca LEDs diferentes dependendo do valor do 'contador'
  if(counter % 5 == 0)
  {
    digitalWrite(RedLEDs_1, HIGH);
    delay(duration);
    digitalWrite(RedLEDs_1, LOW);
  }
  else if (counter % 5 == 1)
  {
    digitalWrite(RedLEDs_2, HIGH);
    delay(duration);
  }
  else if (counter % 5 == 2)
  {
    digitalWrite(OrangeLED, HIGH);
    delay(duration);
  }
  else if (counter % 5 == 3)
  {
    digitalWrite(RedLEDs_1, HIGH);
    delay(duration);
  }
  else
  {
    delay(duration);
    digitalWrite(OrangeLED, LOW);
    digitalWrite(RedLEDs_2, LOW);
    digitalWrite(RedLEDs_1, LOW);
  }
  
  digitalWrite(GreenLEDs, LOW);
  // Pare o tom no buzzerPin
  noTone(buzzerPin);
  
  // Incrementar contador
  counter++;
}

 

Montamos a árvore, escrevemos o código da campainha, programamos os LEDs, agora está tudo feito! Você pode sentar-se perto da árvore, curtir a música e deixar a luz vencer as trevas!

Material necessário.

Arduino mino pro
ProtoBoard
Resistor 220Ω ou 330Ω (x8)
Led Verde (x8)
Led Vermelho (x)
Led Amarelo (x1)
Led Laranja (x1)
Fios de ligaçãoL

 

Código completo em português (Aqui)

Sua vez!

Referencia: IoT Makers Israel

 

Conclusão

Neste artigo, mostrei como criar um arvore de natal, com som e leds com o Arduino. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônica e de fazer coisas!

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com esse Projeto. Se você tiver alguma dúvida, sugestão ou se achar que falta algo neste tutorial, por favor, deixe um comentário abaixo.

Twittar
Compartilhar
Compartilhar
0 Compart.