Els lectors coneixen els exploradors - anàlegs dels nostres pioners, però resulta que també hi ha cabdells - anàlegs del nostre mes d’octubre. Acceptat en ells des de cinc anys. El fill de l’autor Instructsbles amb el sobrenom de mr_fid ja ha estat adoptat, i haurà d’assistir a un gran esdeveniment de cabines i scouts, un dels quals serà el codi Morse. Per interessar encara més l’infant, l’amo li va regalar una joguina inusual.
S'executa el
Arduino Nano i genera 12 paraules de sortida diferents al pit amb un generador integrat (commutable per un interruptor mecànic) i un LED RGB. El cicle es pot ajustar entre 100 i 1.100 mil·lisegons. Per canviar les paraules, es proporciona un commutador intermitent. El disseny està alimentat per una bateria de polímer de liti de 1000 mAh. El controlador de càrrega està integrat. Però aquí encara no ho és:
Mr_fid agraeix a Simon Monk el llibre Arduino Programming que va comprar fa diversos anys. Per elaborar l'esbós es va basar en exemples d'aquest llibre.
Començar el treball a
casolans, el mestre només coneixia el codi Morse que hi havia un senyal SOS. Vaig haver d’aprendre el material i esbrinar que el punt és una mesura, el guionet és tres, l’interval entre els caràcters de la lletra és una mesura, entre les lletres és de tres, entre les paraules és de set.
En marcar plàstic mr_fid utilitza cinta adhesiva. Gràcies a això, es veu millor la traça del marcador si el plàstic és fosc. A més, aquesta cinta adhesiva és mat i el trepant no es llisca en "apuntar".
Cal estimar amb antelació on se situarà quin dels components de l'estructura, de manera que tot encaixi, i cap dels components no toqui els veïns, incloses les parts que sobresurten. Mr_fid no ha oblidat res, però ... la bateria. Bé, el cas és força ampli, i després es va trobar un lloc per a això. Mentrestant ...
Tot i que el mestre té una petita perforació per a bancs, fins i tot amb un foradet per obtenir una comoditat més gran, també és un "arenque" o "pastanaga".
Quan l’eix del commutador està rotat pel mànec, l’interruptor mateix ha de romandre estacionari. Per això, a més de l’eix, al davant hi ha un petit passador que requereix un forat addicional al panell frontal.
Per tant, mr_fid primer va perforar un forat per a l’eix, després va enganxar la cinta adhesiva al darrere, va col·locar l’interruptor de la clau i el va prémer. El passador va deixar una marca a la cinta adhesiva, queda per fer-hi un forat.
L'esquema sense tenir en compte la bateria, el controlador de càrrega i el convertidor sembla:
Al plafó frontal, on es troba l’interruptor de galetes i la resistència variable, el mestre va combinar les conclusions d’aquests components que estan connectats als mateixos punts del circuit del cas (en aquest cas, el plus i el fil comú). Això només permetia dibuixar quatre cables entre el panell frontal i la carcassa.
L’interruptor de la clau també es converteix en una mena de resistència variable, només un primer pas, per a la qual se li solden 11 resistències per 1 kOhm, tal com es mostra a les fotografies. Arduino determina la seva posició mitjançant un voltatge canviant pas a pas, per al qual és suficient una entrada analògica.
Més gran:
Per controlar el LED RGB, mr_fid va triar els pins Arduino amb els números 9, 10 i 11. Es tracta de sortides PWM, que en el pròxim firmware permetrà obtenir més bits per color que tres.
Va connectar un plus i un fil comú en polaritat inversa a una resistència variable, de manera que la posició mínima correspon al cicle de durada màxima, és a dir, a la velocitat mínima.
Un exemple del llibre de text de Simon Monk és senzill i unifuncional: es pren dades que entren a través d’un port sèrie i es tradueixen a codi Morse amb un cicle de rellotge de 200 mil·lisegons. Les funcions addicionals afegides per l’assistent proporcionen l’ajust del període en funció de la tensió procedent del motor de resistència variable, així com la negativa del port sèrie a favor d’emmagatzemar 12 paraules fixes seleccionades pel commutador de marcació. També es van afegir rutines per controlar el botó de commutació del mode RGB-LED i, mitjançant un tweeter amb un generador incorporat, el programa es podia controlar inicialment.
En programar Arduino, mr_fid va oblidar completament que la joguina s'ha d'alimentar d'alguna cosa, perquè la placa s'ha alimentat des de USB tot aquest temps. Quan el recordava, el primer pensament era alimentar-ho tot des de la "Krona" a través de l'estabilitzador. Però no encaixava, i al principi el mestre va voler col·locar-lo fora, però després va decidir utilitzar una fina bateria de polímer de liti amb 3,7 V i 1000 mAh.
Amb una bateria recentment carregada, la tensió arriba a 4,2 V, que és suficient per a tots els cristalls del LED RGB, inclòs el blau. Però a mesura que es descarrega, baixa i, tot i que 3,3 V és suficient, la brillantor de la llum blava pot disminuir molt. Vaig haver d’utilitzar un estabilitzador d’ampliació amb cinc volts estables a la sortida. I per tal de no treure la bateria del maletí quan es carrega, l’autor va afegir un controlador de càrrega i un interruptor d’inversió de dos pols que connecta la bateria amb els dos pols a l’Arduino o a aquest controlador. Ara podeu carregar la joguina des de l’USB.
Va connectar tot això de manera així, sense oblidar la polaritat i la prevenció dels curtcircuits:
Si canvieu la posició del commutador de galetes, podeu seleccionar el codi Morse per a les combinacions de lletres següents: HHH (un punt), OOO (un guionet), CAT (gat), DOG (gos), ANT (formiga), FLY (mosca), RAT (rata), OWL (mussol), PIG (porc), HEN (pollastre), FOX (guineu) i EMU (emu). El botó permet canviar els modes de funcionament del LED RGB a l’anell: colors constants - vermell, blau, verd, blau-verd, groc, gerd, blanc, així com un punt vermell i un guió verd, canvi de color després de cada paraula, canvi de color després de cada lletra .
A Arduino, mr_fid va penjar un esbós com aquest:int dotDelay = 200;
int ledPinRed = 11; // vermell
int ledPinBlue = 10; // blau
int ledPinGreen = 9; // verd
int oldAI = 15;
int pat;
int i = 1;
int j = 0;
bool toggle = fals;
botó int = 8;
int zumbador = 7;
int flag = 1;
int selectWord;
animal int = 1;
int potValue = 0;
int maxVoltageBits = 1023;
int divisBits = màximVoltageBits / 22;
const int pot = A4;
const int rotaryInput = A5;
char ch;
char * lletres [] = {
".-", "-...", "-.-.", "- ..", ".", "..-.", "-.", "....", " .. ",
".---", "-.-", ".- ..", "-", "-.", "---", ".--.", "--.-", ".-.",
"...", "-", "..-", "...-", ".--", "-..-", "-.--", "- .."} ;
números * char [] = {
"-----", ".----", "..---", "...--", "....-",
".....", "-....", "--...", "--- ..", "----."};
char * animals3 = "hhhooocatdogantflyratowlpighenfoxemu";
nul configuració ()
{
pinMode (ledPinBlue, OUTPUT);
pinMode (ledPinRed, OUTPUT);
pinMode (ledPinGreen, OUTPUT);
pinMode (pot, INPUT);
pinMode (rotaryInput, INPUT);
pinMode (botó, INPUT);
pinMode (brunzidor, SORTIDA);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
digitalWrite (ledPinGreen, HIGH);
digitalWrite (ledPinRed, LOW);
retard (500);
digitalWrite (ledPinRed, HIGH);
retard (100);
digitalWrite (ledPinBlue, LOW);
retard (500);
digitalWrite (ledPinBlue, HIGH);
retard (100);
digitalWrite (ledPinGreen, LOW);
retard (500);
digitalWrite (ledPinGreen, HIGH);
retard (100);
digitalWrite (timbre, HIGH);
retard (100);
digitalWrite (timbre, baix);
int buttonValue = digitalRead (botó);
if (buttonValue == 1)
{
selectWord = analogRead (lectura rotativa);
selectorSwitch1 (selectWord);
}
més
{
bandera = 1;
}
}
bucle void ()
{
wait_for_enter ();
selectWord = analogRead (lectura rotativa);
selectorSwitch (selectWord);
potValue = analogRead (pot);
dotDelay = potValue + 100;
i = (animal * 3) -3;
mentre que (j & lt; 3)
{
ch = animals3 [i];
if (ch & gt; = 'a' && ch & lt; = 'z')
{
FlashSequence (lletres [ch - 'a']);
}
altrament si (ch & gt; = '0' && ch & lt; = '9')
{
FlashSequence (lletres [ch - '0']);
}
else if (ch == '')
{
retard (puntDelay * 7);
}
i = i + 1;
j = j + 1;
}
retard (puntDelay * 7);
// commutar =! commutar; // commuta el color de cada paraula (no és necessari)
j és 0;
}
void wait_for_enter ()
{
int buttonValue = digitalRead (botó);
while (buttonValue == 0)
{
buttonValue = digitalRead (botó);
}
}
void flashSequence (seqüència * char)
{
int k = 0;
while (seqüència [k]! = '\ 0')
{
flashDotOrDash (seqüència [k]);
k = k + 1;
}
//Serial.print ("");
retard (puntDelay * 3);
commutar =! commutar; // commutar el color entre les lletres
}
void flashDotOrDash (char dotOrDash)
{
if (dotOrDash == '.')
{
if (marcat == 1)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
}
else if (flag == 2)
{
digitalWrite (ledPinBlue, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinBlue, HIGH);
}
else if (flag == 3)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinGreen, HIGH);
}
else if (flag == 4)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinGreen, HIGH);
digitalWrite (ledPinBlue, HIGH);
}
else if (bandera == 5)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinGreen, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinGreen, HIGH);
}
else if (flag == 6)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
}
else if (flag == 7)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (ledPinGreen, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
digitalWrite (ledPinGreen, HIGH);
}
else if (bandera == 8)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
}
else if (bandera == 9)
{
if (commuta! = 0)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
}
més
{
digitalWrite (ledPinBlue, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay);
digitalWrite (timbre, baix);
digitalWrite (ledPinBlue, HIGH);
}
}
}
més
{
if (marcat == 1)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
}
else if (flag == 2)
{
digitalWrite (ledPinBlue, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinBlue, HIGH);
}
else if (flag == 3)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinGreen, HIGH);
}
else if (flag == 4)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinGreen, HIGH);
digitalWrite (ledPinBlue, HIGH);
}
else if (bandera == 5)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinGreen, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinGreen, HIGH);
}
else if (flag == 6)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
}
else if (flag == 7)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (ledPinBlue, LOW);
digitalWrite (ledPinGreen, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
digitalWrite (ledPinBlue, HIGH);
digitalWrite (ledPinGreen, HIGH);
}
else if (bandera == 8)
{
digitalWrite (ledPinGreen, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinGreen, HIGH);
}
else if (bandera == 9)
{
if (commuta! = 0)
{
digitalWrite (ledPinRed, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinRed, HIGH);
}
més
{
digitalWrite (ledPinBlue, LOW);
digitalWrite (timbre, HIGH);
retard (puntDelay * 3);
digitalWrite (timbre, baix);
digitalWrite (ledPinBlue, HIGH);
}
}
}
retard (puntDelay); // entre lletres
// commutar =! commutar; // alternar entre els caràcters
}
void selectorSwitch1 (int AI)
{
if ((AI & gt; (oldAI + 10)) || (AI & lt; (oldAI - 10))) // veure si el valor ha canviat?
{
if (AI & gt; 11 * Bits dividits) // ha de ser 7,8,9,10,11,12.
{
if (AI & gt; 17 * Bits dividits) // ha de ser 10,11,12.
{
if (AI & gt; 21 * Bits dividits) // ha de ser 12.
{
bandera = 12;
}
Altrament // ha de ser 10.11.
{
if (AI & gt; 19 * Bits dividits) // ha de ser 11.
{
bandera = 11;
}
Altrament // ha de ser 10.
{
bandera = 10;
}
}
}
Altrament // ha de ser 7,8,9
{
if (AI & gt; 15 * Bits dividits) // ha de ser 9.
{
bandera = 9;
}
Altrament // ha de ser 7.8.
{
if (AI & gt; 13 * Bits dividits) // ha de ser 8.
{
bandera = 8;
}
altrament // ha de ser 7.
{
bandera = 7;
}
}
}
}
Altrament // ha de ser 1,2,3,4,5,6.
{
if (AI & gt; 5 * Bits dividits) // ha de ser 4,5,6.
{
if (AI & gt; 9 * Bits dividits) // ha de ser 6.
{
bandera = 6;
}
altrament // ha de ser 4,5.
{
if (AI & gt; 7 * Bits dividits) // ha de ser 5
{
bandera = 5;
}
Altrament // ha de ser 4.
{
bandera = 4;
}
}
}
Altrament // ha de ser 1,2,3.
{
if (AI & gt; 3 * Bits dividits) // ha de ser 3.
{
bandera = 3;
}
altrament // ha de ser 1,2.
{
if (AI & gt; splitBits) // ha de ser 2.
{
bandera = 2;
}
Altrament // ha de ser 1.
{
bandera = 1;
}
}
}
}
}
vellAI = AI;
// retard (500);
//Serial.println ();
}
void selectorSwitch (int AI)
{
if ((AI & gt; (oldAI + 10)) || (AI & lt; (oldAI - 10))) // veure si el valor ha canviat?
{
if (AI & gt; 11 * Bits dividits) // ha de ser 7,8,9,10,11,12.
{
if (AI & gt; 17 * Bits dividits) // ha de ser 10,11,12.
{
if (AI & gt; 21 * Bits dividits) // ha de ser 12.
{
animal = 12;
}
Altrament // ha de ser 10.11.
{
if (AI & gt; 19 * Bits dividits) // ha de ser 11.
{
animal = 11;
}
Altrament // ha de ser 10.
{
animal = 10;
}
}
}
Altrament // ha de ser 7,8,9
{
if (AI & gt; 15 * Bits dividits) // ha de ser 9.
{
animal = 9;
}
Altrament // ha de ser 7.8.
{
if (AI & gt; 13 * Bits dividits) // ha de ser 8.
{
animal = 8;
}
altrament // ha de ser 7.
{
animal = 7;
}
}
}
}
Altrament // ha de ser 1,2,3,4,5,6.
{
if (AI & gt; 5 * Bits dividits) // ha de ser 4,5,6.
{
if (AI & gt; 9 * Bits dividits) // ha de ser 6.
{
animal = 6;
}
altrament // ha de ser 4,5.
{
if (AI & gt; 7 * Bits dividits) // ha de ser 5
{
animal = 5;
}
Altrament // ha de ser 4.
{
animal = 4;
}
}
}
Altrament // ha de ser 1,2,3.
{
if (AI & gt; 3 * Bits dividits) // ha de ser 3.
{
animal = 3;
}
altrament // ha de ser 1,2.
{
if (AI & gt; splitBits) // ha de ser 2.
{
animal = 2;
}
Altrament // ha de ser 1.
{
animal = 1;
}
}
}
}
}
vellAI = AI;
// retard (500);
//Serial.println ();
}
Si heu repetit després de l’amo, ara a les mans hi ha la mateixa joguina amb la qual podeu interessar als vostres fills en codi Morse. I quan creixen, amb una simple alteració del firmware, podeu obtenir les bases per a una "guineu" automàtica estàndard, transmetent una tria de MOE, MOI, MOS, MOH o MO5, que s'encén durant un minut cada quatre minuts.
P.S. especialment per a les persones avorrides que tenen errades en els titulars: els animals són un nom col·lectiu per a animals, aus i insectes.
