Jouet "Animal Names Morse Code"

Électronique / Arduino

Ajouté 6 commentaires

Les lecteurs connaissent les éclaireurs - analogues de nos pionniers, mais il s'avère qu'il y a aussi des petits - analogues de notre octobre. Accepté en eux dès l'âge de cinq ans. Le fils de l'auteur Instructsbles sous le surnom de mr_fid a déjà été adopté, et il devra assister à un événement majeur pour les taxis et les scouts, dont l'un sera le code Morse. Pour intéresser davantage l'enfant, le maître lui a donné un jouet insolite.

Il est exécuté le Arduino Nano génère également 12 mots différents émis par le signal sonore avec un générateur intégré (commutable par un interrupteur mécanique) et une LED RGB. Le cycle peut être ajusté entre 100 et 1100 millisecondes. Pour changer de mots, un interrupteur de bricolage est fourni. La conception est alimentée par une batterie lithium-polymère de 1000 mAh. Le contrôleur de charge est intégré. Mais ici ce n'est pas encore:

Mr_fid remercie Simon Monk pour le livre Arduino Programming, qu'il a acheté il y a plusieurs années. Pour rédiger le croquis, il s'est appuyé sur des exemples de ce livre.

Commencer le travail sur fait maison, le capitaine ne connaissait le code Morse que s'il y avait un signal SOS. J'ai dû apprendre le matériel et découvrir que le point est une mesure, le tiret est trois, l'intervalle entre les caractères de la lettre est une mesure, entre les lettres est trois, entre les mots est sept.

Lors du marquage du plastique, mr_fid utilise du ruban de masquage. Grâce à cela, la trace du marqueur est mieux visible si le plastique est sombre. De plus, ce ruban adhésif est mat et le foret ne glisse pas lors de la "visée".

Il est nécessaire d'estimer à l'avance où se trouvera quel composant de la structure, de sorte que tout rentre, et qu'aucun des composants ne touche les composants voisins, y compris les parties saillantes. Mr_fid n'a rien oublié mais ... la batterie. Eh bien, le boîtier est assez spacieux, et puis un endroit pour cela a été trouvé. En attendant ...

Bien que le capitaine ait un petit foret d'établi, même avec lui, il a utilisé un foret étagé pour plus de commodité, il s'agit également d'un «chevron» ou d'une «carotte».

Lorsque l'arbre de l'interrupteur à bouton est tourné par la poignée, l'interrupteur lui-même doit rester immobile. Pour cela, en plus de l'arbre, en face de lui est une petite broche qui nécessite un trou supplémentaire sur le panneau avant.

Par conséquent, mr_fid a d'abord percé un trou pour l'arbre, puis a collé le ruban de masquage à l'arrière, a mis l'interrupteur à clé en place et l'a appuyé. La broche a laissé une marque sur le ruban de masquage, il reste à y percer un trou.

Le schéma sans prendre en compte la batterie, le contrôleur de charge et le convertisseur ressemble à ceci:

Sur le panneau avant, où se trouvent l'interrupteur filaire et une résistance variable, le maître a combiné les conclusions de ces composants qui sont connectés aux mêmes points du circuit dans le boîtier (dans ce cas, le plus et le fil commun). Cela a permis de ne tirer que quatre fils entre le panneau avant et le boîtier.

L'interrupteur à clé est également transformé en une sorte de résistance variable, seulement une étape, pour laquelle 11 résistances par 1 kOhm sont soudées à celui-ci, comme le montrent les photographies. Arduino détermine sa position par une tension changeante pas à pas, pour laquelle une entrée analogique est suffisante.

Plus grand:

Pour contrôler la LED RGB, mr_fid a choisi les broches Arduino avec les numéros 9, 10 et 11. Ce sont des sorties PWM qui, dans le prochain firmware, permettront d'obtenir plus de bits par couleur que trois.

