Programmering og koding

Trådløs morsesender: lær morsekode og bygg den med to M5StickS3

Fotorealistisk illustrasjon av to M5StickS3 og et Neo Hex-panel med rødt hjerte på en skolepult, ved siden av et ark med morsetegn

Morsealfabetet gjør bokstaver om til korte og lange signaler: prikker og streker. I denne guiden lærer du hele alfabetet med Æ, Ø og Å, og du bygger en trådløs morsesender med to M5StickS3. Når du holder knappen inne på den ene, piper den andre. Programmet oversetter prikkene og strekene dine til bokstaver på skjermen, og til slutt sender dere ikoner som lyser på et sekskantet lyspanel. Du trenger ikke å lodde, og du trenger verken ruter eller internett.

To M5StickS3 som sender morse trådløst til hverandre, med tekst på skjermene og et hjerte på Neo Hex-panelet
Ferdig prosjekt: to M5StickS3 sender morse til hverandre med ESP-NOW. Skjermen viser bokstavene, og Neo Hex viser et ikon.
Kort forklartI morsealfabetet er E en prikk, T en strek og SOS tre prikker, tre streker og tre prikker. En strek varer like lenge som tre prikker. Med to M5StickS3 og Arduino IDE lager du en morsesender der knapp A er morsenøkkelen. Signalet går rett mellom enhetene med ESP-NOW. Nivå 1 gir lyd, nivå 2 gjør morse om til tekst, og nivå 3 legger til ikoner på Neo Hex.
Nivå
Nybegynner, fra omtrent 10 år sammen med en voksen
Tid
Omtrent 45 minutter til første pip, en dobbelttime for alle tre nivåene
Lodding
Nei, alt kobles med én kabel
Du lærer
Morsealfabetet, trådløs kommunikasjon, tidsmåling i kode og styring av lysdioder

Dette trenger du

  • Oransje M5StickS3 med fargeskjerm og blå knapp
    M5StickS32 stk, alle nivåer. Skjerm, høyttaler, batteri og radio er innebygd.
    kr 489,00
    På lager
  • Sekskantet Neo Hex-panel med 37 lysdioder
    M5Stack Neo Hex1 eller 2 stk, nivå 3. En Grove-kabel på 20 cm følger med.
    kr 399,00
    På lager
  • Grove-kabel med fire ledninger og hvite plugger
    Grove-kabler, 20 cmValgfritt, greit å ha i reserve til et klassesett
    kr 119,00
    På lager

I tillegg trenger du en datamaskin med Arduino IDE og en USB-C-kabel som kan overføre data. M5StickS3 leveres uten kabel, og noen USB-C-kabler er bare ladekabler. Finner ikke datamaskinen enheten, er kabelen det første du bør bytte.

Hva er morsealfabetet?

Morsealfabetet er en kode der hver bokstav og hvert tall har sitt eget mønster av korte og lange signaler. Det korte signalet kalles prikk, og det lange kalles strek. Mønstrene kan sendes som lyd, lys, strømpulser i en ledning eller radiobølger. Derfor virker morse med alt fra en lommelykt til en radiosender.

Koden har navn etter amerikaneren Samuel Morse. Han bygde sitt første telegrafapparat i 1835, og i 1844 gikk det første telegrammet mellom Washington og Baltimore. Norge fikk sin første telegraflinje mellom Christiania, som Oslo het den gangen, og Drammen i 1855. I over hundre år var morse den viktigste måten å sende meldinger langt og raskt på, særlig til sjøs. Fra 1999 tok satellitter og digitale systemer over nødsambandet for skip, men radioamatører og speidere bruker fortsatt morse.

Dagens internasjonale morsealfabet er fastsatt av Den internasjonale teleunionen (ITU) i anbefalingen ITU-R M.1677-1. Der finner du A til Z, tallene og noen skilletegn. De norske bokstavene Æ, Ø og Å står ikke i den internasjonale tabellen, men har egne koder som brukes i Norge.

Tabell over morsealfabetet med prikker og streker for bokstavene A til Å og tallene 0 til 9
Morsealfabetet fra A til Å og tallene 0 til 9. Skriv gjerne ut tabellen og ha den ved siden av deg.

Her er den samme tabellen som tekst. Punktum er prikk, og bindestrek er strek. Akkurat slik står kodene også i programmet lenger ned.

TegnKodeTegnKodeTegnKodeTegnKode
A.-K-.-U..-1.----
B-...L.-..V...-2..---
C-.-.M--W.--3...--
D-..N-.X-..-4....-
E.O---Y-.--5.....
F..-.P.--.Z--..6-....
G--.Q--.-Æ.-.-7--...
H....R.-.Ø---.8---..
I..S...Å.--.-9----.
J.---T-?..--..0-----

Legg merke til at de vanligste bokstavene har de korteste kodene. E er bare en prikk, og T er bare en strek. Sjeldne bokstaver som Q og Y har fire signaler. Slik går det raskere å sende vanlig tekst. Tallene følger et fast mønster med fem signaler: 1 har én prikk og fire streker, 2 har to prikker og tre streker, og slik fortsetter det til 5, som er fem prikker. Fra 6 snur mønsteret.

Rytmen: prikk, strek og pauser

Morse er rytme. Det er ikke nok å vite at A er prikk og strek. Mottakeren må også høre hvor en bokstav slutter og den neste begynner. Derfor har morse faste regler for lengdene, og alt måles i prikker:

  • En strek varer like lenge som tre prikker.
  • Pausen mellom signalene i samme bokstav er én prikk.
  • Pausen mellom to bokstaver er tre prikker.
  • Pausen mellom to ord er sju prikker.
Tidslinje som viser lengden på prikk, strek og pausene mellom signaler, bokstaver og ord i morse
Alle lengder måles i prikker. Her ser du ordet SOS og begynnelsen på et nytt ord.

Farten i morse måles i ord per minutt. Som målestokk brukes ordet PARIS, som er nøyaktig 50 prikker langt når pausen etter ordet regnes med. Sender du fem ord i minuttet, varer en prikk 240 millisekunder. Det er et fint tempo å begynne med. Øvede telegrafister klarer over 20 ord i minuttet, og da varer en prikk bare 60 millisekunder.

Slik lærer du morse

Den vanligste feilen er å lære tabellen med øynene og telle prikker og streker. Da må hjernen gå en omvei hver gang. Lær heller lyden av hver bokstav. Si prikk som «di» og strek som «da». A blir «di-da», N blir «da-di», og SOS blir «di-di-di da-da-da di-di-di». Etter en stund kjenner du igjen hele lyden, omtrent som du kjenner igjen en ringetone.

  1. Begynn med få bokstaver. Start med E, T, I, M, S og O. Da kan du allerede sende SOS, og du kjenner forskjellen på korte og lange signaler.
  2. Legg til én bokstav om gangen. Ta en ny bokstav når du klarer nesten alle de gamle. Denne framgangsmåten kalles Koch-metoden.
  3. Send bokstavene raskt, men ta lange pauser. Send selve bokstaven i vanlig tempo, men vent lenge før den neste. Da lærer du lyden riktig fra starten. Dette kalles Farnsworth-metoden.
  4. Øv kort og ofte. Ti minutter hver dag gir mer enn en time én gang i uken.

Morsetreet under er en fin hjelp når du skal lese morse. Start øverst. Gå til venstre for hver prikk og til høyre for hver strek. Bokstaven du lander på, er svaret. Prikk, strek, prikk fører deg for eksempel til E, så A og til slutt R.

Morsetre der prikk fører til venstre og strek til høyre, med bokstavene fra E og T ned til fire signaler
Morsetreet: gå til venstre for prikk og til høyre for strek. Jo lenger ned, jo lengre kode.

Bli kjent med M5StickS3

