Játék "Animal Names Morse Code"

elektronika / Arduino

Hozzáadott 6 megjegyzés

Az olvasók ismerik a felderítőket - úttörőink analógjait, de kiderül, hogy vannak még kölykök is - októberi analógjaink. Öt éves kortól fogadták el őket. Az mr_fid becenév alatt az Instructsbles nevû író fiát már elfogadták, és a kabinok és cserkészek nagy eseményén kell részt vennie, ezek közül az egyik Morse-kód lesz. A gyermek további érdeklődése érdekében a mester szokatlan játékot adott neki.

Ez végrehajtásra kerül Arduino Nano és 12 különféle szót generál a sípoláshoz egy beépített generátorral (mechanikus kapcsolóval kapcsolható) és egy RGB LED-del. A ciklus 100 és 1100 milliszekundum között állítható be. A szavak váltásához bádogos kapcsoló van. A kialakítást 1000 mAh-es lítium-polimer akkumulátor táplálja. A töltésvezérlő beépített. De itt még nem:

Mr_fid köszönetet monk Simon Monknak az Arduino Programming című könyvért, amelyet több éve vásárolt. A vázlat elkészítése során a könyv példáira támaszkodott.

A munka megkezdése Homebrew gally, a mester csak a Morse-kódról tudta, hogy SOS jel van. Meg kellett tanulnom az anyagot, és rájöttem, hogy a pont egy méret, kötőjel három, a betű karakterei közötti intervallum egy, a betűk között három, a szavak között hét.

Műanyag jelöléskor az mr_fid maszkolószalagot használ. Ennek köszönhetően a jelölőnyomás jobban látható, ha a műanyag sötét. Ezenkívül ez a ragasztószalag matt és a fúró „csúszáskor” nem csúszik.

Előzetesen meg kell becsülni, hogy a szerkezet melyik elemét fogja elhelyezni, hogy minden illeszkedjen, és egyikük sem érinti a szomszédos elemeket, ideértve a kiálló részeket is. Mr_fid nem felejtett el semmit, csak ... az akkumulátort. Nos, az ügy elég tágas, és akkor találtak helyet neki. Időközben ...

Noha a mesternek kicsi pad-fúrója van, még kényelmesebb lépésfúrót is használ, de ez egy „halszálka” vagy „sárgarépa” is.

Amikor a kapcsoló tengelyét a fogantyú elforgatja, maga a kapcsolónak helyben maradnia kell. Ehhez a tengely mellett egy kis csap van, amelyhez további lyukat kell létrehozni az előlapon.

Ezért az mr_fid először fúrott egy lyukat a tengelyhez, majd ráragasztotta a maszkolószalagot a hátlapjára, tegye a helyére a csavarkulcs-kapcsolót és nyomja meg. A csap nyomot hagyott a maszkolószalagon, ott marad egy lyuk fúrása.

A séma az akkumulátor, a töltésvezérlő és a konverter figyelembevétele nélkül így néz ki:

Az előlapon, ahol a kekszkapcsoló és a változó ellenállás található, a mester kombinálta ezen alkatrészek azon következtetéseit, amelyek az eset ugyanazon áramköri pontjaihoz kapcsolódnak (ebben az esetben a plusz és a közös vezeték). Ez csak négy huzal húzását tette lehetővé az előlap és a ház között.

A csavarkulcs-kapcsolót egyfajta változó ellenállásrá is alakítják, csak egy lépésben, amelyre 11 kChm-enként 11 ellenállást forrasztanak hozzá, ahogy a fényképeken is látható. Arduino pozícióját fokozatosan változó feszültséggel határozza meg, amelyhez egy analóg bemenet elegendő.

Nagy:

Az RGB LED vezérléséhez az mr_fid a 9., 10. és 11. számú Arduino csapokat választotta. Ezek PWM kimenetek, amelyek a következő firmware-ben lehetővé teszik, hogy színenként több bitet szerezzen, mint három.

Összekapcsolt egy plusz és egy közös vezetéket fordított polaritással egy változó ellenállással, úgy, hogy a minimális helyzet megfeleljen a maximális időtartam ciklusának, azaz a minimális sebességnek.

