Morze kód

[learner]

Sziasztok, elkezdtem dolgozni egy programon amely a soros monitornál elküldött szöveget Morze "kódolja". Ezt sikerült is megoldani, de úgy érzem ez egyszerűbben és rövidebben is kivitelezhető lenne. Szóval gondoltam mielőtt folytatom megkérdezlek titeket mégis hogy lehetne ezt ésszerűbben megcsinálni. Minden tanácsot és segítséget előre köszönök de hozzátenném "könyvtárat" nem szeretnék használni.
Itt kód:

Kód: Egész kijelölése

void setup() {
  DDRD = DDRD | B00010000; // 7 6 5 4 3 2 1 0
  Serial.begin(9600);
}
void loop() {

  if (Serial.available() > 0) {
    int betuertek;
    betuertek = Serial.read();
    switch (betuertek) {
      case 65: /* A */
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(500);
        PORTD = B00000000;
        delay(800);
        break;
      case 66: /* B */
        PORTD = B00010000;
        delay(500);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(800);
        break;
      case 67: /* C */
        PORTD = B00010000;
        delay(500);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(500);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(800);
        break;
      case 68: /* D */
        PORTD = B00010000;
        delay(500);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(800);
        break;
      case 69: /* E */
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(800);
        break;
      case 70: /* F */
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(500);
        PORTD = B00000000;
        delay(200);
        PORTD = B00010000;
        delay(200);
        PORTD = B00000000;
        delay(800);
        break;
    }
  }
}

[vargham]

Van egyszerűbb mód.

Nézd meg, hogy milyen hosszú a leghosszabb Morze karakter. Emlékeim szerint 5. Csinálsz egy struktot, amiben van két byte, egy a hossz, másik a minta. A mintában a 0 bit legyen a ti, az 1 pedig a tá.

Kód: Egész kijelölése

constexpr uint16_t dotLengthMs = 100u; // Általában 50 ms szokott lenni, de oda állítod magadnak, ahová akarod.
constexpr uint16_t dashLength = dotLengthMs * 3u; //A vonás 3x hosszabb, mint a pont.

struct MorseChar {
	byte length;
	byte pattern;
};

uint8_t characterCount = 26 + 10; //Betűk, számok plusz ha akarsz, írásjelek.
MorseChar morseChars[characterCount];

// A karakter kódja:
morseChars[0].length  = 2;
morseChars[0].pattern  = 0b00000010;

// B karakter kódja:
morseChars[0].length  = 4;
morseChars[0].pattern  = 0b00000001;

// C karakter kódja:
morseChars[0].length  = 4;
morseChars[0].pattern  = 0b00000101;

// 1 karakter kódja:
morseChars[0].length  = 5;
morseChars[0].pattern  = 0b00011110;

// Ez mondja meg, hogy melyik ASCII karakter Morze kódja hol van a tömbben
uint8_t getIndex(char aChar) {
	return static_cast<uint8_t>(aChar) - 65;
}

//Ez villogja el az adott karektert.
void charToMorse(char aChar) {
	for (int i = 0; i < morseChars[getIndex(aChar)].length; i++) {
		digitalWrite(outPin, HIGH); // Bekapcsoljuk a kimenetet
		delay((morseChars[getIndex(aChar)].pattern >> i) & 1 ? dashLengthMs : dotLengthMs); // Megnézzük a pattern i. bit értékét, ha 0 akkor rövidet várunk, ha egy akkor hosszút
		digitalWrite(outPin, LOW); // Lekapcsoljuk a kimenetet
		delay(dotLengthMs);
	}
}

Plusz észrevétel: A kimenetet elég furcsán kezeled. Ha már Arduino, akkor használd a pinmode és digitalerite utasításokat. Ha meg sima AVR LibC, akkor azt lehet szebben, olvashattóbban is. Például PD4 output: DDRD |= _BV(PD4)

[vargham]

Plusz tömörítési lehetőség:
A leghosszabb Morze karakterkód az 5 bit, tehát a mintázat bájtban marad 3 szabad bited. 3 biten 2^3, azaz 8 darab számot lehet ábrázolni (0-7). Így megoldható, hogy ne kelljen a struct, hanem 1 bájton eltárolsz mindent: [0-2] biteken a kód hosszát, [3-7] biteken pedig magát a kódot.

