Os leitores conhecem escoteiros - análogos de nossos pioneiros, mas acontece que também existem filhotes - análogos de nosso outubro. Aceito neles a partir dos cinco anos de idade. O filho do autor Instructbles, sob o apelido mr_fid, já foi adotado e ele terá que participar de um grande evento para táxis e batedores, um dos quais será o código Morse. Para interessar ainda mais a criança, o mestre lhe deu um brinquedo incomum.
É executado em
Arduino O Nano também gera 12 palavras diferentes para o sinal sonoro com um gerador embutido (comutável por um interruptor mecânico) e um LED RGB. O ciclo pode ser ajustado entre 100 e 1100 milissegundos. Para trocar palavras, é fornecido um interruptor. O design é alimentado por uma bateria de polímero de lítio de 1000 mAh. O controlador de carregamento está embutido. Mas aqui ainda não está:
Mr_fid agradece a Simon Monk pelo livro Arduino Programming, que ele comprou há vários anos. Ao elaborar o esboço, ele se baseou em exemplos deste livro.
Iniciando o trabalho em
caseiro, o mestre sabia sobre o código Morse apenas que havia um sinal SOS. Eu tive que aprender o material e descobrir que o ponto é uma medida, o traço é três, o intervalo entre os caracteres da letra é uma medida, entre as letras é três, entre as palavras é sete.
Ao marcar o plástico, o mr_fid usa fita adesiva. Graças a isso, o traço do marcador é melhor visualizado se o plástico estiver escuro. Além disso, essa fita adesiva é fosca e a broca não escorrega ao "apontar".
É necessário estimar com antecedência onde qual dos componentes da estrutura estará localizado, para que tudo se encaixe, e nenhum deles toque os vizinhos, incluindo as partes salientes. Mr_fid não esqueceu nada além de ... a bateria. Bem, o gabinete é bastante espaçoso e, em seguida, foi encontrado um local para ele. Enquanto isso ...
Embora o mestre possua uma pequena furadeira de bancada, mesmo com ela utilizou uma furadeira de passo para maior comodidade, também é uma “espinha de peixe” ou “cenoura”.
Quando o eixo da chave giratória é girado pela alça, a própria chave deve permanecer estacionária. Para isso, além do eixo, na frente dele há um pequeno pino que requer um orifício adicional no painel frontal.
Portanto, o mr_fid primeiro fez um furo no eixo e, em seguida, colou a fita adesiva na parte de trás, coloque o interruptor da chave no lugar e pressione-o. O pino deixou uma marca na fita adesiva, resta fazer um furo lá.
O circuito sem bateria, controlador de carga e conversor tem a seguinte aparência:
No painel frontal, onde estão localizados o interruptor de biscoito e o resistor variável, o mestre combinou as conclusões desses componentes que são conectados aos mesmos pontos do circuito no caso (neste caso, o fio positivo e o fio comum). Isso permitiu que apenas quatro fios fossem desenhados entre o painel frontal e a carcaça.
O interruptor da chave também é transformado em um tipo de resistor variável, apenas um passo, para o qual são soldados 11 resistores por 1 kOhm, como mostra as fotografias. O Arduino determina sua posição com uma mudança gradual da tensão, para a qual uma entrada analógica é suficiente.
Maior:
Para controlar o LED RGB, o mr_fid escolheu os pinos do Arduino com os números 9, 10 e 11. Essas são saídas PWM, que no próximo firmware tornarão possível obter mais bits por cor do que três.
Ele conectou um fio positivo e um fio comum em polaridade reversa a um resistor variável, de modo que a posição mínima corresponda ao ciclo de duração máxima, ou seja, a velocidade mínima.
Um exemplo do livro de Simon Monk é simples e monofuncional: pega os dados que chegam através de uma porta serial e os converte em código Morse com um ciclo de clock de 200 milissegundos. Funções adicionais adicionadas pelo assistente fornecem ajuste do período, dependendo da tensão proveniente do mecanismo de resistor variável, bem como a recusa da porta serial em favor do armazenamento de 12 palavras fixas selecionadas pelo seletor. Também foram adicionadas rotinas para controlar o botão de comutação do modo RGB-LED e, com um tweeter com um gerador embutido, o programa pode controlar inicialmente.
Ao programar o Arduino, o mr_fid esqueceu completamente que o brinquedo precisa ser alimentado de alguma coisa, porque a placa foi alimentada por USB esse tempo todo. Quando ele se lembrou, o primeiro pensamento foi alimentar tudo da "Krona" através do estabilizador. Mas ele não se encaixava e, a princípio, o mestre queria colocá-lo do lado de fora, mas decidiu usar uma fina bateria de polímero de lítio com 3,7 V e 1000 mAh.
Com uma bateria recém carregada, a voltagem atinge 4,2 V, o que é suficiente para todos os cristais do LED RGB, incluindo o azul. Mas, quando descarrega, cai e, embora 3,3 V seja suficiente, o brilho da luz azul pode diminuir bastante. Eu tive que usar um estabilizador de impulso com cinco volts estáveis na saída. E, para não remover a bateria do estojo durante o carregamento, o autor adicionou um controlador de carregamento e um interruptor de reversão bipolar que conecta a bateria com os dois pólos ao Arduino ou a este controlador. Agora você pode carregar o brinquedo via USB.
Ele conectou tudo isso dessa maneira, sem esquecer a polaridade e a prevenção de curto-circuito:
Alterando a posição do comutador de biscoito, você pode selecionar o código Morse para as seguintes combinações de letras: HHH (um ponto), OOO (um traço), CAT (gato), CÃO (cachorro), ANT (formiga), FLY (voar), RAT (rato), CORUJA (coruja), PORCO (porco), galinha (galinha), RAPOSA (raposa) e UEM (ema). O botão permite alternar os modos de operação do LED RGB no anel: cores constantes - vermelho, azul, verde, azul esverdeado, amarelo, framboesa, branco, além de um ponto vermelho e um traço verde, mudança de cor após cada palavra, mudança de cor após cada letra .
No Arduino, mr_fid enviou um esboço assim:int dotDelay = 200;
int ledPinRed = 11; // vermelho
int ledPinBlue = 10; // azul
int ledPinGreen = 9; // verde
int oldAI = 15;
int pat;
int i = 1;
int j = 0;
alternar bool = false;
botão int = 8;
buzzer int = 7;
sinalizador int = 1;
int selectWord;
int animal = 1;
int potValue = 0;
int maxVoltageBits = 1023;
int splitBits = maxVoltageBits / 22;
const int pot = A4;
const int rotaryInput = A5;
char ch;
char * letras [] = {
".-", "-...", "-.-.", "- ..", ".", "..-.", "-.", "....", " .. ",
".---", "-.-", ".- ..", "-", "-.", "---", ".--.", "--.-", ".-.",
"...", "-", "..-", "...-", ".--", "-..-", "-.--", "- .."} ;
char * numbers [] = {
"-----", ".----", "..---", "...--", "....-",
".....", "-....", "--...", "--- ..", "----."};
char * animals3 = "hhhooocatdogantflyratowlpighenfoxemu";
configuração nula ()
{
pinMode (ledPinBlue, OUTPUT);
pinMode (ledPinRed, OUTPUT);
pinMode (ledPinGreen, OUTPUT);
pinMode (pot, INPUT);
pinMode (rotaryInput, INPUT);
pinMode (botão, ENTRADA);
pinMode (campainha, SAÍDA);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
digitalWrite (ledPinGreen, HIGH);
digitalWrite (ledPinRed, LOW);
atraso (500);
digitalWrite (ledPinRed, HIGH);
atraso (100);
digitalWrite (ledPinBlue, LOW);
atraso (500);
digitalWrite (ledPinBlue, HIGH);
atraso (100);
digitalWrite (ledPinGreen, LOW);
atraso (500);
digitalWrite (ledPinGreen, HIGH);
atraso (100);
digitalWrite (campainha, ALTA);
atraso (100);
digitalWrite (campainha, LOW);
int buttonValue = digitalRead (botão);
if (buttonValue == 1)
{
selectWord = analogRead (rotaryInput);
selectorSwitch1 (selectWord);
}
mais
{
flag = 1;
}
}
loop vazio ()
{
wait_for_enter ();
selectWord = analogRead (rotaryInput);
selectorSwitch (selectWord);
potValue = analogRead (pot);
dotDelay = potValue + 100;
i = (animal * 3) -3;
enquanto (j & lt; 3)
{
ch = animais3 [i];
if (ch & gt; = 'a' && ch & lt; = 'z')
{
flashSequence (letras [ch - 'a']);
}
caso contrário, se (ch & gt; = '0' && ch & lt; = '9')
{
flashSequence (letras [ch - '0']);
}
caso contrário, se (ch == '')
{
atraso (dotDelay * 7);
}
i = i + 1;
j = j + 1;
}
atraso (dotDelay * 7);
// alternar =! alternar; // alterna a cor de cada palavra (não é necessário)
j é 0;
}
void wait_for_enter ()
{
int buttonValue = digitalRead (botão);
while (buttonValue == 0)
{
buttonValue = digitalRead (botão);
}
}
void flashSequence (sequência char *)
{
int k = 0;
while (sequência [k]! = '\ 0')
{
flashDotOrDash (sequência [k]);
k = k + 1;
}
//Serial.print ("");
atraso (dotDelay * 3);
toggle =! toggle; // alterna a cor entre as letras
}
void flashDotOrDash (char dotOrDash)
{
if (dotOrDash == '.')
{
if (sinalizador == 1)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
}
caso contrário, se (sinalizador == 2)
{
digitalWrite (ledPinBlue, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinBlue, HIGH);
}
caso contrário, se (sinalizador == 3)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinGreen, HIGH);
}
caso contrário, se (sinalizador == 4)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinGreen, HIGH);
digitalWrite (ledPinBlue, HIGH);
}
caso contrário, se (sinalizador == 5)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinGreen, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinGreen, HIGH);
}
caso contrário, se (sinalizador == 6)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
}
senão se (sinalizador == 7)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (ledPinGreen, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
digitalWrite (ledPinGreen, HIGH);
}
senão se (sinalizador == 8)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
}
caso contrário, se (sinalizador == 9)
{
if (alternar! = 0)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
}
mais
{
digitalWrite (ledPinBlue, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay);
digitalWrite (campainha, LOW);
digitalWrite (ledPinBlue, HIGH);
}
}
}
mais
{
if (sinalizador == 1)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
}
caso contrário, se (sinalizador == 2)
{
digitalWrite (ledPinBlue, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinBlue, HIGH);
}
caso contrário, se (sinalizador == 3)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinGreen, HIGH);
}
caso contrário, se (sinalizador == 4)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinGreen, HIGH);
digitalWrite (ledPinBlue, HIGH);
}
caso contrário, se (sinalizador == 5)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinGreen, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinGreen, HIGH);
}
caso contrário, se (sinalizador == 6)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
}
senão se (sinalizador == 7)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (ledPinGreen, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
digitalWrite (ledPinGreen, HIGH);
}
senão se (sinalizador == 8)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinGreen, HIGH);
}
caso contrário, se (sinalizador == 9)
{
if (alternar! = 0)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinRed, HIGH);
}
mais
{
digitalWrite (ledPinBlue, LOW);
digitalWrite (campainha, ALTA);
atraso (dotDelay * 3);
digitalWrite (campainha, LOW);
digitalWrite (ledPinBlue, HIGH);
}
}
}
delay (dotDelay); // entre letras
// alterna =! alterna; // alterna entre os caracteres
}
void selectorSwitch1 (int AI)
{
if ((AI & gt; (oldAI + 10)) || (AI & lt; (oldAI - 10))) // veja se o valor mudou?
{
se (AI & gt; 11 * bits divididos) // deve ser 7,8,9,10,11,12.
{
if (AI & gt; 17 * divididoBits) // deve ser 10,11,12.
{
if (AI & gt; 21 * divididoBits) // deve ser 12.
{
flag = 12;
}
else // deve ser 10.11.
{
if (AI & gt; 19 * divididoBits) // deve ser 11.
{
flag = 11;
}
else // deve ser 10.
{
flag = 10;
}
}
}
else // deve ser 7,8,9.
{
if (AI & gt; 15 * divididoBits) // deve ser 9.
{
flag = 9;
}
else // deve ser 7,8.
{
if (AI & gt; 13 * divididoBits) // deve ser 8.
{
flag = 8;
}
else // deve ser 7.
{
flag = 7;
}
}
}
}
senão // deve ser 1,2,3,4,5,6.
{
if (AI & gt; 5 * divididoBits) // deve ser 4,5,6.
{
if (AI & gt; 9 * divididoBits) // deve ser 6.
{
flag = 6;
}
else // deve ser 4,5.
{
if (AI & gt; 7 * divididoBits) // deve ser 5
{
flag = 5;
}
else // deve ser 4.
{
flag = 4;
}
}
}
else // deve ser 1,2,3.
{
if (AI & gt; 3 * splitBits) // deve ser 3.
{
flag = 3;
}
else // deve ser 1,2.
{
if (AI & gt; divididoBits) // deve ser 2.
{
flag = 2;
}
else // deve ser 1.
{
flag = 1;
}
}
}
}
}
IAI antiga = IA;
// delay (500);
//Serial.println ();
}
Seletor de voidSwitch (int AI)
{
if ((AI & gt; (oldAI + 10)) || (AI & lt; (oldAI - 10))) // veja se o valor mudou?
{
se (AI & gt; 11 * bits divididos) // deve ser 7,8,9,10,11,12.
{
if (AI & gt; 17 * divididoBits) // deve ser 10,11,12.
{
if (AI & gt; 21 * divididoBits) // deve ser 12.
{
animal = 12;
}
else // deve ser 10.11.
{
if (AI & gt; 19 * divididoBits) // deve ser 11.
{
animal = 11;
}
else // deve ser 10.
{
animal = 10;
}
}
}
else // deve ser 7,8,9.
{
if (AI & gt; 15 * divididoBits) // deve ser 9.
{
animal = 9;
}
else // deve ser 7,8.
{
if (AI & gt; 13 * divididoBits) // deve ser 8.
{
animal = 8;
}
else // deve ser 7.
{
animal = 7;
}
}
}
}
senão // deve ser 1,2,3,4,5,6.
{
if (AI & gt; 5 * divididoBits) // deve ser 4,5,6.
{
if (AI & gt; 9 * divididoBits) // deve ser 6.
{
animal = 6;
}
else // deve ser 4,5.
{
if (AI & gt; 7 * divididoBits) // deve ser 5
{
animal = 5;
}
else // deve ser 4.
{
animal = 4;
}
}
}
else // deve ser 1,2,3.
{
if (AI & gt; 3 * splitBits) // deve ser 3.
{
animal = 3;
}
else // deve ser 1,2.
{
if (AI & gt; divididoBits) // deve ser 2.
{
animal = 2;
}
else // deve ser 1.
{
animal = 1;
}
}
}
}
}
IAI antiga = IA;
// delay (500);
//Serial.println ();
}
Se você repetiu após o mestre, agora está em suas mãos o mesmo brinquedo com o qual você pode interessar seus filhos no código Morse. E quando eles crescem, com um simples remake do firmware, você pode obter a base para uma "raposa" automática padrão, transmitindo uma escolha de MOE, MOI, MOS, MOH ou MO5, ligando por um minuto a cada quatro minutos.
P.S. especialmente para pessoas chatas que encontram falhas nas manchetes: animais são um nome coletivo para animais, pássaros e insetos.