A Simon Monk tankönyvéből származó példa egyszerű és funkcionális: a soros porton keresztül beérkező adatokat átveszi és Morise-kódba fordítja egy 200 milliszekundumos ciklusban. A varázsló által hozzáadott további funkciók biztosítják az időszak beállítását a változó ellenállású motor feszültségétől függően, valamint a soros port megtagadását a tárcsás kapcsoló által kiválasztott 12 rögzített szó tárolása érdekében. Rendszereket adott az RGB-LED üzemmód kapcsológombjának vezérlésére is, és egy beépített generátorral rendelkező tweeterrel a program kezdetben vezérelhette.

Az Arduino programozásakor az mr_fid teljesen elfelejtette, hogy a játékot valamiről kell táplálni, mivel a tábla egész idő alatt az USB-ből táplált. Amikor eszébe jutott, az első gondolat az volt, hogy mindezt a „Kronából” a stabilizátoron keresztül táplálják. De nem fér el, és először a mester akartak kint helyezni, de úgy döntött, hogy vékony lítium-polimer akkumulátort használ, 3,7 V és 1000 mAh-val.

Frissen feltöltött akkumulátorral a feszültség eléri a 4,2 V-ot, amely elegendő az RGB LED összes kristályához, beleértve a kékképet is. De amint kisül, csökken, és bár 3,3 V is elegendő, a kék fény fényereje jelentősen csökkenhet. Fokozás-stabilizátort kellett használni stabil kimeneti stabil 5 voltos feszültséggel. És annak elkerülése érdekében, hogy töltés közben ne távolítsa el az akkumulátort a házból, a szerzõ egy töltõvezérlõt és egy kétpólusú irányváltó kapcsolót adott hozzá, amely összeköti az akkumulátort mindkét pólussal az Arduino-hoz vagy ehhez a vezérlõhöz. Most már feltöltheti a játékot az USB-ről.

Mindezt úgy összekapcsolta, hogy ne felejtse el a polaritást és a rövidzárlat megakadályozását:

A kekszkapcsoló helyzetének megváltoztatásával kiválaszthatja a Morzes kódot a következő betűkombinációkhoz: HHH (egy pont), OOO (egy kötőjel), CAT (macska), DOG (kutya), ANT (hangya), LÉG (légy), RAT (patkány), OWL (bagoly), PIG (sertés), HEN (csirke), FOX (róka) és EMU (emu). A gombbal válthat az RGB LED működési módjain a gyűrűn: állandó színek - piros, kék, zöld, kék-zöld, sárga, málna, fehér, valamint egy piros pont és egy zöld kötőjel, színváltozás minden szó után, színváltozás minden betű után .

Arduinóban az mr_fid feltöltött egy ilyen vázlatot:

vázlat

int dotDelay = 200;
int ledPinRed = 11; // piros
int ledPinBlue = 10; // kék
int ledPinGreen = 9; // zöld
int oldAI = 15;
int pat;
int i = 1;
int j = 0;
bool toggle = hamis;
int gomb = 8;
int zümmögés = 7;
int zászló = 1;
int selectWord;
int állat = 1;
int potValue = 0;
int maxVoltageBits = 1023;
int splitBits = maxVoltageBits / 22;
const int pot = A4;
const int rotaryInput = A5;
char ch;

char * betűk [] = {
  ".-", "-...", "-.-.", "- ..", ".", "..-.", "-.", "....", " .. "
  ".---", "-.-", ".- ..", "-", "-.", "---", ".--.", "--.-", ".-."
  "...", "-", "..-", "...-", ".--", "-..-", "-.--", "- .."} ;

char * számok [] = {
  "-----", ".----", "..---", "...--", "....-",
  ".....", "-....", "--...", "--- ..", "----."};

char * állatok3 = "hhhooocatdogantflyratowlpighenfoxemu";