[learner]

Rendben, lenne pár kérdésem. Először mi az a strukt? Utánanéztem annyit sikerült megértenem, hogy valamilyen tömb byte típusú adatokkal. A benne lévő adatokat hogy használhatom a program más részein. Hogy hivatkozzak a tömb elemeire, hogy változtathatom az értéküket?
Ezt a részt nem értem mit jelent ez?

Kód: Egész kijelölése

constexpr uint16_t dotLengthMs = 100u;
constexpr uint16_t dashLength = dotLengthMs * 3u;

Igazából nem értek egy kukkot sem az egészből , ez hogy fog nekem hosszú és rövid jeleket kiadni? Miért nincs void setup és loop kódodban? Csak egy charToMorse nevű "függvényt" (azt hiszem így nevezik) látok és ez hogy fog lefutni? Tudom, kicsit furcsa kérdések és valószínű rosszul fogalmaztam meg őket de remélem itt választ kapok rájuk és rendet tudok végre rakni egy kicsit a fejemben.

[vargham]

Nem írtam meg neked a teljes programot.
Írd meg a setupot, a loopot. A loopban vizsgáld, hogy jött-e a soros porton karaketer, ha igen akkor hívd meg a charToMorse nevű függvényt, paraméterként kapja meg a sorosporton érkezett karaktert.

A constexpr uint16_t dotLengthMs az egy konstans, ami 16 bites (2 byte) előjel nélküli egész. Ez adja meg millisecundumban a ti hosszát (lásd a delay hívást), a tá az 3x olyan hosszú, mint a ti, ezért kapja a konstans a ti * 3 hossz értéket.

A munkámból adódóan megszoktam, hogy nem használok byte, int és hasonló adattípusokat, mivel ezeknek platformonként eltérő lehet a hossza. Fontos, hogy ha egy adott kód futhat 64 bites PC-n, 32 bites és 8 bites mikrokontrolleren is, akkor mindegyik ugyanolyan adathosszal dolgozzon. Az Arduinoban a byte az 8 bites előjel nélküli egész, arra korrekten uint8_t néven lehet hivatkozni.
Ugyanígy a kód átláthatósága miatt hoztam létre a nevesített konstansokat.

Kód: Egész kijelölése

//Ilyet nem írunk: 
delay (1500);
//Helyette:
//Nevesített konstans
constexpr uint16_t waitForButtonPressTimeoutMs = 1500; // Figyelj a konstans nevére! Beszédes. Valószínűleg egy interruptra várunk.
//Máshol a kódban:
delay (waitForButtonPressTimeoutMs);

A struct az önmagában nem tömb, hanem egy olyan szerkezet, amiben összetartozó adatokat tudsz tárolni. Egy új típust hozol ezzel létre.
Például

Kód: Egész kijelölése

struct Apple {
	uint16_t diameter;
	uint16_t weight;
};

// Használata:
Apple pityuAlmaja;
pityuAlmaja.diameter = 8;
pityuAlmaja.weigth = 110;

De ezekre volt példa a kódomban is. Használtam a struktot adattárolásra.

[Robert]

Ilyen esetben miért nem a digitalWrite utasítást használod kiírásra?
A digitalWrite határfrekvenciája ~150 kHz. Azaz e főlé nem tudsz menni.

Kérdés: miért kell program tömörítés? Sok esetben az már túl mutat a kezdő lépéseken is (hátérinfo/tudás szükséges, sok 10/100 mód adott feladatrész megoldására).

De ha morse kód:
- rövid jel (ti – 1 egység hosszú);
- hosszú jel (tá 3 egység hosszú);
- rövid szünetjel (jelköz – 1 egység hosszú);
- hosszú szünetjel (betűköz – 3 egység hosszú);
- nagyon hosszú szünetjel (szóköz és mondatköz - 7 egység hosszú).

