Arquivos Mensais: julho \18\UTC 2014

Hino Nacional no LCD

No SmartKit do Garagino Rev 1, do Laboratório de Garagem, vinha um programa de exemplo que tocava o Hino Nacional… Com meus recém adquiridos conhecimentos sobre a biblioteca LCD do Arduino e os desde sempre escassos sobre teoria musical, implementei isso aí que dá pra ver: as notinhas aparecendo conforme toca huehue até os pontos de aumento 😀

O código ficou uma bagunça, porque fui colocando tudo fora de ordem kkk (atentar para as ligações do LCD, que mudei pq estava trabalhando em outro projeto ao msm tempo, usando um módulo receptor de RF…):

#include “pitches.h”
#include <LiquidCrystal.h> //Inclui a biblioteca do LCD
#define NO_SOUND 0

LiquidCrystal lcd(12, 10, 5, 4, 3, 7); //Configura os pinos do Arduino para se comunicar com o LCD

byte semicolcheia[8] = {
B00010,
B00011,
B00010,
B00011,
B01110,
B11110,
B01100,
};

byte colcheia[8] = {
B00010,
B00011,
B00010,
B00010,
B01110,
B11110,
B01100,
};

byte seminima[8] = {
B00010,
B00010,
B00010,
B00010,
B01110,
B11110,
B01100,
};

byte minima[8] = {
B00010,
B00010,
B00010,
B00010,
B01110,
B10010,
B01100,
};

// Notas que devem ser tocadas ordenadamente;
int melodia[] = {
NOTE_C4,
NOTE_F4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_A4,NOTE_G4,NOTE_A4,NOTE_AS4,
NOTE_B4,NOTE_C5,NOTE_F4,NOTE_C4,
NOTE_F4,NOTE_E4,NOTE_G4,NOTE_F4,NOTE_A4,NOTE_G4,NOTE_AS4,NOTE_A4,
NOTE_FS4,NOTE_G4,NO_SOUND,NO_SOUND,NOTE_C4,
NOTE_G4,NOTE_FS4,NOTE_G4,NOTE_A4,NOTE_AS4,NOTE_A4,NOTE_AS4,NOTE_B4,

NOTE_CS5,NOTE_D5,NOTE_G4,NOTE_C4,
NOTE_G4,NOTE_F4,NOTE_A4,NOTE_G4,NOTE_AS4,NOTE_A4,NOTE_B4,NOTE_AS4,
NOTE_GS4,NOTE_A4,NO_SOUND,NOTE_A4,NOTE_A4,
NOTE_AS4,NOTE_A4,NO_SOUND,NOTE_A4,NOTE_AS4,NOTE_A4,
NOTE_A4,NOTE_D5,NOTE_C5,NOTE_AS4,
NOTE_AS4,NOTE_A4,NOTE_A4,NOTE_G4,NOTE_G4,NOTE_F4,NOTE_F4,NOTE_E4,

NOTE_E4,NOTE_D4,NO_SOUND,NOTE_G4,NOTE_G4,
NOTE_A4,NOTE_G4,NO_SOUND,NOTE_G4,NOTE_A4,NOTE_G4,
NOTE_G4,NOTE_C5,NOTE_B4,NOTE_A4,
NOTE_A4,NOTE_G4,NOTE_G4,NOTE_F4,NOTE_F4,NOTE_E4,NOTE_E4,NOTE_D4,
NOTE_D4,NOTE_C4,NO_SOUND,NOTE_C4,NOTE_E4,NOTE_G4,
NOTE_AS4,NOTE_C4,NOTE_E4,NOTE_G4,NOTE_AS4,NOTE_C4,NOTE_E4,NOTE_G4,

NOTE_AS4,NOTE_AS4,NOTE_C4,
NOTE_F4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_A4,NOTE_G4,NOTE_A4,NOTE_AS4,
NOTE_B4,NOTE_C5,NOTE_F4,NOTE_C4,
NOTE_F4,NOTE_E4,NOTE_G4,NOTE_F4,NOTE_A4,NOTE_G4,NOTE_AS4,NOTE_A4,
NOTE_FS4,NOTE_G4,NO_SOUND,NOTE_C4,
NOTE_G4,NOTE_FS4,NOTE_G4,NOTE_A4,NOTE_AS4,NOTE_A4,NOTE_AS4,NOTE_B4,

NOTE_CS5,NOTE_D5,NOTE_G4,NOTE_C4,
NOTE_G4,NOTE_FS4,NOTE_A4,NOTE_G4,NOTE_AS4,NOTE_A4,NOTE_C5,NOTE_AS4,
NOTE_GS4,NOTE_A4,NO_SOUND,NO_SOUND,NOTE_F4,
NOTE_G4,NOTE_F4,NOTE_E4,NOTE_F4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_F4,
NOTE_F4,NOTE_AS4,NOTE_AS4,NO_SOUND,NOTE_G4,
NOTE_A4,NOTE_G4,NOTE_FS4,NOTE_G4,NOTE_FS4,NOTE_G4,NOTE_A4,NOTE_G4,//2ºFS4

NOTE_G4,NOTE_C5,NOTE_C5,NO_SOUND,NOTE_A4,
NOTE_AS4,NOTE_A4,NOTE_GS4,NOTE_A4,NOTE_GS4,NOTE_A4,NOTE_AS4,NOTE_A4,//2ºGS4
NOTE_A4,NOTE_D5,NOTE_C5,NOTE_AS4,NOTE_G4,
NOTE_G4,NOTE_F4,NO_SOUND,NOTE_E4,NOTE_F4,NOTE_G4,
NOTE_AS4,NOTE_A4,NOTE_E4,NOTE_F4,NOTE_CS4,NOTE_D4,NOTE_AS4,NOTE_G4,
NOTE_G4,NOTE_F4,NO_SOUND,NOTE_G4,NOTE_A4,NOTE_AS4,

NOTE_B4,NOTE_C5,NOTE_A4,NOTE_F4,NOTE_D4,NOTE_AS4,
NOTE_A4,NOTE_F4,NOTE_D4,NOTE_C4,NOTE_D4,NOTE_E4,
NOTE_F4

};