érvénytelen beállítás ()
{
  pinMode (ledPinBlue, OUTPUT);
  pinMode (ledPinRed, OUTPUT);
  pinMode (ledPinGreen, OUTPUT);
  pinMode (pot, INPUT);
  pinMode (rotaryInput, INPUT);
  pinMode (gomb, INPUT);
  pinMode (csengő, OUTPUT);
  digitalWrite (ledPinRed, HIGH);
  digitalWrite (ledPinBlue, HIGH);
  digitalWrite (ledPinGreen, HIGH);
  digitalWrite (ledPinRed, LOW);
  késés (500);
  digitalWrite (ledPinRed, HIGH);
  késleltetés (100);
  digitalWrite (ledPinBlue, LOW);
  késés (500);
  digitalWrite (ledPinBlue, HIGH);
  késleltetés (100);
  digitalWrite (ledPinGreen, LOW);
  késés (500);
  digitalWrite (ledPinGreen, HIGH);
  késleltetés (100);
  digitalWrite (zümmögő, HIGH);
  késleltetés (100);
  digitalWrite (zümmögő, LOW);
  int buttonValue = digitalRead (gomb);
  if (buttonValue == 1)
  {
    selectWord = analogRead (rotaryInput);
    selectorSwitch1 (selectWord);
  }
  más
  {
    zászló = 1;
  }
}