M5StickS3 er en liten, ferdig datamaskin med ESP32-S3, fargeskjerm, høyttaler, batteri og radio i samme boks. I dette prosjektet bruker du tre knapper og to porter:

  • Knapp A er den store knappen på forsiden. Den er morsenøkkelen din: knappen du sender prikker og streker med. Å sende morse med en nøkkel kalles å nøkle.
  • Knapp B sitter på siden. Den tømmer skjermen i nivå 2 og sender ikoner i nivå 3.
  • Strømknappen sitter på den andre siden. Ett trykk slår enheten på eller starter den på nytt, og to raske trykk slår den av.
  • USB-C brukes til lading og til å laste opp programmet.
  • Grove-porten ved siden av USB-C brukes til Neo Hex i nivå 3.
M5StickS3 sett forfra med knapp A, knapp B, strømknapp, skjerm, USB-C og Grove-port merket med navn
Knappene og portene du bruker. I prosjektet ligger M5StickS3 på siden, slik at skjermen blir bred.

Gjør klar Arduino IDE

Programmene skrives i Arduino IDE, som er gratis. Oppsettet under gjør du bare én gang på hver datamaskin. Menyene har engelske navn, slik de står i Arduino IDE.

  1. Installer Arduino IDE. Last ned versjon 2 fra arduino.cc og installer den.
  2. Legg til M5Stack-kortene. Åpne File > Preferences. Lim inn adressen under i feltet Additional boards manager URLs, og trykk OK.
  3. Installer kortpakken. Åpne Tools > Board > Boards Manager, søk etter M5Stack og trykk Install. Dette tar noen minutter.
  4. Installer bibliotekene. Åpne Tools > Manage Libraries. Søk etter M5Unified, trykk Install og velg Install all, slik at M5GFX følger med. Installer deretter FastLED. Det biblioteket trenger du i nivå 3.
  5. Velg kort og port. Koble til en M5StickS3 med USB-C. Velg Tools > Board > M5Stack > M5StickS3, og velg porten som dukker opp under Tools > Port.
https://static-cdn.m5stack.com/resource/arduino/package_m5stack_index.json

Alle programmene i guiden er kompilert med versjonene i tabellen. Nyere versjoner skal også virke. Versjoner som er eldre enn dem i høyre kolonne, kjenner ikke M5StickS3.

PakkeKompilert medEldste som støtter M5StickS3
M5Stack-kortpakken3.3.103.2.5
M5Unified0.3.00.2.12
M5GFX0.3.00.2.18
FastLED3.10.9Bare nødvendig i nivå 3

Nivå 1: trådløs morsenøkkel

Nivå 1: nybegynner. Tid: 45 minutter med installasjon. Du trenger to M5StickS3, en USB-C-kabel som kan overføre data, og en datamaskin med Arduino IDE.

Det første programmet gjør én ting: Når du holder knapp A inne på den ene enheten, piper begge. Din egen enhet piper med en lys tone, og den andre svarer med en mørkere tone. Slik hører dere hvem som sender.

  1. Lag et nytt program i Arduino IDE med File > New Sketch. Arduino kaller programmene skisser. Slett alt som står der.
  2. Kopier hele programmet under og lim det inn.
  3. Trykk på pilen Upload. Vent til det står Done uploading nederst.
  4. Koble fra den første enheten, koble til den andre og trykk Upload en gang til. Begge skal ha nøyaktig det samme programmet.
// Trådløs morsenøkkel, nivå 1: hold knapp A inne, og begge M5StickS3 piper.
#include <M5Unified.h>
#include <WiFi.h>
#include <esp_now.h>

const uint8_t GRUPPE = 1;   // samme tall på de to som hører sammen (1 til 255)
const uint8_t KANAL = 1;    // WiFi-kanal, lik på alle
const int TONE_MIN = 700;   // Hz, tonen når du sender selv
const int TONE_DIN = 520;   // Hz, tonen når den andre sender