azaz
Jel Időtartam
Rövid (ti) 1 egység (1)
Hosszú (tá) 3 egység (111)
Jelköz (Betűn belüli szünet a jelek között.) 1 egység (0)
Betűköz (Betűk közötti szünet.) 3 egység (000)
Szóköz (Szavak és mondatok közötti szünet.) 7 egység (0000000)


És a sebesség is kötött:
Az adás sebességét a percenként leadott szavak számával jellemzik (WPM = Word Per Minute). Mivel az egyes szavak tényleges hossza a benne szereplő karakterektől függ, az adás sebességének meghatározásakor a "PARIS" szót tekintik hossz-etalonnak (ennek és a követő szószünetnek a billentyűzése a fentebb ismertetett módszer szerint 50 elemi egységnyi időt igényel).

Így 10 WPM sebesség percenként 10 szó, azaz 50 betű leadásának felel meg.

Forrés: https://hu.wikipedia.org/wiki/Morzek%C3%B3d

[learner]

Én megpróbáltam
Nem tudtam, hogy kezeljem ezeket a konstansokat, gondolom úgy mintha egy globális változó lenne nem? Szóval loop és setupon kívül legyen, mert láttam másik függvény is használja.

Kód: Egész kijelölése

constexpr uint16_t dotLengthMs = 100u; // Általában 50 ms szokott lenni, de oda állítod magadnak, ahová akarod.
constexpr uint16_t dashLength = dotLengthMs * 3u; //A vonás 3x hosszabb, mint a pont.
struct MorseChar {
   byte length;
   byte pattern;
};

uint8_t characterCount = 26 + 10; //Betűk, számok plusz ha akarsz, írásjelek.
MorseChar morseChars[characterCount];

int outPin = 4;

void setup(){
Serial.begin(9600);
pinMode(outPin, OUTPUT);  
}

void loop() {
  if (Serial.available() > 0) {
    charToMorse(Serial.read());
  }
// A karakter kódja:
morseChars[0].length  = 2;
morseChars[0].pattern  = 0b00000010;

// B karakter kódja:
morseChars[0].length  = 4;
morseChars[0].pattern  = 0b00000001;

// C karakter kódja:
morseChars[0].length  = 4;
morseChars[0].pattern  = 0b00000101;

// 1 karakter kódja:
morseChars[0].length  = 5;
morseChars[0].pattern  = 0b00011110;
}

// Ez mondja meg, hogy melyik ASCII karakter Morze kódja hol van a tömbben
uint8_t getIndex(char aChar) {
   return static_cast<uint8_t>(aChar) - 65;
}

//Ez villogja el az adott karektert.
void charToMorse(char aChar) {
   for (int i = 0; i < morseChars[getIndex(aChar)].length; i++) {
      digitalWrite(outPin, HIGH); // Bekapcsoljuk a kimenetet
      delay((morseChars[getIndex(aChar)].pattern >> i) & 1 ? dashLengthMs : dotLengthMs); // Megnézzük a pattern i. bit értékét, ha 0 akkor rövidet várunk, ha egy akkor hosszút
      digitalWrite(outPin, LOW); // Lekapcsoljuk a kimenetet
      delay(dotLengthMs);
   }
}

Hibát jelez itt:

Kód: Egész kijelölése

MorseChar morseChars[characterCount];

Forditó ezt írja ki: array bound is not an integer constant before ']' token
Valamilyen szám kell neki, talán hogy, hány elem van benne?

Egyébként azért lényeges a program tömörítés számomra, mert zavar a gondolat, hogy amit csinálok sokkal egyszerűbben is lehetne. Többször volt olyan, hogy egy működő programot kitöröltem, mert nem tetszett a mérete. Tökéletességre törekszem.
Például ez egy terepasztalon lévő forgalomirányító lámpáknak a vezérlése 1 óra alatt megvolt az első működő verzió utána még volt vagy 5 és ez lett a legrövidebb, de még mindig úgy érzem lehetne rövidebb.

Kód: Egész kijelölése

void setup() {
  DDRD = DDRD | B11111000; // 7 6 5 4 3 2 1 0
  DDRB = DDRB | B00011111; // nincs nincs 13 12 11 10 9 8
}