üres hurok ()
{
  wait_for_enter ();
  selectWord = analogRead (rotaryInput);
  selectorSwitch (selectWord);
  potValue = analogRead (pot);
  dotDelay = potValue + 100;
  i = (állati * 3) -3;
  míg (j <3)
  {
    ch = állatok3 [i];
    if (ch & gt; = 'a' && ch & =; z ')
    {
      flashSequence (betűk [ch - 'a']);
    }
    egyébként, ha (ch & gt; = '0' && ch & lt; = '9')
    {
      flashSequence (betűk [ch - '0']);
    }
    egyébként ha (ch == '')
    {
      késleltetés (dotDelay * 7);
    }
    i = i + 1;
    j = j + 1;
  }
  késleltetés (dotDelay * 7);
  // toggle =! toggle; // minden szó színváltása (nem szükséges)
  j értéke 0;
}
void wait_for_enter ()
{
  int buttonValue = digitalRead (gomb);
  míg (buttonValue == 0)
  {
    buttonValue = digitalRead (gomb);
  }
}

void flashSequence (char * sorozat)
{
  int k = 0;
  míg (sorozat [k]! = '\ 0')
  {
    flashDotOrDash (sorozat [k]);
    k = k + 1;
  }
  //Serial.print ("");
  késleltetés (dotDelay * 3);
  váltás =! váltás; // szín váltás a betűk között
}

void flashDotOrDash (char dotOrDash)
{
  if (dotOrDash == '.')
  {
    if (zászló == 1)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (zümmögő, HIGH);
      késés (dotDelay);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
    }
    egyébként ha (zászló == 2)
    {
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (zümmögő, HIGH);
      késés (dotDelay);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinBlue, HIGH);
    }
    egyébként ha (zászló == 3)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (zümmögő, HIGH);
      késés (dotDelay);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinGreen, HIGH);
    }
    egyébként ha (zászló == 4)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (zümmögő, HIGH);
      késés (dotDelay);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinGreen, HIGH);
      digitalWrite (ledPinBlue, HIGH);
    }
    egyébként ha (zászló == 5)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (zümmögő, HIGH);
      késés (dotDelay);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinGreen, HIGH);
    }
    egyébként ha (zászló == 6)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (zümmögő, HIGH);
      késés (dotDelay);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinBlue, HIGH);
    }
    egyébként ha (zászló == 7)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (zümmögő, HIGH);
      késés (dotDelay);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinBlue, HIGH);
      digitalWrite (ledPinGreen, HIGH);
    }
    egyébként ha (zászló == 8)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (zümmögő, HIGH);
      késés (dotDelay);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
    }
    egyébként ha (zászló == 9)
    {
      if (váltás! = 0)
      {
        digitalWrite (ledPinRed, LOW);
        digitalWrite (zümmögő, HIGH);
        késés (dotDelay);
        digitalWrite (zümmögő, LOW);
        digitalWrite (ledPinRed, HIGH);
      }
      más
      {
        digitalWrite (ledPinBlue, LOW);
        digitalWrite (zümmögő, HIGH);
        késés (dotDelay);
        digitalWrite (zümmögő, LOW);
        digitalWrite (ledPinBlue, HIGH);
      }
    }
  }
  más
  {
    if (zászló == 1)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (zümmögő, HIGH);
      késleltetés (dotDelay * 3);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
    }
    egyébként ha (zászló == 2)
    {
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (zümmögő, HIGH);
      késleltetés (dotDelay * 3);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinBlue, HIGH);
    }
    egyébként ha (zászló == 3)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (zümmögő, HIGH);
      késleltetés (dotDelay * 3);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinGreen, HIGH);
    }
    egyébként ha (zászló == 4)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (zümmögő, HIGH);
      késleltetés (dotDelay * 3);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinGreen, HIGH);
      digitalWrite (ledPinBlue, HIGH);
    }
    egyébként ha (zászló == 5)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (zümmögő, HIGH);
      késleltetés (dotDelay * 3);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinGreen, HIGH);
    }
    egyébként ha (zászló == 6)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (zümmögő, HIGH);
      késleltetés (dotDelay * 3);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinBlue, HIGH);
    }
    egyébként ha (zászló == 7)
    {
      digitalWrite (ledPinRed, LOW);
      digitalWrite (ledPinBlue, LOW);
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (zümmögő, HIGH);
      késleltetés (dotDelay * 3);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinRed, HIGH);
      digitalWrite (ledPinBlue, HIGH);
      digitalWrite (ledPinGreen, HIGH);
    }
    egyébként ha (zászló == 8)
    {
      digitalWrite (ledPinGreen, LOW);
      digitalWrite (zümmögő, HIGH);
      késleltetés (dotDelay * 3);
      digitalWrite (zümmögő, LOW);
      digitalWrite (ledPinGreen, HIGH);
    }
    egyébként ha (zászló == 9)
    {
      if (váltás! = 0)
      {
        digitalWrite (ledPinRed, LOW);
        digitalWrite (zümmögő, HIGH);
        késleltetés (dotDelay * 3);
        digitalWrite (zümmögő, LOW);
        digitalWrite (ledPinRed, HIGH);
      }
      más
      {
        digitalWrite (ledPinBlue, LOW);
        digitalWrite (zümmögő, HIGH);
        késleltetés (dotDelay * 3);
        digitalWrite (zümmögő, LOW);
        digitalWrite (ledPinBlue, HIGH);
        
      }
    }
    
  }
  késés (dotDelay); // betűk között
  // váltás =! váltás; // váltás a karakterek között
}
void selectorSwitch1 (int AI)
{
  if ((AI> (oldAI + 10)) || (AI & lt; (oldAI - 10))) // lásd, megváltozott-e az érték?
  {
    if (AI> 11 * osztott bit) // legyen 7,8,9,10,11,12.
    {
      if (AI> 17 * osztott bit) // legyen 10,11,12.
      {
        if (AI> 21 * splitBits) // 12-nek kell lennie.
        {
          zászló = 12;
        }
        else // legyen 10.11.
        {
          if (AI> 19 * splitBits) // 11-nek kell lennie.
          {
            zászló = 11;
          }
          else // 10-nek kell lennie.
          {
           zászló = 10;
          }
        }
      }
      else // 7,8,9-nek kell lennie.
      {
        if (AI> 15 * splitBits) // 9-nek kell lennie.
        {
          zászló = 9;
        }
        else // 7.8-nak kell lennie.
        {
          if (AI> 13 * splitBits) // 8-nak kell lennie.
          {
            zászló = 8;
          }
          else // 7-nek kell lennie.
          {
            zászló = 7;
          }
        }
      }
    }
    else // 1,2,3,4,5,6-nek kell lennie.
    {
      if (AI> 5 * splitBits) // 4,5,6-nak kell lennie.
      {
        if (AI> 9 * splitBits) // 6-nak kell lennie.
        {
          zászló = 6;
        }
        else // 4,5-nek kell lennie.
        {
          if (AI> 7 * splitBits) // 5-nek kell lennie
          {
            zászló = 5;
          }
          else // 4-nek kell lennie.
          {
            zászló = 4;
          }
        }
      }
      else // 1,2,3-nak kell lennie.
      {
        if (AI> 3 * splitBits) // 3-nak kell lennie.
        {
          zászló = 3;
        }
        else // 1,2-nek kell lennie.
        {
          if (AI> splitBits) // 2-nek kell lennie.
          {
            zászló = 2;

          }
          else // 1-nek kell lennie.
          {
            zászló = 1;
          }
        }
      }
    }
  }
  oldAI = AI;
  // késleltetés (500);
  //Serial.println ();
}
void selectorSwitch (int AI)
{
  if ((AI> (oldAI + 10)) || (AI & lt; (oldAI - 10))) // lásd, megváltozott-e az érték?
  {
    if (AI> 11 * osztott bit) // legyen 7,8,9,10,11,12.
    {
      if (AI> 17 * osztott bit) // legyen 10,11,12.
      {
        if (AI> 21 * splitBits) // 12-nek kell lennie.
        {
          állat = 12;
        }
        else // legyen 10.11.
        {
          if (AI> 19 * splitBits) // 11-nek kell lennie.
          {
            állat = 11;
          }
          else // 10-nek kell lennie.
          {
           állat = 10;
          }
        }
      }
      else // 7,8,9-nek kell lennie.
      {
        if (AI> 15 * splitBits) // 9-nek kell lennie.
        {
          állat = 9;
        }
        else // 7.8-nak kell lennie.
        {
          if (AI> 13 * splitBits) // 8-nak kell lennie.
          {
            állat = 8;
          }
          else // 7-nek kell lennie.
          {
            állat = 7;
          }
        }
      }
    }
    else // 1,2,3,4,5,6-nek kell lennie.
    {
      if (AI> 5 * splitBits) // 4,5,6-nak kell lennie.
      {
        if (AI> 9 * splitBits) // 6-nak kell lennie.
        {
          állat = 6;
        }
        else // 4,5-nek kell lennie.
        {
          if (AI> 7 * splitBits) // 5-nek kell lennie
          {
            állat = 5;
          }
          else // 4-nek kell lennie.
          {
            állat = 4;
          }
        }
      }
      else // 1,2,3-nak kell lennie.
      {
        if (AI> 3 * splitBits) // 3-nak kell lennie.
        {
          állat = 3;
        }
        else // 1,2-nek kell lennie.
        {
          if (AI> splitBits) // 2-nek kell lennie.
          {
            állat = 2;

          }
          else // 1-nek kell lennie.
          {
            állat = 1;
          }
        }
      }
    }
  }
  oldAI = AI;
  // késleltetés (500);
  //Serial.println ();
}