Il a connecté un plus et un fil commun en polarité inversée à une résistance variable, de sorte que la position minimale correspond au cycle de durée maximale, c'est-à-dire la vitesse minimale.

Un exemple tiré du manuel de Simon Monk est simple et monofonctionnel: il prend les données qui transitent par un port série et les traduit en code Morse avec un cycle d'horloge de 200 millisecondes. Des fonctions supplémentaires ajoutées par l'assistant permettent d'ajuster la période en fonction de la tension provenant du moteur à résistance variable, ainsi que le refus du port série au profit du stockage de 12 mots fixes sélectionnés par le commutateur à cadran. Également ajouté des routines pour contrôler le bouton de commutation du mode RVB-LED, et avec un tweeter avec un générateur intégré, le programme pourrait contrôler initialement.

Lors de la programmation d'Arduino, mr_fid a complètement oublié que le jouet doit être alimenté à partir de quelque chose, car la carte a été alimentée par USB tout ce temps. Quand il se rappela, la première pensée fut de tout alimenter à partir de la «Krona» via le stabilisateur. Mais cela ne convenait pas, et au début, le maître a voulu le placer à l'extérieur, mais a ensuite décidé d'utiliser une mince batterie au lithium-polymère avec 3,7 V et 1000 mAh.

Avec une batterie fraîchement chargée, la tension atteint 4,2 V, ce qui est suffisant pour tous les cristaux de la LED RGB, y compris le bleu. Mais à mesure qu'elle se décharge, elle baisse et bien que 3,3 V soit suffisant, la luminosité de la lumière bleue peut considérablement diminuer. J'ai dû utiliser un stabilisateur boost avec un cinq volts stable à la sortie. Et afin de ne pas retirer la batterie de l'étui lors de la charge, l'auteur a ajouté un contrôleur de charge et un interrupteur inverseur bipolaire qui relie la batterie avec les deux pôles à l'Arduino ou à ce contrôleur. Vous pouvez maintenant charger le jouet via USB.

Il a connecté tout cela ensemble de cette manière, sans oublier la polarité et la prévention des courts-circuits:

En modifiant la position de l'interrupteur à biscuit, vous pouvez sélectionner le code Morse pour les combinaisons de lettres suivantes: HHH (un point), OOO (un tiret), CAT (chat), CHIEN (chien), ANT (fourmi), FLY (mouche), RAT (rat), OWL (hibou), PIG (porc), HEN (poulet), FOX (renard) et EMU (emu). Le bouton vous permet de changer les modes de fonctionnement de la LED RGB sur l'anneau: couleurs constantes - rouge, bleu, vert, bleu-vert, jaune, framboise, blanc, ainsi qu'un point rouge et un tiret vert, changement de couleur après chaque mot, changement de couleur après chaque lettre .

Dans Arduino, mr_fid a téléchargé un tel croquis:

Esquisse

int dotDelay = 200;
int ledPinRed = 11; // rouge
int ledPinBlue = 10; // bleu
int ledPinGreen = 9; // vert
int oldAI = 15;
int pat;
int i = 1;
int j = 0;
bool toggle = false;
bouton int = 8;
buzzer int = 7;
drapeau int = 1;
int selectWord;
int animal = 1;
int potValue = 0;
int maxVoltageBits = 1023;
int diviséBits = maxVoltageBits / 22;
const int pot = A4;
const int RotaryInput = A5;
char ch;

char * lettres [] = {
  ".-", "-...", "-.-.", "- ..", ".", "..-.", "-.", "....", " .. ",
  ".---", "-.-", ".- ..", "-", "-.", "---", ".--.", "--.-", ".-.",
  "...", "-", "..-", "...-", ".--", "-..-", "-.--", "- .."} ;

char * nombres [] = {
  "-----", ".----", "..---", "...--", "....-",
  ".....", "-....", "--...", "--- ..", "----."};