void loop()
{
  byte Pulse = 0;
  PORTD = B10001000; // "B" bináris formázó
  PORTB = B00010001;
  delay(5000);
  while (Pulse < 8) {
    Pulse ++;
    PORTD = B10010000;
    PORTB = B00011000;
    delay(400);
    PORTD = B10010000;
    PORTB = B00011001;
    delay(400);
  }
  Pulse = 0;
  PORTD = B01100000;
  PORTB = B00000110;
  delay(5000);
  while (Pulse < 8) {
    Pulse ++;
    PORTD = B00110000;
    PORTB = B00001010;
    delay(400);
    PORTD = B01110000;
    PORTB = B00001010;
    delay(400);
  }
  Pulse = 0;
  PORTD = B01000000;
  PORTB = B00000010;
}

[Robert]

Ha a cipőskanál fejlesztés miatt kell a kódoptimalizálás (beleférjen a chipbe) - az más.
Az optimalizált kód és az Arduino - hát nem igazán szinonim fogalmak....

Az időráfordítást számlva sokszor _nem éri meg_ optimalizálni. Kivéve:
- időkritikus Interruptok,
- chip erőforásának határán sikerül lenni (lebegőpontos számolás),
- nagy gyártási volumen és a 10centtel olcsóbb chipbe is belefér,
- ....

[vargham]

-Ha valamit ötvenszer ki kell írni, és helyette ciklust használ, az szerintem nem értelmetlen tömörítés.
-A fordítónak az volt a baja, hogy nem konstans a tömb mérete.
-A delay-es megoldással az a baj, hogy amíg a delay-ben vár, addig a processzor semmi mást nem tudcsinálni, így újabb karaktert sem tud fogadni.
-Úgy látom, hogy nem Arduino, hanem alapvető C/C++ programozási problémáid vannak. Érdemes lenne elolvasnod valami alap ismertetőt a vezérlési szerkezetekről, változókról, stb.
-Nem árultad el, hogy miért használsz bitszintű portregiszter manipulációkat az Arduino pinMode, digitalWrite, stb helyett.
-Arduino-val lehetetlen normális, kompakt kódot készíteni. Lehet, hogy nem látod, de maga a core tele van nagy és felesleges hívásokkal, így a lefordított bináris is feleslegesen nagy lesz. (Innen nézve érthető, hogy nem használsz Arduino digitalWrite-ot, de akkor ne használd a többit sem (setup, loop, stb). Ott az Atmel Studio, szuperül lehet programozni benne ezeket a mikrokontrolelreket.)

[vargham]

Kivettem a tenary operatort, és if-et raktam helyette, hogy ne zavarjon össze. Valamint leellenőriztem, hogy fordul-e.

Kód: Egész kijelölése

constexpr uint16_t dotLengthMs = 100u; // Általában 50 ms szokott lenni, de oda állítod magadnak, ahová akarod.
constexpr uint16_t dashLengthMs = dotLengthMs * 3u; //A vonás 3x hosszabb, mint a pont.

struct MorseChar {
   byte length;
   byte pattern;
};

constexpr uint8_t characterCount = 26 + 10; //Betűk, számok plusz ha akarsz, írásjelek.
MorseChar morseChars[characterCount];
constexpr int outPin = 4;

// Ez mondja meg, hogy melyik ASCII karakter Morze kódja hol van a tömbben
inline uint8_t getIndex(char aChar) {
    uint8_t morseIndex = characterCount; //Invalid érték, ha nem találjuk meg a keresett karaktert, akkor ezt adjuk vissza.
    uint8_t asciiCode = static_cast<uint8_t>(aChar);
    uint8_t offset = 0;
    if ('A' <= aChar && aChar <= 'Z') { //Nagybetűk
        offset = static_cast<uint8_t>('A'); // Az A karakter ASCII kódja 65, ezt kivonva a kapott karakter kódjából megkapjuk, hogy a tömbünkben hol tároljuk az adott karakter Morze kódját
        morseIndex = asciiCode - offset;
    }
    else if ('a' <= aChar && aChar <= 'z') { //Kisbetűk
        offset = static_cast<uint8_t>('a'); // Az a karakter ASCII kódja 97, ezt kivonva a kapott karakter kódjából megkapjuk, hogy a tömbünkben hol tároljuk az adott karakter Morze kódját
        morseIndex = asciiCode - offset;
    }
    else if ('0' <= aChar && aChar <= '9') {
        offset = static_cast<uint8_t>('0');
        morseIndex = asciiCode - offset + getIndex('Z') + 1; // A betűket a számok után raktam, 0-tól kezdve.
    }
    else {
        // Itt nem csinálunk semmit
    }
    return morseIndex;
}