const uint8_t ALLE[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
enum Type : uint8_t { TONE_AV = 0, TONE_PA = 1 };

struct Melding {
  char merke[2];    // alltid 'M' og 'S', så vi kjenner igjen våre egne meldinger
  uint8_t gruppe;
  uint8_t type;
  uint8_t nummer;   // brukes fra nivå 2
  char tegn[3];     // brukes fra nivå 2
};

M5Canvas lerret(&M5.Display);
volatile uint32_t mottarTil = 0;   // den andre sender fram til dette tidspunktet
uint32_t sistSendt = 0;
int tilstand = -1;                 // 0 = stille, 1 = du sender, 2 = du mottar

// ===== Skjermtegning =====
const uint32_t BAKGRUNN = 0x101418, HVIT = 0xFFFFFF, GRA = 0x39424A, ORANSJE = 0xEF7D22, BLA = 0x2F6FD0;

void tegnSkjerm(int tilstand) {
  const uint32_t farge[] = {GRA, ORANSJE, BLA};
  const char *tekst[] = {"Hold knapp A inne", "Du sender", "Du mottar"};
  char gruppe[16];
  snprintf(gruppe, sizeof(gruppe), "Gruppe %d", GRUPPE);

  lerret.fillScreen(BAKGRUNN);
  lerret.setTextColor(HVIT);
  lerret.setFont(&fonts::lgfxJapanGothicP_20);
  lerret.setTextDatum(top_left);
  lerret.drawString("Morse", 8, 6);
  lerret.setTextDatum(top_right);
  lerret.drawString(gruppe, 232, 6);
  lerret.fillCircle(120, 68, 28, farge[tilstand]);
  lerret.setTextDatum(bottom_center);
  lerret.drawString(tekst[tilstand], 120, 131);
}
// ===== Slutt skjermtegning =====

// Kjøres hver gang en ESP-NOW-melding kommer inn.
void mottatt(const esp_now_recv_info_t *info, const uint8_t *data, int lengde) {
  if (lengde != sizeof(Melding)) return;
  Melding m;
  memcpy(&m, data, sizeof(m));
  if (m.merke[0] != 'M' || m.merke[1] != 'S' || m.gruppe != GRUPPE) return;
  if (m.type == TONE_PA) mottarTil = millis() + 150;
  if (m.type == TONE_AV) mottarTil = 0;
}

void send(uint8_t type) {
  Melding m = {{'M', 'S'}, GRUPPE, type, 0, {0, 0, 0}};
  esp_now_send(ALLE, (const uint8_t *)&m, sizeof(m));
}

void setup() {
  auto cfg = M5.config();
  M5.begin(cfg);
  M5.Display.setRotation(1);          // liggende skjerm, 240 x 135 piksler
  lerret.createSprite(240, 135);
  M5.Speaker.setVolume(120);

  WiFi.mode(WIFI_STA);
  WiFi.setChannel(KANAL);
  while (!WiFi.STA.started()) delay(100);
  esp_now_init();
  esp_now_register_recv_cb(mottatt);
  esp_now_peer_info_t alle = {};
  memcpy(alle.peer_addr, ALLE, 6);    // adressen FF:FF:FF:FF:FF:FF betyr «til alle»
  esp_now_add_peer(&alle);
}

void loop() {
  M5.update();
  uint32_t na = millis();
  bool nede = M5.BtnA.isPressed();

  if (nede && na - sistSendt >= 40) {   // gjenta «tone på» 25 ganger i sekundet
    send(TONE_PA);
    sistSendt = na;
  }
  if (M5.BtnA.wasReleased()) {
    send(TONE_AV);
    send(TONE_AV);
  }

  int ny = nede ? 1 : (na < mottarTil ? 2 : 0);
  if (ny != tilstand) {
    tilstand = ny;
    if (tilstand == 1) M5.Speaker.tone(TONE_MIN);
    else if (tilstand == 2) M5.Speaker.tone(TONE_DIN);
    else M5.Speaker.stop();
    tegnSkjerm(tilstand);
    lerret.pushSprite(0, 0);
  }
  delay(5);
}

Skjermen viser hva som skjer. Sirkelen er grå når det er stille, oransje når du sender, og blå når du mottar.

Tre skjermbilder fra nivå 1 som viser grå sirkel når det er stille, oransje når du sender og blå når du mottar
Skjermen i nivå 1, tegnet av det samme programmet som du laster opp: stille, du sender og du mottar.

Slik virker det

M5StickS3 sender med ESP-NOW. Det er et sett med regler for radiomeldinger, en protokoll, fra Espressif, som lager brikken inne i enheten. ESP-NOW bruker den samme radioen som WiFi på 2,4 GHz, men trenger ingen ruter, ikke noe passord og ikke noe internett. Enhetene sender korte meldinger rett til hverandre.

Meldingen i programmet heter Melding og er bare åtte byte lang. De to første bytene er alltid bokstavene M og S. Slik kjenner programmet igjen sine egne meldinger og hopper over alt annet som måtte fly gjennom luften. Så kommer gruppenummeret og typen: TONE_PA eller TONE_AV.

Mens du holder knappen inne, sender programmet «tone på» 25 ganger i sekundet. Mottakeren piper så lenge slike meldinger kommer, og slutter 150 millisekunder etter den siste. Det er lurt av to grunner. Blir en enkelt melding borte på veien, merker du ingenting. Og blir meldingen «tone av» borte, slutter pipingen likevel av seg selv.

Flere par i samme rom

Programmet sender til adressen FF:FF:FF:FF:FF:FF. Det betyr «til alle som lytter». Fordelen er at du slipper å finne og skrive inn adressen til den andre enheten. Ulempen er at alle i rommet hører alle. Derfor har programmet et gruppenummer. To enheter med samme tall i GRUPPE hører hverandre, og meldinger fra andre grupper blir hoppet over.

To par med M5StickS3 i samme klasserom der gruppe 1 og gruppe 2 sender uten å forstyrre hverandre
Hvert par velger sitt eget gruppenummer, og da forstyrrer ikke parene hverandre.

I et klasserom gir du hvert par sitt eget tall fra 1 til 255. Endre linjen const uint8_t GRUPPE = 1; før du laster opp, og skriv gjerne tallet på en lapp som teipes på enheten. I nivå 1 står tallet også øverst til høyre på skjermen. Vil hele klassen høre samme melding, bruker alle det samme tallet.

Nivå 2: fra prikker og streker til bokstaver

Nivå 2: litt øvet. Tid: 20 minutter. Du trenger oppsettet fra nivå 1. Ingen nye deler.

Nå skal programmet forstå hva du sender. Det måler hvor lenge knappen er inne og hvor lange pausene er, og gjør mønsteret om til bokstaver. Det du sender, står under «Du». Det den andre sender, står under «Mottatt». Lyden virker som før, så dere kan lytte først og sjekke på skjermen etterpå.

Den delen av programmet som gjør trykkene om til bokstaver, kalles dekoderen. Den bruker tre grenser:

  • Et trykk som er kortere enn 300 millisekunder, blir en prikk. Et lengre trykk blir en strek.
  • Venter du 900 millisekunder uten å trykke, er bokstaven ferdig.
  • Venter du i 2,1 sekunder, kommer det et mellomrom, og du begynner på et nytt ord.
Tidslinje som viser grensene dekoderen bruker for prikk, strek, ferdig bokstav og mellomrom mellom ord
Grensene i dekoderen. Trykk kortere enn 300 ms blir prikk, og 900 ms pause avslutter bokstaven.

Grensene er romsligere enn i ekte morse, slik at nybegynnere får tid til å tenke. Mens du nøkler, viser skjermen prikkene og strekene dine nederst. Når bokstaven er ferdig, flytter den seg opp på linjen over. Et mønster som ikke finnes i tabellen, vises som en stjerne.

Tre skjermbilder fra nivå 2 der prikker og streker nederst blir til bokstavene SOS og svaret HEI kommer inn
Skjermen i nivå 2: du nøkler, bokstaven blir ferdig, og svaret fra den andre kommer inn under «Mottatt».

Last opp programmet under til begge enhetene, akkurat som i nivå 1. Husk å sette samme GRUPPE på de to som hører sammen.

Hele programmet for nivå 2
// Trådløs morse med dekoder, nivå 2: bokstavene du nøkler, vises på begge M5StickS3.
#include <M5Unified.h>
#include <WiFi.h>
#include <esp_now.h>

const uint8_t GRUPPE = 1;                // samme tall på de to som hører sammen
const uint8_t KANAL = 1;                 // WiFi-kanal, lik på alle
const int TONE_MIN = 700;                // Hz, tonen når du sender selv
const int TONE_DIN = 520;                // Hz, tonen når den andre sender
const uint16_t STREK_FRA_MS = 300;       // trykk som varer minst så lenge, blir strek
const uint16_t BOKSTAV_PAUSE_MS = 900;   // så lang pause avslutter bokstaven
const uint16_t ORD_PAUSE_MS = 2100;      // så lang pause gir mellomrom
const int MAKS_TEGN = 18;                // så mange tegn får plass på en linje

// ===== Morsekjerne =====
struct MorseTegn {
  const char *tegn;
  const char *kode;   // . = prikk, - = strek
};

// Bokstaver og tall fra ITU-R M.1677-1, pluss de norske bokstavene Æ, Ø og Å.
const MorseTegn MORSE[] = {
  {"A", ".-"},    {"B", "-..."},  {"C", "-.-."},  {"D", "-.."},   {"E", "."},
  {"F", "..-."},  {"G", "--."},   {"H", "...."},  {"I", ".."},    {"J", ".---"},
  {"K", "-.-"},   {"L", ".-.."},  {"M", "--"},    {"N", "-."},    {"O", "---"},
  {"P", ".--."},  {"Q", "--.-"},  {"R", ".-."},   {"S", "..."},   {"T", "-"},
  {"U", "..-"},   {"V", "...-"},  {"W", ".--"},   {"X", "-..-"},  {"Y", "-.--"},
  {"Z", "--.."},  {"Æ", ".-.-"},  {"Ø", "---."},  {"Å", ".--.-"},
  {"1", ".----"}, {"2", "..---"}, {"3", "...--"}, {"4", "....-"}, {"5", "....."},
  {"6", "-...."}, {"7", "--..."}, {"8", "---.."}, {"9", "----."}, {"0", "-----"},
  {"?", "..--.."},
};
const int MORSE_ANTALL = sizeof(MORSE) / sizeof(MORSE[0]);

// Finn tegnet som hører til en kode. Ukjent kode gir "*".
const char *morseTilTegn(const char *kode) {
  for (int i = 0; i < MORSE_ANTALL; i++) {
    if (strcmp(MORSE[i].kode, kode) == 0) return MORSE[i].tegn;
  }
  return "*";
}

// Dekoderen får beskjed når knappen går ned og opp, og blir spurt jevnlig med sjekk().
class MorseDekoder {
 public:
  MorseDekoder(uint16_t strekFraMs, uint16_t bokstavPauseMs, uint16_t ordPauseMs)
      : strekFra(strekFraMs), bokstavPause(bokstavPauseMs), ordPause(ordPauseMs) {}

  void ned(uint32_t na) {
    nede = true;
    nedTid = na;
  }

  // Knappen er sluppet: et kort trykk blir prikk, et langt blir strek.
  char opp(uint32_t na) {
    if (!nede) return 0;
    nede = false;
    char symbol = (na - nedTid >= strekFra) ? '-' : '.';
    if (lengde < sizeof(kode) - 1) {
      kode[lengde++] = symbol;
      kode[lengde] = 0;
    }
    sistOpp = na;
    venterBokstav = true;
    venterOrd = false;
    return symbol;
  }

  // Gir et ferdig tegn, " " for nytt ord, eller nullptr når ingenting er klart.
  const char *sjekk(uint32_t na) {
    if (nede) return nullptr;
    if (venterBokstav && na - sistOpp >= bokstavPause) {
      const char *tegn = morseTilTegn(kode);
      kode[0] = 0;
      lengde = 0;
      venterBokstav = false;
      venterOrd = true;
      return tegn;
    }
    if (venterOrd && na - sistOpp >= ordPause) {
      venterOrd = false;
      return " ";
    }
    return nullptr;
  }

  const char *pagaende() const { return kode; }   // prikker og streker hittil

 private:
  uint16_t strekFra, bokstavPause, ordPause;
  char kode[8] = "";
  uint8_t lengde = 0;
  bool nede = false, venterBokstav = false, venterOrd = false;
  uint32_t nedTid = 0, sistOpp = 0;
};
// ===== Slutt morsekjerne =====

const uint8_t ALLE[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
enum Type : uint8_t { TONE_AV = 0, TONE_PA = 1, TEGN = 2 };

struct Melding {
  char merke[2];    // alltid 'M' og 'S'
  uint8_t gruppe;
  uint8_t type;
  uint8_t nummer;   // øker for hvert tegn, så mottakeren kan hoppe over kopier
  char tegn[3];     // ett tegn som UTF-8 (Æ, Ø og Å bruker to byte)
};

M5Canvas lerret(&M5.Display);
MorseDekoder dekoder(STREK_FRA_MS, BOKSTAV_PAUSE_MS, ORD_PAUSE_MS);
QueueHandle_t innboks;             // tegn som har kommet inn, venter her til loop() henter dem
volatile uint32_t mottarTil = 0;   // den andre sender fram til dette tidspunktet
String sendtTekst, mottattTekst;
uint32_t sistSendt = 0;
uint8_t mittNummer = 0;
int sistNummer = -1;
int tilstand = -1;                 // 0 = stille, 1 = du sender, 2 = du mottar

// ===== Skjermtegning =====
const uint32_t BAKGRUNN = 0x101418, HVIT = 0xFFFFFF, GRA = 0x8B9299, ORANSJE = 0xEF7D22, BLA = 0x2F6FD0;

void tegnSkjerm(const char *sendt, const char *mottatt, const char *kode, int tilstand) {
  lerret.fillScreen(BAKGRUNN);
  lerret.setTextDatum(top_left);
  lerret.setFont(&fonts::lgfxJapanGothicP_16);
  lerret.setTextColor(ORANSJE);
  lerret.drawString("Du", 8, 4);
  lerret.setTextColor(BLA);
  lerret.drawString("Mottatt", 8, 54);
  lerret.setFont(&fonts::lgfxJapanGothic_24);
  lerret.setTextColor(HVIT);
  lerret.drawString(sendt, 8, 22);
  lerret.drawString(mottatt, 8, 72);

  int x = 8;                               // koden du holder på med, tegnet som prikker og streker
  for (const char *k = kode; *k; k++) {
    if (*k == '.') {
      lerret.fillCircle(x + 6, 118, 6, ORANSJE);
      x += 20;
    } else {
      lerret.fillRoundRect(x, 112, 30, 12, 6, ORANSJE);
      x += 38;
    }
  }
  if (tilstand == 1) lerret.fillCircle(224, 118, 8, ORANSJE);
  if (tilstand == 2) lerret.fillCircle(224, 118, 8, BLA);
  if (tilstand == 0) lerret.drawCircle(224, 118, 8, GRA);
}
// ===== Slutt skjermtegning =====

// Legg et tegn til en linje og fjern det eldste når linjen er full.
void leggTil(String &linje, const char *tegn) {
  linje += tegn;
  int antall = 0;
  for (size_t i = 0; i < linje.length(); i++) {
    if ((linje[i] & 0xC0) != 0x80) antall++;      // tell tegn, ikke byte
  }
  if (antall > MAKS_TEGN) linje.remove(0, (linje[0] & 0x80) ? 2 : 1);
}

// Kjøres hver gang en ESP-NOW-melding kommer inn.
void mottatt(const esp_now_recv_info_t *info, const uint8_t *data, int lengde) {
  if (lengde != sizeof(Melding)) return;
  Melding m;
  memcpy(&m, data, sizeof(m));
  if (m.merke[0] != 'M' || m.merke[1] != 'S' || m.gruppe != GRUPPE) return;
  m.tegn[2] = 0;                      // et tegn er aldri lengre enn to byte, den tredje avslutter teksten
  if (m.type == TONE_PA) mottarTil = millis() + 150;
  if (m.type == TONE_AV) mottarTil = 0;
  if (m.type == TEGN) xQueueSend(innboks, &m, 0);
}

void send(uint8_t type, const char *tegn) {
  Melding m = {{'M', 'S'}, GRUPPE, type, mittNummer, {0, 0, 0}};
  strncpy(m.tegn, tegn, 2);
  esp_now_send(ALLE, (const uint8_t *)&m, sizeof(m));
}

void setup() {
  auto cfg = M5.config();
  M5.begin(cfg);
  M5.Display.setRotation(1);          // liggende skjerm, 240 x 135 piksler
  lerret.createSprite(240, 135);
  M5.Speaker.setVolume(120);
  innboks = xQueueCreate(16, sizeof(Melding));
  mittNummer = esp_random();          // tilfeldig start, så en omstart ikke ser ut som en kopi

  WiFi.mode(WIFI_STA);
  WiFi.setChannel(KANAL);
  while (!WiFi.STA.started()) delay(100);
  esp_now_init();
  esp_now_register_recv_cb(mottatt);
  esp_now_peer_info_t alle = {};
  memcpy(alle.peer_addr, ALLE, 6);    // adressen FF:FF:FF:FF:FF:FF betyr «til alle»
  esp_now_add_peer(&alle);
}

void loop() {
  M5.update();
  uint32_t na = millis();
  bool endret = false;

  if (M5.BtnA.wasPressed()) dekoder.ned(na);
  if (M5.BtnA.wasReleased()) {
    dekoder.opp(na);
    send(TONE_AV, "");
    send(TONE_AV, "");
    endret = true;
  }
  if (M5.BtnA.isPressed() && na - sistSendt >= 40) {
    send(TONE_PA, "");
    sistSendt = na;
  }
  if (M5.BtnB.wasPressed()) {          // knapp B tømmer skjermen
    sendtTekst = "";
    mottattTekst = "";
    endret = true;
  }

  const char *ferdig = dekoder.sjekk(na);
  if (ferdig) {
    leggTil(sendtTekst, ferdig);
    mittNummer++;
    send(TEGN, ferdig);
    send(TEGN, ferdig);                // to ganger, i tilfelle den første forsvinner
    endret = true;
  }

  Melding m;
  while (xQueueReceive(innboks, &m, 0)) {
    if (m.nummer == sistNummer) continue;   // kopi av et tegn vi allerede har
    sistNummer = m.nummer;
    leggTil(mottattTekst, m.tegn);
    endret = true;
  }

  int ny = M5.BtnA.isPressed() ? 1 : (na < mottarTil ? 2 : 0);
  if (ny != tilstand) {
    tilstand = ny;
    if (tilstand == 1) M5.Speaker.tone(TONE_MIN);
    else if (tilstand == 2) M5.Speaker.tone(TONE_DIN);
    else M5.Speaker.stop();
    endret = true;
  }
  if (endret) {
    tegnSkjerm(sendtTekst.c_str(), mottattTekst.c_str(), dekoder.pagaende(), tilstand);
    lerret.pushSprite(0, 0);
  }
  delay(5);
}

Slik virker dekoderen

Selve morsetabellen ligger i listen MORSE, med ett par for hvert tegn: bokstaven og koden skrevet med punktum og bindestrek. Klassen MorseDekoder får beskjed hver gang knappen går ned og opp. Den regner ut hvor lenge trykket varte, legger til en prikk eller en strek og venter på pausen som forteller at bokstaven er ferdig. Da slår funksjonen morseTilTegn opp koden i tabellen.

Den ferdige bokstaven sendes som en egen melding av typen TEGN. Den sendes to ganger, i tilfelle den første blir borte. Hver bokstav har et nummer, slik at mottakeren ser at kopien er en kopi og ikke skriver bokstaven dobbelt. Æ, Ø og Å bruker to byte hver i UTF-8, og derfor har meldingen plass til tre byte i feltet tegn.

Meldingene kommer inn i en egen del av programmet, den som tar seg av radioen. Den delen kan ikke tegne trygt på skjermen. Funksjonen mottatt legger derfor bokstaven i en kø, og loop() henter den ut når den har tid. Slike køer bruker du ofte når to ting skjer samtidig i et program.

Tilpass tempoet

Går det for sakte, eller blir bokstavene delt i to? Endre de tre grensene øverst i programmet. En god regel er å bestemme hvor lang prikken din skal være, og regne ut resten derfra.

TempoPrikkSTREK_FRA_MSBOKSTAV_PAUSE_MSORD_PAUSE_MS
Nybegynner, slik koden stårOpptil 300 ms3009002100
Rolig250 ms5006251500
Middels150 ms300375900
Rask120 ms240300720

I de tre nederste radene er grensen for strek to prikker, pausen etter en bokstav to og en halv prikk, og pausen etter et ord seks prikker. Da må du holde rytmen fra reglene lenger opp: strek som tre prikker, tre prikker pause mellom bokstaver og sju mellom ord.

Nivå 3: ikoner på Neo Hex

Nivå 3: viderekommen. Tid: 30 minutter. Du trenger oppsettet fra nivå 2 og ett eller to Neo Hex-paneler. Grove-kabelen følger med panelet.

Neo Hex er et sekskantet panel med 37 flerfargede lysdioder. Hver lysdiode kan få sin egen farge, og alle styres gjennom én ledning. I nivå 3 sender et kort trykk på knapp B et ikon til den andre: hjerte, smilefjes, ja, nei, sol eller snø. Ikonet lyser på begge panelene, og navnet står øverst til høyre på skjermen. Mens noen sender morse, blinker den midterste raden i takt.

Koble til panelet

  1. Slå av M5StickS3 med to raske trykk på strømknappen.
  2. Snu Neo Hex og finn de hvite kontaktene på baksiden. De er merket IN og OUT.
  3. Sett den ene enden av Grove-kabelen i en kontakt merket IN. Pluggen passer bare én vei.
  4. Sett den andre enden i Grove-porten på M5StickS3, ved siden av USB-C.
Koblingstegning der en Grove-kabel går fra porten på M5StickS3 til kontakten merket IN på Neo Hex
Én kabel er hele koblingen: svart er jord, rød er 5 V og gul er signal. Den hvite ledningen brukes ikke.
Hold lysstyrken lav. Lysdiodene er svært sterke når du ser rett på dem, og 37 lysdioder på full styrke trekker mer strøm enn Grove-porten skal levere. Programmet bruker derfor lysstyrke 24 av 255 og begrenser strømmen. La LYSSTYRKE være lav, og ikke se rett inn i panelet på kort avstand.

Test panelet først

Last opp det lille testprogrammet under før du går videre. Det tenner lysdiodene én og én i den rekkefølgen programmet teller dem, og viser nummeret på skjermen. Den første lysdioden i hver rad lyser rødt, og resten lyser grønt.

// Test av Neo Hex: lysdiodene tennes én og én i den rekkefølgen programmet teller dem.
#include <M5Unified.h>
#include <FastLED.h>

const uint8_t HEX_PINNE = 9;    // gul ledning i Grove-porten på M5StickS3
const uint8_t RAD_START[7] = {0, 4, 9, 15, 22, 28, 33};

CRGB dioder[37];

void setup() {
  auto cfg = M5.config();
  M5.begin(cfg);
  M5.Display.setRotation(1);
  M5.Display.setFont(&fonts::lgfxJapanGothicP_24);
  M5.Power.setExtOutput(true);  // slå på 5 V i Grove-porten
  FastLED.addLeds<WS2812B, HEX_PINNE, GRB>(dioder, 37);
  FastLED.setBrightness(24);
}

void loop() {
  FastLED.clear();
  for (int nr = 0; nr < 37; nr++) {
    bool forstIRaden = false;
    for (int rad = 0; rad < 7; rad++) {
      if (RAD_START[rad] == nr) forstIRaden = true;
    }
    dioder[nr] = forstIRaden ? CRGB(255, 0, 0) : CRGB(0, 255, 0);   // rød = første lysdiode i en rad
    FastLED.show();
    M5.Display.fillScreen(TFT_BLACK);
    M5.Display.setCursor(8, 50);
    M5.Display.printf("Lysdiode %d av 37", nr + 1);
    delay(300);
  }
  delay(3000);
}
Neo Hex med de 37 lysdiodene nummerert rad for rad i sju rader med fire til sju lysdioder i hver
Slik teller programmet lysdiodene: sju rader med 4, 5, 6, 7, 6, 5 og 4 lysdioder.

Last opp programmet med ikoner

Programmet for nivå 3 er det samme som i nivå 2, med ikoner i tillegg. Morsedelen er helt lik. Knapp B har fått to oppgaver: Et kort trykk sender neste ikon, og et langt trykk tømmer skjermen og slukker panelet.

Hele programmet for nivå 3
// Trådløs morse med ikoner, nivå 3: knapp B sender et ikon til den andre sitt Neo Hex-panel.
#include <M5Unified.h>
#include <FastLED.h>
#include <WiFi.h>
#include <esp_now.h>

const uint8_t GRUPPE = 1;                // samme tall på de to som hører sammen
const uint8_t KANAL = 1;                 // WiFi-kanal, lik på alle
const int TONE_MIN = 700;                // Hz, tonen når du sender selv
const int TONE_DIN = 520;                // Hz, tonen når den andre sender
const uint16_t STREK_FRA_MS = 300;       // trykk som varer minst så lenge, blir strek
const uint16_t BOKSTAV_PAUSE_MS = 900;   // så lang pause avslutter bokstaven
const uint16_t ORD_PAUSE_MS = 2100;      // så lang pause gir mellomrom
const int MAKS_TEGN = 18;                // så mange tegn får plass på en linje
const uint8_t HEX_PINNE = 9;             // gul ledning i Grove-porten på M5StickS3
const uint8_t LYSSTYRKE = 24;            // 0 til 255, hold den lav
const bool SIKKSAKK = false;             // true hvis annenhver rad på panelet ditt går motsatt vei

// ===== Morsekjerne =====
struct MorseTegn {
  const char *tegn;
  const char *kode;   // . = prikk, - = strek
};

// Bokstaver og tall fra ITU-R M.1677-1, pluss de norske bokstavene Æ, Ø og Å.
const MorseTegn MORSE[] = {
  {"A", ".-"},    {"B", "-..."},  {"C", "-.-."},  {"D", "-.."},   {"E", "."},
  {"F", "..-."},  {"G", "--."},   {"H", "...."},  {"I", ".."},    {"J", ".---"},
  {"K", "-.-"},   {"L", ".-.."},  {"M", "--"},    {"N", "-."},    {"O", "---"},
  {"P", ".--."},  {"Q", "--.-"},  {"R", ".-."},   {"S", "..."},   {"T", "-"},
  {"U", "..-"},   {"V", "...-"},  {"W", ".--"},   {"X", "-..-"},  {"Y", "-.--"},
  {"Z", "--.."},  {"Æ", ".-.-"},  {"Ø", "---."},  {"Å", ".--.-"},
  {"1", ".----"}, {"2", "..---"}, {"3", "...--"}, {"4", "....-"}, {"5", "....."},
  {"6", "-...."}, {"7", "--..."}, {"8", "---.."}, {"9", "----."}, {"0", "-----"},
  {"?", "..--.."},
};
const int MORSE_ANTALL = sizeof(MORSE) / sizeof(MORSE[0]);

// Finn tegnet som hører til en kode. Ukjent kode gir "*".
const char *morseTilTegn(const char *kode) {
  for (int i = 0; i < MORSE_ANTALL; i++) {
    if (strcmp(MORSE[i].kode, kode) == 0) return MORSE[i].tegn;
  }
  return "*";
}

// Dekoderen får beskjed når knappen går ned og opp, og blir spurt jevnlig med sjekk().
class MorseDekoder {
 public:
  MorseDekoder(uint16_t strekFraMs, uint16_t bokstavPauseMs, uint16_t ordPauseMs)
      : strekFra(strekFraMs), bokstavPause(bokstavPauseMs), ordPause(ordPauseMs) {}

  void ned(uint32_t na) {
    nede = true;
    nedTid = na;
  }

  // Knappen er sluppet: et kort trykk blir prikk, et langt blir strek.
  char opp(uint32_t na) {
    if (!nede) return 0;
    nede = false;
    char symbol = (na - nedTid >= strekFra) ? '-' : '.';
    if (lengde < sizeof(kode) - 1) {
      kode[lengde++] = symbol;
      kode[lengde] = 0;
    }
    sistOpp = na;
    venterBokstav = true;
    venterOrd = false;
    return symbol;
  }

  // Gir et ferdig tegn, " " for nytt ord, eller nullptr når ingenting er klart.
  const char *sjekk(uint32_t na) {
    if (nede) return nullptr;
    if (venterBokstav && na - sistOpp >= bokstavPause) {
      const char *tegn = morseTilTegn(kode);
      kode[0] = 0;
      lengde = 0;
      venterBokstav = false;
      venterOrd = true;
      return tegn;
    }
    if (venterOrd && na - sistOpp >= ordPause) {
      venterOrd = false;
      return " ";
    }
    return nullptr;
  }

  const char *pagaende() const { return kode; }   // prikker og streker hittil

 private:
  uint16_t strekFra, bokstavPause, ordPause;
  char kode[8] = "";
  uint8_t lengde = 0;
  bool nede = false, venterBokstav = false, venterOrd = false;
  uint32_t nedTid = 0, sistOpp = 0;
};
// ===== Slutt morsekjerne =====

const uint8_t ALLE[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
enum Type : uint8_t { TONE_AV = 0, TONE_PA = 1, TEGN = 2, IKON = 3 };

struct Melding {
  char merke[2];    // alltid 'M' og 'S'
  uint8_t gruppe;
  uint8_t type;
  uint8_t nummer;   // øker for hvert tegn, så mottakeren kan hoppe over kopier
  char tegn[3];     // ett tegn som UTF-8 (Æ, Ø og Å bruker to byte), eller nummeret til et ikon
};

// ===== Ikoner =====
// Neo Hex har 37 lysdioder i sju rader med 4, 5, 6, 7, 6, 5 og 4 dioder.
const uint8_t RAD_START[7] = {0, 4, 9, 15, 22, 28, 33};
const uint8_t RAD_LENGDE[7] = {4, 5, 6, 7, 6, 5, 4};

// Ett ikon er sju tekster, en for hver rad. Bokstaven bestemmer fargen, og punktum betyr av.
// R = rød, G = grønn, B = blå, Y = gul, O = oransje, W = hvit
const char *IKONER[][7] = {
  {"R..R", "RR.RR", "RRRRRR", ".RRRRR.", ".RRRR.", "..R..", "...."},   // hjerte
  {"....", ".B.B.", "......", "Y.....Y", ".Y..Y.", ".YYY.", "...."},   // smilefjes
  {"GGGG", "G...G", "G....G", "G.....G", "G....G", "G...G", "GGGG"},   // ja
  {"R..R", ".R.R.", "..RR..", "...R...", "..RR..", ".R.R.", "R..R"},   // nei
  {"O..O", ".YYY.", ".YYYY.", "OYYYYYO", ".YYYY.", ".YYY.", "O..O"},   // sol
  {"W..W", "..W..", "..WW..", "WWWWWWW", "..WW..", "..W..", "W..W"},   // snø
};
const char *IKONNAVN[] = {"Hjerte", "Smilefjes", "Ja", "Nei", "Sol", "Snø"};
const int IKON_ANTALL = sizeof(IKONNAVN) / sizeof(IKONNAVN[0]);
// ===== Slutt ikoner =====

CRGB dioder[37];
int vistIkon = -1;                 // ikonet som vises på panelet akkurat nå, -1 = ikke noe ikon
int mittIkon = -1;                 // det siste ikonet du sendte

M5Canvas lerret(&M5.Display);
MorseDekoder dekoder(STREK_FRA_MS, BOKSTAV_PAUSE_MS, ORD_PAUSE_MS);
QueueHandle_t innboks;             // tegn som har kommet inn, venter her til loop() henter dem
volatile uint32_t mottarTil = 0;   // den andre sender fram til dette tidspunktet
String sendtTekst, mottattTekst;
uint32_t sistSendt = 0;
uint8_t mittNummer = 0;
int sistNummer = -1;
int tilstand = -1;                 // 0 = stille, 1 = du sender, 2 = du mottar

// ===== Skjermtegning =====
const uint32_t BAKGRUNN = 0x101418, HVIT = 0xFFFFFF, GRA = 0x8B9299, ORANSJE = 0xEF7D22, BLA = 0x2F6FD0;

void tegnSkjerm(const char *sendt, const char *mottatt, const char *kode, int tilstand, const char *ikon) {
  lerret.fillScreen(BAKGRUNN);
  lerret.setTextDatum(top_left);
  lerret.setFont(&fonts::lgfxJapanGothicP_16);
  lerret.setTextColor(ORANSJE);
  lerret.drawString("Du", 8, 4);
  lerret.setTextColor(BLA);
  lerret.drawString("Mottatt", 8, 54);
  lerret.setFont(&fonts::lgfxJapanGothic_24);
  lerret.setTextColor(HVIT);
  lerret.drawString(sendt, 8, 22);
  lerret.drawString(mottatt, 8, 72);

  int x = 8;                               // koden du holder på med, tegnet som prikker og streker
  for (const char *k = kode; *k; k++) {
    if (*k == '.') {
      lerret.fillCircle(x + 6, 118, 6, ORANSJE);
      x += 20;
    } else {
      lerret.fillRoundRect(x, 112, 30, 12, 6, ORANSJE);
      x += 38;
    }
  }
  if (tilstand == 1) lerret.fillCircle(224, 118, 8, ORANSJE);
  if (tilstand == 2) lerret.fillCircle(224, 118, 8, BLA);
  if (tilstand == 0) lerret.drawCircle(224, 118, 8, GRA);
  lerret.setFont(&fonts::lgfxJapanGothicP_16);
  lerret.setTextColor(GRA);
  lerret.setTextDatum(top_right);
  lerret.drawString(ikon, 232, 4);            // navnet på ikonet som lyser på panelet
}
// ===== Slutt skjermtegning =====

CRGB farge(char bokstav) {
  switch (bokstav) {
    case 'R': return CRGB(255, 0, 0);
    case 'G': return CRGB(0, 255, 0);
    case 'B': return CRGB(0, 0, 255);
    case 'Y': return CRGB(255, 180, 0);
    case 'O': return CRGB(255, 70, 0);
    case 'W': return CRGB(255, 255, 255);
    default:  return CRGB(0, 0, 0);
  }
}

// Tegn ikonet på panelet. Mens en tone lyder, lyser den midterste raden i tillegg.
void visHex(int ikon, int tilstand) {
  for (int rad = 0; rad < 7; rad++) {
    for (int i = 0; i < RAD_LENGDE[rad]; i++) {
      int plass = (SIKKSAKK && rad % 2 == 1) ? RAD_LENGDE[rad] - 1 - i : i;
      dioder[RAD_START[rad] + plass] = (ikon < 0) ? CRGB(0, 0, 0) : farge(IKONER[ikon][rad][i]);
    }
  }
  if (tilstand != 0) {
    for (int i = 0; i < RAD_LENGDE[3]; i++) {
      dioder[RAD_START[3] + i] = (tilstand == 1) ? CRGB(255, 70, 0) : CRGB(0, 0, 255);
    }
  }
  FastLED.show();
}

// Legg et tegn til en linje og fjern det eldste når linjen er full.
void leggTil(String &linje, const char *tegn) {
  linje += tegn;
  int antall = 0;
  for (size_t i = 0; i < linje.length(); i++) {
    if ((linje[i] & 0xC0) != 0x80) antall++;      // tell tegn, ikke byte
  }
  if (antall > MAKS_TEGN) linje.remove(0, (linje[0] & 0x80) ? 2 : 1);
}

// Kjøres hver gang en ESP-NOW-melding kommer inn.
void mottatt(const esp_now_recv_info_t *info, const uint8_t *data, int lengde) {
  if (lengde != sizeof(Melding)) return;
  Melding m;
  memcpy(&m, data, sizeof(m));
  if (m.merke[0] != 'M' || m.merke[1] != 'S' || m.gruppe != GRUPPE) return;
  m.tegn[2] = 0;                      // et tegn er aldri lengre enn to byte, den tredje avslutter teksten
  if (m.type == TONE_PA) mottarTil = millis() + 150;
  if (m.type == TONE_AV) mottarTil = 0;
  if (m.type == TEGN || m.type == IKON) xQueueSend(innboks, &m, 0);
}

void send(uint8_t type, const char *tegn) {
  Melding m = {{'M', 'S'}, GRUPPE, type, mittNummer, {0, 0, 0}};
  strncpy(m.tegn, tegn, 2);
  esp_now_send(ALLE, (const uint8_t *)&m, sizeof(m));
}

void setup() {
  auto cfg = M5.config();
  M5.begin(cfg);
  M5.Display.setRotation(1);          // liggende skjerm, 240 x 135 piksler
  lerret.createSprite(240, 135);
  M5.Speaker.setVolume(120);
  innboks = xQueueCreate(16, sizeof(Melding));
  mittNummer = esp_random();          // tilfeldig start, så en omstart ikke ser ut som en kopi

  M5.Power.setExtOutput(true);        // slå på 5 V i Grove-porten, ellers er panelet mørkt
  FastLED.addLeds<WS2812B, HEX_PINNE, GRB>(dioder, 37);
  FastLED.setBrightness(LYSSTYRKE);
  FastLED.setMaxPowerInVoltsAndMilliamps(5, 250);
  visHex(vistIkon, 0);

  WiFi.mode(WIFI_STA);
  WiFi.setChannel(KANAL);
  while (!WiFi.STA.started()) delay(100);
  esp_now_init();
  esp_now_register_recv_cb(mottatt);
  esp_now_peer_info_t alle = {};
  memcpy(alle.peer_addr, ALLE, 6);    // adressen FF:FF:FF:FF:FF:FF betyr «til alle»
  esp_now_add_peer(&alle);
}

void loop() {
  M5.update();
  uint32_t na = millis();
  bool endret = false;

  if (M5.BtnA.wasPressed()) dekoder.ned(na);
  if (M5.BtnA.wasReleased()) {
    dekoder.opp(na);
    send(TONE_AV, "");
    send(TONE_AV, "");
    endret = true;
  }
  if (M5.BtnA.isPressed() && na - sistSendt >= 40) {
    send(TONE_PA, "");
    sistSendt = na;
  }
  if (M5.BtnB.wasClicked()) {          // kort trykk på knapp B: send neste ikon
    mittIkon = (mittIkon + 1) % IKON_ANTALL;
    vistIkon = mittIkon;
    char nr[2] = {char('0' + mittIkon), 0};
    mittNummer++;
    send(IKON, nr);
    send(IKON, nr);
    endret = true;
  }
  if (M5.BtnB.wasHold()) {             // langt trykk på knapp B: tøm skjermen og panelet
    sendtTekst = "";
    mottattTekst = "";
    vistIkon = -1;
    endret = true;
  }

  const char *ferdig = dekoder.sjekk(na);
  if (ferdig) {
    leggTil(sendtTekst, ferdig);
    mittNummer++;
    send(TEGN, ferdig);
    send(TEGN, ferdig);                // to ganger, i tilfelle den første forsvinner
    endret = true;
  }

  Melding m;
  while (xQueueReceive(innboks, &m, 0)) {
    if (m.nummer == sistNummer) continue;   // kopi av et tegn vi allerede har
    sistNummer = m.nummer;
    if (m.type == TEGN) leggTil(mottattTekst, m.tegn);
    if (m.type == IKON && m.tegn[0] >= '0' && m.tegn[0] < '0' + IKON_ANTALL) vistIkon = m.tegn[0] - '0';
    endret = true;
  }

  int ny = M5.BtnA.isPressed() ? 1 : (na < mottarTil ? 2 : 0);
  if (ny != tilstand) {
    tilstand = ny;
    if (tilstand == 1) M5.Speaker.tone(TONE_MIN);
    else if (tilstand == 2) M5.Speaker.tone(TONE_DIN);
    else M5.Speaker.stop();
    endret = true;
  }
  if (endret) {
    tegnSkjerm(sendtTekst.c_str(), mottattTekst.c_str(), dekoder.pagaende(), tilstand,
               vistIkon < 0 ? "" : IKONNAVN[vistIkon]);
    lerret.pushSprite(0, 0);
    visHex(vistIkon, tilstand);
  }
  delay(5);
}
De seks ikonene i programmet tegnet på Neo Hex: hjerte, smilefjes, ja, nei, sol og snø i ulike farger
De seks ikonene som følger med, tegnet rett fra tabellen i programmet.

Tegn ditt eget ikon

Et ikon i programmet er sju korte tekster, én for hver rad på panelet. Hver bokstav er en lysdiode: R er rød, G er grønn, B er blå, Y er gul, O er oransje og W er hvit. Punktum betyr at lysdioden er av. Radene har 4, 5, 6, 7, 6, 5 og 4 tegn, akkurat som panelet. Slik ser hjertet ut i koden:

{"R..R", "RR.RR", "RRRRRR", ".RRRRR.", ".RRRR.", "..R..", "...."},   // hjerte

Vil du lage ditt eget, tegner du først sju rader med ringer på et ark og fargelegger dem. Skriv så av rad for rad, legg til en ny linje i IKONER og et nytt navn i IKONNAVN. Programmet teller selv hvor mange ikoner du har. Husk at annenhver rad er forskjøvet en halv lysdiode, slik at mønsteret ligner en bikake og ikke et rutenett.

Fotorealistisk illustrasjon av M5StickS3 og Neo Hex med et rødt hjerte på panelet, på et lyst bord på skolen
Illustrasjon. Nivå 3 ferdig koblet. Hjertet lyser på panelet, og navnet på ikonet står øverst til høyre på skjermen.

Prøv selv

Utfordringene under passer for et par eller for en hel klasse. De første krever bare nivå 1.

Fotorealistisk illustrasjon av to elever som sender morse til hverandre med hver sin M5StickS3 over en skolepult
Illustrasjon. Den ene sender, den andre lytter og skriver ned. Bytt roller etter hvert ord.
  1. Navnet ditt. Skriv navnet ditt i morse på et ark, og send det. Den andre skriver ned det hun eller han hører, uten å se på skjermen.
  2. Hemmelig ord. Den ene velger et ord på fire bokstaver. Den andre har tre forsøk på å tyde det. Bytt roller.
  3. Morsestafett. Still dere på rekke. Dere trenger bare to enheter. Førstemann får en setning på en lapp og sender den til nummer to, ett ord om gangen. Nummer to skriver ned det hun eller han hørte. Så går de to enhetene videre til nummer to og nummer tre, og setningen sendes på nytt. Sammenlign med lappen til slutt.
  4. Mål rekkevidden. Gå ut i skolegården. Den ene blir stående, den andre går ti skritt om gangen og sender en prikk. Hvor langt unna virker det? Prøv også gjennom en vegg og rundt et hjørne.
  5. Bytt toner. Endre TONE_MIN og TONE_DIN. Hvilke toner er lettest å skille? Prøv tall mellom 400 og 1000.
  6. Raskere tempo. Bruk tabellen under nivå 2 og gå fra nybegynner til middels. Hvor mange ord klarer dere på ett minutt?
  7. Eget ikon. Lag et ikon som betyr «ferdig» eller «vent litt», og avtal med makkeren hva det betyr.
  8. Egen kode. Legg til et tegn i MORSE-tabellen, for eksempel punktum, som er .-.-.- i det internasjonale morsealfabetet.
Fotorealistisk illustrasjon av en elev som sender morse med M5StickS3 i skolekorridoren til en venn langt borte
Illustrasjon. En lang gang egner seg godt til å måle rekkevidden. Den ene står stille, den andre går ti skritt om gangen og sender en prikk.

Hvis det ikke virker

Det du serSannsynlig årsakGjør dette
Ingen port i Arduino IDELadekabel uten data, eller enheten er ikke i nedlastingsmodusBytt kabel. Hold strømknappen inne i to sekunder til det grønne lyset blinker.
Feilmelding om esp_now_recv_info_tGammel kortpakkeOppdater M5Stack i Boards Manager til en versjon fra tabellen
Feilmelding om M5Unified.h eller FastLED.hBiblioteket manglerInstaller det i Manage Libraries
Svart skjerm etter opplastingEnheten står fortsatt i nedlastingsmodusTrykk én gang på strømknappen
Bare din egen enhet piperUlik GRUPPE eller KANAL, eller den andre har ikke fått programmetSjekk at GRUPPE og KANAL er like i koden, og last opp på nytt til begge. I nivå 1 står gruppenummeret øverst til høyre på skjermen.
Tonen hakkerFor lang avstand, eller mye annen trafikk på kanalenGå nærmere. Prøv KANAL 6 eller 11 på begge enhetene.
Alt blir strekerDu holder for lengeSend kortere prikker, eller øk STREK_FRA_MS
I blir til to E-erFor lang pause inne i bokstavenSend tettere, eller øk BOKSTAV_PAUSE_MS
Stjerne i stedet for bokstavMønsteret finnes ikke i tabellenVent til bokstaven er ferdig før du begynner på den neste
Neo Hex er mørktKabelen står i OUT, eller du har lastet opp nivå 2Flytt kabelen til IN og last opp nivå 3 eller testprogrammet
Et ikon du har tegnet selv, er speilvendt i annenhver radAnnenhver rad går motsatt vei på panelet dittKjør testprogrammet og sett SIKKSAKK til true
Skjermen står opp nedDu holder enheten den andre veienBytt ut setRotation(1) med setRotation(3)
Den ene enheten virker, men ikke den andre

La de to enhetene bytte roller, slik at den andre sender. Last så opp nivå 1 på nytt til begge, uten å endre noe i koden. Virker det nå, var det ulike programmer eller ulike gruppenummer. Virker fortsatt bare den ene, sjekker du at begge er ladet. Hold dem ved siden av hverandre på pulten før du prøver på lengre avstand.

Mange par i samme rom, og alt går tregt

Alle parene deler den samme radiokanalen, og hver enhet sender 25 meldinger i sekundet mens knappen er inne. Med mange par samtidig kan meldinger kollidere. Fordel parene på kanal 1, 6 og 11 ved å endre KANAL. De to i et par må alltid ha samme kanal og samme gruppe.

Test deg selv

Test deg selv: hvor lenge varer en strek?

Like lenge som tre prikker. Pausen mellom to bokstaver er også tre prikker, og pausen mellom to ord er sju.

Test deg selv: hvilken bokstav er -.-?

K. I morsetreet går du til høyre for strek, til venstre for prikk og til høyre for strek: T, N og K.

Test deg selv: hvorfor trenger programmet et gruppenummer?

Meldingene sendes til alle som lytter. Uten gruppenummer ville alle enhetene i rommet pipe samtidig. Programmet hopper over meldinger med et annet tall enn sitt eget.

Test deg selv: hvorfor sendes «tone på» mange ganger i sekundet?

En radiomelding kan bli borte på veien. Når meldingen gjentas hele tiden, gjør det ingenting om én forsvinner. Mottakeren slutter dessuten å pipe av seg selv når meldingene stopper.

Test deg selv: hvor mange tegn har den midterste raden i et ikon?

Sju. Radene på Neo Hex har 4, 5, 6, 7, 6, 5 og 4 lysdioder, til sammen 37.

Vanlige spørsmål

Trenger M5StickS3 WiFi eller internett for å sende morse?

Nei. ESP-NOW går rett fra den ene enheten til den andre. Dere kan bruke morsesenderen i skolegården, på tur og i et rom uten nett.

Hvor langt rekker signalet?

Det kommer an på omgivelsene. Espressif oppgir opptil 200 meter i åpent lende for ESP-NOW, men M5StickS3 har en liten, innebygd antenne, og vegger og mennesker demper signalet, mens andre nettverk forstyrrer det. Regn med mindre, og mål selv. Rekkeviddetesten under «Prøv selv» er laget for det.

Er det lov å sende slik?

Ja. M5StickS3 sender med lav effekt på 2,4 GHz, det samme båndet som WiFi og Bluetooth bruker. Det båndet kan brukes uten lisens i Norge etter fribruksforskriften. Du trenger heller ikke radioamatørlisens for å bruke morse.

Kan andre lese meldingene våre?

Ja. Meldingene er ikke kryptert, og alle med samme program og samme gruppenummer kan lytte. Morse er dessuten ingen hemmelig kode. Alle kan lære den. Send derfor aldri passord eller andre hemmeligheter.

Kan vi være flere enn to?

Ja. Alle enheter med samme gruppenummer hører hverandre, så en hel gruppe kan lytte til den som sender. Avtal at bare én sender om gangen. Sender to samtidig, blandes tonene.

Hvorfor står ikke Æ, Ø og Å i alle morsetabeller?

Det internasjonale morsealfabetet har A til Z, É, tall og skilletegn. Mange land har lagt til egne bokstaver. I Norge er Æ .-.-, Ø ---. og Å .--.-. Programmet i guiden kjenner alle tre.

Kan jeg bruke micro:bit i stedet for M5StickS3?

Programmene her er skrevet for M5StickS3. En micro:bit har også radio og kan sende morse mellom to kort, men med et annet program. Vil du begynne der, er guiden om å komme i gang med micro:bit et godt sted å starte.

Slik bygger du videre

Nå har du sendt meldinger gjennom luften med ferdige enheter. Neste steg kan være guiden om trådløs kommunikasjon med 433 MHz og Arduino, der du ser hvordan en radiosender er bygd opp av løse moduler, antenne og Arduino. Guiden om å programmere ESP32 og M5Stack sammenligner blokker, MicroPython og Arduino, og guiden om UIFlow 2.0 viser hvordan du programmerer M5Stack med blokker. Skal meldingene gå flere kilometer uten mobildekning, forklarer guiden om LoRa, LoRaWAN og Meshtastic hvordan det virker.

Flere kort, sensorer og enheter med Grove-kontakt finner du under M5Stack. Moduler og antenner til egne radioprosjekter ligger under trådløs og radiokommunikasjon.

Kilder: ITU-R M.1677-1 om det internasjonale morsealfabetet, Store norske leksikon om morsetegn og SOS, Espressifs dokumentasjon for ESP-NOW, M5Stacks dokumentasjon for M5StickS3 og Neo Hex, og fribruksforskriften.

Alle guider

Produkter omtalt i denne guiden

Produktene som brukes og sammenlignes i guiden, med pris og lagerstatus.