char * animals3 = "hhhooocatdogantflyratowlpighenfoxemu";

void setup ()
{
  pinMode (ledPinBlue, OUTPUT);
  pinMode (ledPinRed, OUTPUT);
  pinMode (ledPinGreen, OUTPUT);
  pinMode (pot, INPUT);
  pinMode (entrée rotative, entrée);
  pinMode (bouton, INPUT);
  pinMode (buzzer, OUTPUT);
  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 (buzzer, HIGH);
  retard (100);
  digitalWrite (buzzer, LOW);
  int buttonValue = digitalRead (bouton);
  if (buttonValue == 1)
  {
    selectWord = analogRead (RotaryInput);
    selectorSwitch1 (selectWord);
  }
  d'autre
  {
    drapeau = 1;
  }
}

boucle vide ()
{
  wait_for_enter ();
  selectWord = analogRead (RotaryInput);
  selectorSwitch (selectWord);
  potValue = analogRead (pot);
  dotDelay = potValue + 100;
  i = (animal * 3) -3;
  tandis que (j & lt; 3)
  {
    ch = animaux3 [i];
    if (ch & gt; = 'a' && ch & lt; = 'z')
    {
      flashSequence (lettres [ch - 'a']);
    }
    sinon si (ch & gt; = '0' && ch & lt; = '9')
    {
      flashSequence (lettres [ch - '0']);
    }
    sinon si (ch == '')
    {
      délai (dotDelay * 7);
    }
    i = i + 1;
    j = j + 1;
  }
  délai (dotDelay * 7);
  // toggle =! toggle; // bascule la couleur de chaque mot (pas nécessaire)
  j est 0;
}
void wait_for_enter ()
{
  int buttonValue = digitalRead (bouton);
  while (buttonValue == 0)
  {
    buttonValue = digitalRead (bouton);
  }
}

void flashSequence (séquence char *)
{
  int k = 0;
  while (séquence [k]! = '\ 0')
  {
    flashDotOrDash (séquence [k]);
    k = k + 1;
  }
  //Serial.print ("");
  délai (dotDelay * 3);
  bascule =! bascule; // bascule la couleur entre les lettres
}