// Néhány karakter kódja.
// Ne felejtsd el kitölteni az összes betűvel.
// 0. indexen van az 'A' karakter, 25. helyen a 'Z', 26. helyen a '0', és így tovább
void fillMorseArray() {
    // A karakter kódja:
    morseChars[getIndex('A')].length  = 2;
    morseChars[getIndex('A')].pattern  = 0b00000010;
    
    // B karakter kódja:
    morseChars[getIndex('B')].length  = 4;
    morseChars[getIndex('B')].pattern  = 0b00000001;
    
    // C karakter kódja:
    morseChars[getIndex('C')].length  = 4;
    morseChars[getIndex('C')].pattern  = 0b00000101;

    // D karakter kódja:
    // Írd ide!
    
    // 0 karakter kódja:
    // ...
    
    // 1 karakter kódja:
    morseChars[getIndex('1')].length  = 5;
    morseChars[getIndex('1')].pattern  = 0b00011110; 
}

void setup(){
    fillMorseArray();
    Serial.begin(9600);
    pinMode(outPin, OUTPUT);  
}

void loop() {
  if (Serial.available() > 0) {
    charToMorse(Serial.read());
  }
}

//Ez villogja el az adott karektert.
void charToMorse(char aChar) {
    uint8_t morseIndex = getIndex(aChar); // Megkérdezzük, hol van a tömbben a kért karakter Morze kódja
    if (morseIndex < characterCount) { // Ha a válasz a tömbön belül van, akkor ok, ha nem, akkor nem ismert karakterről van szó.
       for (int i = 0; i < morseChars[morseIndex].length; i++) {
          digitalWrite(outPin, HIGH); // Bekapcsoljuk a kimenetet
          if (((morseChars[morseIndex].pattern >> i) & 1) == 1) { // Megnézzük a pattern i. bit értékét, ha 1, akkor hosszú várakozás kell, mert hosszú (vonás) ideig kell bekapcsolva hagyni a kimenetet
            delay(dashLengthMs);
          }
          else {
            delay(dotLengthMs); // A bit 0, rövid várakozás.
          }
          digitalWrite(outPin, LOW); // Lekapcsoljuk a kimenetet
          delay(dotLengthMs); // Jelköz szünet.
       }
    }
}

[learner]

Köszönöm, ez nagyon szuper lett . Most a minta alapján megpróbálom a többi betűt és számot is beletenni. Leírnád nekem mi az a tenary operator? Esetleg tudnál ajánlani valamilyen oldalt nekem amit hasznát vennék? Mármint nem a Morze kóddal kapcsolatban, hanem ahonnan tanulhatok ezt azt pár trükköt .

[learner]

Kiegészítettem a többi betűvel és számmal a kódot.

Kód: Egész kijelölése

constexpr uint16_t dotLengthMs = 200u; // Általában 50 ms szokott lenni, de oda állítod magadnak, ahová akarod.
constexpr uint16_t dashLengthMs = dotLengthMs * 3u; //A vonás 3x hosszabb, mint a pont.

struct MorseChar {
   byte length;
   byte pattern;
};

constexpr uint8_t characterCount = 26 + 10; //Betűk, számok plusz ha akarsz, írásjelek.
MorseChar morseChars[characterCount];
constexpr int outPin = 4;