// Duração das Notas: Colcheia:8; Semínima: 4; Mínima:2; Semibreve:1
int tempoNotas[] = {
4,
6,16,6,16,6,16,6,16,
3,8,4,4,
6,16,6,16,6,16,6,16,
4,4,4,16,8,
6,16,6,16,6,16,6,16,

3,8,4,4,
6,16,6,16,6,16,6,16,
4,4,4,6,16,
4,4,8,8,6,16,
4,2,8,8,
8,8,8,8,8,8,8,8,

4,4,4,6,16,
4,4,8,8,6,16,
4,2,8,8,
8,8,8,8,8,8,8,8,
4,4,8,8,8,8,
8,8,8,8,8,8,8,8,

2,4,4,
6,16,6,16,6,16,6,16,
3,8,4,4,
6,16,6,16,6,16,6,16,
4,4,4,4,
6,16,6,16,6,16,6,16,

3,8,4,4,
6,16,6,16,6,16,6,16,
4,4,4,8,16,
6,16,6,16,6,16,6,16,
3,8,4,8,8,
6,16,6,16,6,16,6,16,

3,8,4,8,8,
6,16,6,16,6,16,6,16,
4,3,8,8,8,
4,4,8,8,8,8,
8,8,8,8,8,8,8,8,
4,4,8,8,8,8,

8,8,8,8,4,4,
4,6,16,4,6,16,
2
};

const int compasso = 2000; // Altera o compasso da música