void flashDotOrDash (char dotOrDash)
{
  if (dotOrDash == '.')
  {
    si (indicateur == 1)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
    }
    sinon si (indicateur == 2)
    {
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinBlue, HIGH);
    }
    sinon si (indicateur == 3)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinGreen, HIGH);
    }
    sinon si (indicateur == 4)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinGreen, HIGH);
      digitalWrite (ledPinBlue, HIGH);
    }
    sinon si (indicateur == 5)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinGreen, HIGH);
    }
    sinon si (indicateur == 6)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinBlue, HIGH);
    }
    sinon si (indicateur == 7)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinBlue, HIGH);
      digitalWrite (ledPinGreen, HIGH);
    }
    sinon si (indicateur == 8)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
    }
    sinon si (indicateur == 9)
    {
      si (basculer! = 0)
      {
        digitalWrite (ledPinRed, LOW);
        digitalWrite (buzzer, HIGH);
        délai (dotDelay);
        digitalWrite (buzzer, LOW);
        digitalWrite (ledPinRed, HIGH);
      }
      d'autre
      {
        digitalWrite (ledPinBlue, LOW);
        digitalWrite (buzzer, HIGH);
        délai (dotDelay);
        digitalWrite (buzzer, LOW);
        digitalWrite (ledPinBlue, HIGH);
      }
    }
  }
  d'autre
  {
    si (indicateur == 1)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay * 3);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
    }
    sinon si (indicateur == 2)
    {
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay * 3);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinBlue, HIGH);
    }
    sinon si (indicateur == 3)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay * 3);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinGreen, HIGH);
    }
    sinon si (indicateur == 4)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay * 3);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinGreen, HIGH);
      digitalWrite (ledPinBlue, HIGH);
    }
    sinon si (indicateur == 5)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay * 3);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinGreen, HIGH);
    }
    sinon si (indicateur == 6)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay * 3);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinBlue, HIGH);
    }
    sinon si (indicateur == 7)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay * 3);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinBlue, HIGH);
      digitalWrite (ledPinGreen, HIGH);
    }
    sinon si (indicateur == 8)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (buzzer, HIGH);
      délai (dotDelay * 3);
      digitalWrite (buzzer, LOW);
      digitalWrite (ledPinGreen, HIGH);
    }
    sinon si (indicateur == 9)
    {
      si (basculer! = 0)
      {
        digitalWrite (ledPinRed, LOW);
        digitalWrite (buzzer, HIGH);
        délai (dotDelay * 3);
        digitalWrite (buzzer, LOW);
        digitalWrite (ledPinRed, HIGH);
      }
      d'autre
      {
        digitalWrite (ledPinBlue, LOW);
        digitalWrite (buzzer, HIGH);
        délai (dotDelay * 3);
        digitalWrite (buzzer, LOW);
        digitalWrite (ledPinBlue, HIGH);
        
      }
    }
    
  }
  delay (dotDelay); // entre les lettres
  // toggle =! toggle; // bascule entre les caractères
}
void selectorSwitch1 (int AI)
{
  if ((AI & gt; (oldAI + 10)) || (AI & lt; (oldAI - 10))) // voir si la valeur a changé?
  {
    si (AI & gt; 11 * bits divisés) // doit être 7,8,9,10,11,12.
    {
      si (AI & gt; 17 * bits divisés) // doit être 10,11,12.
      {
        si (AI & gt; 21 * bits divisés) // doit être 12.
        {
          drapeau = 12;
        }
        sinon // doit être soit 10.11.
        {
          si (AI & gt; 19 * bits divisés) // doit être égal à 11.
          {
            drapeau = 11;
          }
          sinon // doit être 10.
          {
           drapeau = 10;
          }
        }
      }
      sinon // doit être 7,8,9.
      {
        si (AI & gt; 15 * bits divisés) // doit être 9.
        {
          drapeau = 9;
        }
        sinon // doit être 7.8.
        {
          si (AI & gt; 13 * bits divisés) // doit être égal à 8.
          {
            drapeau = 8;
          }
          sinon // doit être 7.
          {
            drapeau = 7;
          }
        }
      }
    }
    sinon // doit être 1,2,3,4,5,6.
    {
      si (AI & gt; 5 * bits divisés) // doit être 4,5,6.
      {
        si (AI & gt; 9 * bits divisés) // doit être 6.
        {
          drapeau = 6;
        }
        sinon // doit être 4,5.
        {
          si (AI & gt; 7 * bits divisés) // doit être 5
          {
            drapeau = 5;
          }
          sinon // doit être 4.
          {
            drapeau = 4;
          }
        }
      }
      sinon // doit être 1,2,3.
      {
        si (AI & gt; 3 * bits divisés) // doit être égal à 3.
        {
          drapeau = 3;
        }
        sinon // doit être 1,2.
        {
          si (AI & gt; bits divisés) // doit être égal à 2.
          {
            drapeau = 2;

          }
          sinon // doit être 1.
          {
            drapeau = 1;
          }
        }
      }
    }
  }
  oldAI = AI;
  // délai (500);
  //Serial.println ();
}
void selectorSwitch (int AI)
{
  if ((AI & gt; (oldAI + 10)) || (AI & lt; (oldAI - 10))) // voir si la valeur a changé?
  {
    si (AI & gt; 11 * bits divisés) // doit être 7,8,9,10,11,12.
    {
      si (AI & gt; 17 * bits divisés) // doit être 10,11,12.
      {
        si (AI & gt; 21 * bits divisés) // doit être 12.
        {
          animal = 12;
        }
        sinon // doit être soit 10.11.
        {
          si (AI & gt; 19 * bits divisés) // doit être égal à 11.
          {
            animal = 11;
          }
          sinon // doit être 10.
          {
           animal = 10;
          }
        }
      }
      sinon // doit être 7,8,9.
      {
        si (AI & gt; 15 * bits divisés) // doit être 9.
        {
          animal = 9;
        }
        sinon // doit être 7.8.
        {
          si (AI & gt; 13 * bits divisés) // doit être égal à 8.
          {
            animal = 8;
          }
          sinon // doit être 7.
          {
            animal = 7;
          }
        }
      }
    }
    sinon // doit être 1,2,3,4,5,6.
    {
      si (AI & gt; 5 * bits divisés) // doit être 4,5,6.
      {
        si (AI & gt; 9 * bits divisés) // doit être 6.
        {
          animal = 6;
        }
        sinon // doit être 4,5.
        {
          si (AI & gt; 7 * bits divisés) // doit être 5
          {
            animal = 5;
          }
          sinon // doit être 4.
          {
            animal = 4;
          }
        }
      }
      sinon // doit être 1,2,3.
      {
        si (AI & gt; 3 * bits divisés) // doit être égal à 3.
        {
          animal = 3;
        }
        sinon // doit être 1,2.
        {
          si (AI & gt; bits divisés) // doit être égal à 2.
          {
            animal = 2;

          }
          sinon // doit être 1.
          {
            animal = 1;
          }
        }
      }
    }
  }
  oldAI = AI;
  // délai (500);
  //Serial.println ();
}