// Ez mondja meg, hogy melyik ASCII karakter Morze kódja hol van a tömbben
inline uint8_t getIndex(char aChar) {
    uint8_t morseIndex = characterCount; //Invalid érték, ha nem találjuk meg a keresett karaktert, akkor ezt adjuk vissza.
    uint8_t asciiCode = static_cast<uint8_t>(aChar);
    uint8_t offset = 0;
    if ('A' <= aChar && aChar <= 'Z') { //Nagybetűk
        offset = static_cast<uint8_t>('A'); // Az A karakter ASCII kódja 65, ezt kivonva a kapott karakter kódjából megkapjuk, hogy a tömbünkben hol tároljuk az adott karakter Morze kódját
        morseIndex = asciiCode - offset;
    }
    else if ('a' <= aChar && aChar <= 'z') { //Kisbetűk
        offset = static_cast<uint8_t>('a'); // Az a karakter ASCII kódja 97, ezt kivonva a kapott karakter kódjából megkapjuk, hogy a tömbünkben hol tároljuk az adott karakter Morze kódját
        morseIndex = asciiCode - offset;
    }
    else if ('0' <= aChar && aChar <= '9') {
        offset = static_cast<uint8_t>('0');
        morseIndex = asciiCode - offset + getIndex('Z') + 1; // A betűket a számok után raktam, 0-tól kezdve.
    }
    else {
        // Itt nem csinálunk semmit
    }
    return morseIndex;
}

// Karakterek kódja.
// 0. indexen van az 'A' karakter, 25. helyen a 'Z', 26. helyen a '0', és így tovább
void fillMorseArray() {
    // A karakter kódja:
    morseChars[getIndex('A')].length  = 2;
    morseChars[getIndex('A')].pattern  = 0b00000010;
    
    // B karakter kódja:
    morseChars[getIndex('B')].length  = 4;
    morseChars[getIndex('B')].pattern  = 0b00000001;
    
    // C karakter kódja:
    morseChars[getIndex('C')].length  = 4;
    morseChars[getIndex('C')].pattern  = 0b00000101;

    // D karakter kódja:
    morseChars[getIndex('D')].length = 3;
    morseChars[getIndex('D')].pattern  = 0b00000001;

     // E karakter kódja:
    morseChars[getIndex('E')].length = 1;
    morseChars[getIndex('E')].pattern  = 0b00000000;

    // F karakter kódja:
    morseChars[getIndex('F')].length = 4;
    morseChars[getIndex('F')].pattern  = 0b00000100;

    // G karakter kódja:
    morseChars[getIndex('G')].length = 3;
    morseChars[getIndex('G')].pattern  = 0b00000011;

    // H karakter kódja:
    morseChars[getIndex('H')].length = 4;
    morseChars[getIndex('H')].pattern  = 0b00000000;

    // I karakter kódja:
    morseChars[getIndex('I')].length = 2;
    morseChars[getIndex('I')].pattern  = 0b00000000;

    // J karakter kódja:
    morseChars[getIndex('J')].length = 4;
    morseChars[getIndex('J')].pattern  = 0b00001110;

    // K karakter kódja:
    morseChars[getIndex('K')].length = 3;
    morseChars[getIndex('K')].pattern  = 0b00000101;

    // L karakter kódja:
    morseChars[getIndex('L')].length = 4;
    morseChars[getIndex('L')].pattern  = 0b00000010;

    // M karakter kódja:
    morseChars[getIndex('M')].length = 2;
    morseChars[getIndex('M')].pattern  = 0b00000011;

    // N karakter kódja:
    morseChars[getIndex('N')].length = 2;
    morseChars[getIndex('N')].pattern  = 0b00000001;

    // O karakter kódja:
    morseChars[getIndex('O')].length = 3;
    morseChars[getIndex('O')].pattern  = 0b00000111;

    // P karakter kódja:
    morseChars[getIndex('P')].length = 4;
    morseChars[getIndex('P')].pattern  = 0b00000110;

    // Q karakter kódja:
    morseChars[getIndex('Q')].length = 4;
    morseChars[getIndex('Q')].pattern  = 0b00001011;

    // R karakter kódja:
    morseChars[getIndex('R')].length = 3;
    morseChars[getIndex('R')].pattern  = 0b00000010;

    // S karakter kódja:
    morseChars[getIndex('S')].length = 3;
    morseChars[getIndex('S')].pattern  = 0b00000000;

    // T karakter kódja:
    morseChars[getIndex('T')].length = 1;
    morseChars[getIndex('T')].pattern  = 0b00000001;

    // U karakter kódja:
    morseChars[getIndex('U')].length = 3;
    morseChars[getIndex('U')].pattern  = 0b00000100;

    // V karakter kódja:
    morseChars[getIndex('V')].length = 4;
    morseChars[getIndex('V')].pattern  = 0b00001000;

    // W karakter kódja:
    morseChars[getIndex('W')].length = 3;
    morseChars[getIndex('W')].pattern  = 0b00000110;

    // X karakter kódja:
    morseChars[getIndex('X')].length = 4;
    morseChars[getIndex('X')].pattern  = 0b00001001;

    // Y karakter kódja:
    morseChars[getIndex('Y')].length = 4;
    morseChars[getIndex('Y')].pattern  = 0b00001101;

    // Z karakter kódja:
    morseChars[getIndex('Z')].length = 4;
    morseChars[getIndex('Z')].pattern  = 0b00000011;
    
    // 0 karakter kódja:
    morseChars[getIndex('0')].length = 5;
    morseChars[getIndex('0')].pattern  = 0b00011111;
    
    // 1 karakter kódja:
    morseChars[getIndex('1')].length  = 5;
    morseChars[getIndex('1')].pattern  = 0b00011110;

    // 2 karakter kódja:
    morseChars[getIndex('2')].length = 5;
    morseChars[getIndex('2')].pattern  = 0b00011100;

    // 3 karakter kódja:
    morseChars[getIndex('3')].length = 5;
    morseChars[getIndex('3')].pattern  = 0b00011000;

    // 4 karakter kódja:
    morseChars[getIndex('4')].length = 5;
    morseChars[getIndex('4')].pattern  = 0b00010000;

    // 5 karakter kódja:
    morseChars[getIndex('5')].length = 5;
    morseChars[getIndex('5')].pattern  = 0b00000000;

    // 6 karakter kódja:
    morseChars[getIndex('6')].length = 5;
    morseChars[getIndex('6')].pattern  = 0b00000001;

    // 7 karakter kódja:
    morseChars[getIndex('7')].length = 5;
    morseChars[getIndex('7')].pattern  = 0b00000011;

    // 8 karakter kódja:
    morseChars[getIndex('8')].length = 5;
    morseChars[getIndex('8')].pattern  = 0b00000111;

    // 9 karakter kódja:
    morseChars[getIndex('9')].length = 5;
    morseChars[getIndex('9')].pattern  = 0b00001111;
}