void setup() {
lcd.begin(16, 2); //Inicia o LCD com dimensões 16×2(Colunas x Linhas)
lcd.createChar(0, colcheia);
lcd.createChar(1, seminima);
lcd.createChar(2, minima);
lcd.createChar(3, semicolcheia);
pinMode(13, OUTPUT);
digitalWrite(13, 1);
for (int Nota = 0; Nota < 230; Nota++) {//o número 80 indica quantas notas tem a nossa matriz.
int tempo = compasso/tempoNotas[Nota]; //Tempo = compasso dividido pela indicação da matriz tempoNotas.
tone(8, melodia[Nota],tempo); //Toca a nota indicada pela matriz melodia durante o tempo.
// Para distinguir as notas adicionamos um tempo entre elas (tempo da nota + 20%).
lcd.clear();
lcd.setCursor(0,1);
if(melodia[Nota] == 262){
lcd.print(“C  (do)”);
} else if(melodia[Nota] == 440){
lcd.print(“A  (la)”);
} else if(melodia[Nota] == 349){
lcd.print(“F  (fa)”);
} else if(melodia[Nota] == 294){
lcd.print(“D  (re)”);
} else if(melodia[Nota] == 330){
lcd.print(“E  (mi)”);
} else if(melodia[Nota] == 392){
lcd.print(“G  (sol)”);
} else if(melodia[Nota] == 494){
lcd.print(“B  (si)”);
} else if(melodia[Nota] == 523){
lcd.print(“C  (do)”);
} else if(melodia[Nota] == 466){
lcd.print(“Bb (si bemol)”);
} else if(melodia[Nota] == 370){
lcd.print(“F# (fa susten.)”);
} else if(melodia[Nota] == 415){
lcd.print(“G# (sol susten.)”);
} else if(melodia[Nota] == 554){
lcd.print(“C# (do susten.)”);
} else if(melodia[Nota] == 587){
lcd.print(“D  (re)”);
} else if(melodia[Nota] == 277){
lcd.print(“C# (do susten.)”);
} else if(melodia[Nota] == 0){
lcd.print(“-  (pausa)”);
} else {
lcd.print(melodia[Nota]);
}
lcd.setCursor(0,0);
lcd.print(“Tempo: “);
if(tempoNotas[Nota] == 8 || tempoNotas[Nota] == 6){
lcd.write(byte(0));
if(tempoNotas[Nota] == 6){
lcd.print(“.”);
}
} else if(tempoNotas[Nota] == 4 || tempoNotas[Nota] == 3){
lcd.write(byte(1));
if(tempoNotas[Nota] == 3){
lcd.print(“.”);
}
} else if(tempoNotas[Nota] == 16){
lcd.write(byte(3));
} else if(tempoNotas[Nota] == 2){
lcd.write(byte(2));
}
delay(tempo*1.2);
}
}
void loop(){
//Não é necessária a repetição pois a mesma será feita pelo botão Reset.
}
//Fim de Programa

 

Anúncios

Garagino – um arduino brasileiro

Laboratório de Garagem desenvolveu o Garagino, que é uma versão simplificada do Arduino, diminuindo o custo. É interessante para quem quer começar pequenos projetos e gosta de economizar. O LdG ainda desenvolve alguns shields para quem opta por utilizar o Garagino, como o popular shield para conexões Ethernet.

O Garagino Rev 1 é um produto desenvolvido pela Equipe LdG para os desenvolvedores com interesse em projetos mais baratos e compactos.

É compacto, pode ser utilizado direto em protoboards, em projetos destinados a automação, em projetos de coleta de dados, robôs, etc. O Garagino diferente de outras placas miniaturizadas compatíveis com Arduino, utiliza um microcontrolador ATMEGA 328 no encapsulamento DIP 28 pinos e Bootloader do UNO Rev3, ficando mais fácil sua troca caso seja necessário.

Sua alimentação pode ser feita entre 1,8 e 5VDC, esta flexibilidade na alimentação traz economia ao projeto.

Exemplo:

– Quando alimentado 3.3V não necessita de adaptadores de tensão para se comunicar com cartões SD, memôrias externas e outros periféricos que necessitam de níveis lógicos de 3.3V.

 

FONTE: http://www.labdegaragem.org