Si vous avez répété après le maître, vous avez maintenant entre vos mains le même jouet avec lequel vous pouvez intéresser vos enfants au code Morse. Et quand ils grandissent, avec un simple remake du firmware, vous pouvez obtenir la base d'un "renard" automatique standard, transmettant un choix de MOE, MOI, MOS, MOH ou MO5, s'allumant pendant une minute toutes les quatre minutes.

P.S. surtout pour les gens ennuyeux qui trouvent à redire aux gros titres: les animaux sont un nom collectif pour les animaux, les oiseaux et les insectes.

6 novembre 2018 01:23 0

Répondre Pour citer Plainte

Citation: tormozedison

supprimer le commutateur d'inversion bipolaire?

Oui, laissez un interrupteur unipolaire entre la batterie et le module Step-Up.

5 novembre 2018 23 h 40 L'auteur 0

Je vois. Un tel module ne protégerait donc pas seulement la batterie contre les décharges excessives,mais cela permettrait-il de retirer le commutateur inverseur bipolaire?

Maintenant, si je répétais cette chose, alors en général, je connectais simplement le cordon à la banque d'alimentation, abandonnant la batterie interne. Et j'ajouterais également RTC et la fonction d'horloge Morse.

5 novembre 2018 23 h 19 0

Celui sur la photo est destiné seulement pour chargeurs. Ici, vous devez contrôler non seulement la charge, mais également la décharge. Sur la carte, en plus du TP4056, vous avez besoin d'un CI comme DW01 et des clés. Et, par conséquent, pas 4 contacts pour le câblage, mais 6. Peut-être que le module boost protégera la batterie s'il cesse soudainement de fonctionner à une tension de 2,7 ... 2,8 V, mais nous ne savons rien de ses paramètres et comptons sur " les effets de gauche sont faux.

5 novembre 2018, 21:19 L'auteur 0

Dites-moi, pourquoi ce type de contrôleur de charge est-il mauvais et quel est le meilleur?

5 novembre 2018 20:51 0

La méchante soudure des résistances sur le biscuit et le mauvais contrôleur de charge de batterie.

5 novembre 2018 09:34 -3

Mais seul le titre peut être blâmé? Mais l'auteur n'a pas d'alphabétisation?

Jouet "Animal Names Morse Code"

Ajoutez un commentaire

Catégories de bricolage