void setup(){
    fillMorseArray();
    Serial.begin(9600);
    pinMode(outPin, OUTPUT);  
}

void loop() {
  if (Serial.available() > 0) {
    charToMorse(Serial.read());
  }
}

//Ez villogja el az adott karektert.
void charToMorse(char aChar) {
    uint8_t morseIndex = getIndex(aChar); // Megkérdezzük, hol van a tömbben a kért karakter Morze kódja
    if (morseIndex < characterCount) { // Ha a válasz a tömbön belül van, akkor ok, ha nem, akkor nem ismert karakterről van szó.
       for (int i = 0; i < morseChars[morseIndex].length; i++) {
          digitalWrite(outPin, HIGH); // Bekapcsoljuk a kimenetet
          if (((morseChars[morseIndex].pattern >> i) & 1) == 1) { // Megnézzük a pattern i. bit értékét, ha 1, akkor hosszú várakozás kell, mert hosszú (vonás) ideig kell bekapcsolva hagyni a kimenetet
            delay(dashLengthMs);
          }
          else {
            delay(dotLengthMs); // A bit 0, rövid várakozás.
          }
          digitalWrite(outPin, LOW); // Lekapcsoljuk a kimenetet
          delay(dotLengthMs); // Jelköz szünet.
       }
    }
}

[vargham]

Amúgy működik? Csak mert nem próbáltam.

[learner]

Igen működik. Egyetlen probléma az, hogy a szavakat nem lehet elkülöníteni egymástól. De ezt majd megoldom valahogy. Egyébként a sebességet is állítanom kelet mert túl gyors volt.

[vargham]

a szavakat nem lehet elkülöníteni egymástól

Rakd be a space karaktert, amihez hozzárendeled a szóelválasztó szünetet.