Ha megismételted a mester után, most a kezedben van ugyanaz a játék, amellyel érdeklődhetsz gyermekeitek mellett Morse-kódban. És mikor felnőnek, a firmware egyszerű átalakításával alapot kaphat egy szokásos automatikus "róka" -hoz, amely MOE, MOI, MOS, MOH vagy MO5 választást továbbít, négy percenként egy percre bekapcsolva.

Ui különösen az unalmas emberek számára, akik hibákat találnak a címsorral: az állatok az állatok, a madarak és a rovarok együttes neve.

2018. november 6-án, 01:23 0

válasz Idézni panasz

Idézet: tormozedison

távolítsa el a bipoláris irányváltó kapcsolót?

Igen, hagyjon egy pólusú kapcsolót az akkumulátor és a Step-Up modul között.

2018. november 5-én, 11:40 A szerző 0

Értem. Egy ilyen modul tehát nemcsak az akkumulátort védi a túltöltéstől,de lehetővé tenné a bipoláris irányváltó kapcsoló eltávolítását?

Most, ha megismételtem ezt a dolgot, akkor általában egyszerűen csatlakoztatnám a vezetéket a hálózati bankhoz, elhagyva a belső akkumulátort. És hozzátennék az RTC-t és a Morse óra funkciót.

2018. november 5-én, 11:19 0

A képen látható képet szánták csak töltőkhöz. Itt nemcsak a töltést, hanem a kisütést is ellenőriznie kell. A táblán a TP4056 mellett további IC-re van szükség, mint például a DW01, és a kulcsokhoz. Ennek megfelelően nem 4 érintkező vezetékes csatlakoztatásra, hanem 6. Lehet, hogy az erősítő modul megvédi az akkumulátort, ha hirtelen 2,7 ... 2,8 V feszültséggel működik, de nem tudunk semmit annak paramétereiről, és számítunk " balra "hatások nem megfelelőek.

2018. november 5, 21:19 A szerző 0

Mondja el, miért rossz az ilyen típusú töltővezérlő, és melyik a jobb?

2018. november 5-én, 20:51 0

Az ellenállások csúnya forrasztása a kekszen és a helytelen akkumulátor töltésvezérlő.

2018. november 5-én, 09:34 -3

De csak a cím hibás? De a szerző nem rendelkezik műveltséggel?

Játék "Animal Names Morse Code"

Adj hozzá egy megjegyzést

DIY kategóriák