RTTTL - Arduino zenelejátszó II.

Eljött az idő, hogy életre keltsd az Arduino projektjeidet az első RTTTL dallamod segítségével. Az RTTTL (Ring Tone Text Transfer Language) lehetővé teszi, hogy könnyedén létrehozz egyszerű, de hatásos hangjelzéseket, amelyek zenei színt adhatnak bármilyen Arduino-projektnek. Ebben az útmutatóban végigvezetlek azon a folyamaton, hogyan készítsd el az első RTTTL kódodat, és töltsd fel azt az Arduino eszközödre. Bemutatom a kód felépítését, a szükséges beállításokat, és hogyan használhatod a hangszórót a dallam megszólaltatásához.

Az RTTTL kódstruktúra meglepően egyszerű, mégis sokoldalú. A dallamot egyetlen karakterláncban adod meg, amely a dallam nevét, az alapértelmezett beállításokat (mint például az oktáv, a tempó, és a hangjegyhossz), valamint magát a hangjegyek sorozatát tartalmazza. Az Arduino és egy hangszóró segítségével ezt a karakterláncot zenévé alakíthatod, amely a projekted hangos visszajelzéséül szolgálhat, akár figyelmeztető hangjelzésekhez, akár szórakoztató effektekhez.

Az első fejezet a RTTTL alapokról, a szükséges librarykról itt található: →RTTTL – Arduino zenelejátszó I.
A harmadik fejezetben zenelejátszásokat tesztelünk és mini zenegépet hozunk össze: →RTTTL – Arduino zenelejátszó III.

Tartalomjegyzék

Az első RTTTL program létrehozása és feltöltése Arduino-ra

Most, hogy minden szükséges eszköz és könyvtár telepítésre került, elérkezett az idő, hogy elkészítsük első RTTTL projektünket Arduino-val. Ebben a fejezetben lépésről lépésre vezetlek végig azon, hogyan hozhatod létre és töltheted fel az első RTTTL dallamodat, valamint belelesünk az alapvető kódstruktúrába és a zenelejátszás megvalósításának módjába.

Az alapvető kódstruktúra ismertetése

Az RTTTL dallamokat az Arduino környezetben egy karakterláncként tároljuk, amely tartalmazza a dallam nevét, a beállításokat (pl. hangjegyhossz, oktáv és tempó), valamint a hangjegyek sorozatát. Az Arduino segítségével a hangszórón keresztül lejátszhatjuk ezt a dallamot, amely egyszerű, de jól hallható zenei visszajelzést ad.

Példa egy egyszerű RTTTL kódra

Star Trek:d=4,o=5,b=63:8f.,16a#,d#.6,8d6,16a#.,16g.,16c.6,f6
TheGodfa:d=8,o=5,b=100:e,a,c6,b,a,c6,a,b,a,f,g,2e,p,e,a,c6,b,a,c6,a,b,a,e,d#,2d

1 2	Star Trek:d=4,o=5,b=63:8f.,16a#,d#.6,8d6,16a#.,16g.,16c.6,f6 TheGodfa:d=8,o=5,b=100:e,a,c6,b,a,c6,a,b,a,f,g,2e,p,e,a,c6,b,a,c6,a,b,a,e,d#,2d

Az RTTTL formátum felépítése:

Név: Az első rész a dallam neve, jelen esetben „Star Trek” illetve „TheGodfa”.
Beállítások: A következő rész tartalmazza az alapértelmezett hangjegyhosszt (d=4), az oktávot (o=5), és a tempót (b=63).
Hangjegyek: A dallam maga egy hangjegysorozat, amelyet különböző hosszúságokkal, oktávbeállításokkal és szünetekkel (pl. , 8f, c6) határozunk meg.

Ez az egyszerű szintaxis teszi lehetővé, hogy gyorsan és könnyedén írjunk meg egy dallamot, amelyet az Arduino segítségével lejátszhatunk.

A kód feltöltése és lejátszása az Arduino-n

Miután beállítottuk az RTTTL-kódot, következhet a kód Arduino-ra történő feltöltése, amely lehetővé teszi a dallam megszólaltatását a hangszórón. Az alábbiakban bemutatok egy egyszerű kódot, amely segít a dallam lejátszásában.

Példa kód az Arduino IDE-hez (AnyRtttl használatával)

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5
const char * tetris = "tetris:d=4,o=5,b=160:e6,8b,8c6,8d6,16e6,16d6,8c6,8b,a,8a,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,2a,8p,d6,8f6,a6,8g6,8f6,e6,8e6,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,a";

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  anyrtttl::blocking::play(BUZZER_PIN, tetris);
  while(true)  { }
}

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

const char * tetris = "tetris:d=4,o=5,b=160:e6,8b,8c6,8d6,16e6,16d6,8c6,8b,a,8a,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,2a,8p,d6,8f6,a6,8g6,8f6,e6,8e6,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,a";

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

}

void loop() {

anyrtttl::blocking::play(BUZZER_PIN, tetris);

while(true) { }

}

Megjegyzés a kódról: A fenti példa egyszerű, és arra optimalizált, hogy a dallam lejátszása gyorsan megkezdődjön, amikor az Arduino elindul. A dallam karakterláncként kerül megadásra, és a anyrtttl::blocking::play(BUZZER_PIN, tetris) függvény felelős a lejátszásért. A loop() rész végén a programkód végtelen ciklusba kerül, hogy csak egyszer játssza le a dallamot. Bár a loop() lehetne üres is, és a setup() tartalmazza ekkor a lejátszást.

Feltöltés az Arduino-ra

A kód feltöltéséhez kövesd az alábbi lépéseket:

Verify: A kód feltöltése előtt kattints a „Verify” gombra az Arduino IDE-ben, amely ellenőrzi, hogy nincs-e szintaktikai hiba a programban.
Upload: A „Verify” után kattints az „Upload” gombra, hogy feltöltsd a programot az Arduino-ra.
Tesztelés: Miután a feltöltés befejeződött, a hangszórón keresztül megszólal a „Mario” dallam. Ha minden megfelelően működik, a dallam tisztán és jól hallhatóan fog szólni.

Tippek és trükkök az első RTTTL projektedhez

Szünetek és hangerő: Az RTTTL kódon belül a szünetek (p) segítenek a dallam tagolásában, így egyedi ritmusokat hozhatsz létre. Az Arduino és a hangszóró által generált hangerőt frekvencia alapján szabályozhatod – a kisebb frekvenciák mélyebb, halkabb hangokat, míg a nagyobb frekvenciák magasabb, élesebb hangokat eredményeznek.
Tempó beállítása: A tempót (b paraméter) változtatva lassabb vagy gyorsabb dallamokat játszhatsz le, attól függően, milyen érzést szeretnél kelteni. Például, ha lassabb tempóra állítod, a dallam szelídebb lesz, míg egy gyorsabb tempóval dinamikusabb hangzást érhetsz el.
Dallamok váltása: Az RTTTL kódokkal könnyedén válthatsz különböző dallamok között, például egy gombnyomásra vagy más események hatására. Az alábbi példakódban bemutatjuk, hogyan játszhatsz le egy újabb dallamot, amikor egy kapcsolót aktiválsz.

Több RTTTL dallam kezelése egy kódban

Íme egy példakód, amely bemutatja, hogyan válthatunk különböző dallamok között nyomógombok segítségével:

#include <anyrtttl.h>
#include <pitches.h>

// Project's constants
#define BUZZER_PIN 5
#define BUTTON1_PIN 2 // Button for the first song
#define BUTTON2_PIN 3 // Button for the second song

const char tetris[] PROGMEM = "tetris:d=4,o=5,b=160:e6,8b,8c6,8d6,16e6,16d6,8c6,8b,a,8a,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,2a,8p,d6,8f6,a6,8g6,8f6,e6,8e6,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,a";
const char mario[] PROGMEM = "mario:d=4,o=5,b=100:16e6,16e6,32p,8e6,16c6,8e6,8g6,8p,8g,8p,8c6,16p,8g,16p,8e,16p,8a,8b,16a#,8a,16g.,16e6,16g6,8a6,16f6,8g6,8e6,16c6,16d6,8b,16p,8c6,16p,8g,16p,8e,16p,8a,8b,16a#,8a,16g.,16e6,16g6,8a6,16f6,8g6,8e6,16c6,16d6,8b,8p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16g#,16a,16c6,16p,16a,16c6,16d6,8p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16c7,16p,16c7,16c7,p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16g#,16a,16c6,16p,16a,16c6,16d6,8p,16d#6,8p,16d6,8p,16c6";

bool isPlaying = false;
int currentSong = 0;

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(BUTTON1_PIN, INPUT_PULLUP); // Button 1 for Tetris
  pinMode(BUTTON2_PIN, INPUT_PULLUP); // Button 2 for Mario
  Serial.begin(115200);
  Serial.println();
  Serial.println("Nyomd meg a megfelelő gombot a dallam lejátszásához:");
  Serial.println("D2: Tetris");
  Serial.println("D3: Mario");
}

void loop() {
  if (digitalRead(BUTTON1_PIN) == LOW) {
    delay(50); // Debouncing delay
    if (!isPlaying || currentSong != 1) {
      stopPlayback();
      Serial.println("Lejátszás: Tetris");
      anyrtttl::nonblocking::beginProgMem(BUZZER_PIN, tetris);
      isPlaying = true;
      currentSong = 1;
    } else {
      stopPlayback();
    }
    waitUntilRelease(BUTTON1_PIN);
  }

  if (digitalRead(BUTTON2_PIN) == LOW) {
    delay(50); // Debouncing delay
    if (!isPlaying || currentSong != 2) {
      stopPlayback();
      Serial.println("Lejátszás: Mario");
      anyrtttl::nonblocking::beginProgMem(BUZZER_PIN, mario);
      isPlaying = true;
      currentSong = 2;
    } else {
      stopPlayback();
    }
    waitUntilRelease(BUTTON2_PIN);
  }

  // Continue playing the current song if it is running
  if (isPlaying && anyrtttl::nonblocking::isPlaying()) {
    anyrtttl::nonblocking::play();
  } else if (isPlaying && !anyrtttl::nonblocking::isPlaying()) {
    isPlaying = false;
    Serial.println("A lejátszás véget ért. Várakozás gombnyomásra...");
  }
}

void stopPlayback() {
  if (isPlaying) {
    anyrtttl::nonblocking::stop();
    isPlaying = false;
    Serial.println("A lejátszás megszakadt.");
  }
}

void waitUntilRelease(int buttonPin) {
  while (digitalRead(buttonPin) == LOW) {
    // Wait until the button is released
  }
}

#include <anyrtttl.h>

#include <pitches.h>

// Project's constants

#define BUZZER_PIN 5

#define BUTTON1_PIN 2 // Button for the first song

#define BUTTON2_PIN 3 // Button for the second song

const char tetris[] PROGMEM = "tetris:d=4,o=5,b=160:e6,8b,8c6,8d6,16e6,16d6,8c6,8b,a,8a,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,2a,8p,d6,8f6,a6,8g6,8f6,e6,8e6,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,a";

const char mario[] PROGMEM = "mario:d=4,o=5,b=100:16e6,16e6,32p,8e6,16c6,8e6,8g6,8p,8g,8p,8c6,16p,8g,16p,8e,16p,8a,8b,16a#,8a,16g.,16e6,16g6,8a6,16f6,8g6,8e6,16c6,16d6,8b,16p,8c6,16p,8g,16p,8e,16p,8a,8b,16a#,8a,16g.,16e6,16g6,8a6,16f6,8g6,8e6,16c6,16d6,8b,8p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16g#,16a,16c6,16p,16a,16c6,16d6,8p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16c7,16p,16c7,16c7,p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16g#,16a,16c6,16p,16a,16c6,16d6,8p,16d#6,8p,16d6,8p,16c6";

bool isPlaying = false;

int currentSong = 0;

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

pinMode(BUTTON1_PIN, INPUT_PULLUP); // Button 1 for Tetris

pinMode(BUTTON2_PIN, INPUT_PULLUP); // Button 2 for Mario

Serial.begin(115200);

Serial.println();

Serial.println("Nyomd meg a megfelelő gombot a dallam lejátszásához:");

Serial.println("D2: Tetris");

Serial.println("D3: Mario");

}

void loop() {

if (digitalRead(BUTTON1_PIN) == LOW) {

delay(50); // Debouncing delay

if (!isPlaying || currentSong != 1) {

stopPlayback();

Serial.println("Lejátszás: Tetris");

anyrtttl::nonblocking::beginProgMem(BUZZER_PIN, tetris);

isPlaying = true;

currentSong = 1;

} else {

stopPlayback();

}

waitUntilRelease(BUTTON1_PIN);

}

if (digitalRead(BUTTON2_PIN) == LOW) {

delay(50); // Debouncing delay

if (!isPlaying || currentSong != 2) {

stopPlayback();

Serial.println("Lejátszás: Mario");

anyrtttl::nonblocking::beginProgMem(BUZZER_PIN, mario);

isPlaying = true;

currentSong = 2;

} else {

stopPlayback();

}

waitUntilRelease(BUTTON2_PIN);

}

// Continue playing the current song if it is running

if (isPlaying && anyrtttl::nonblocking::isPlaying()) {

anyrtttl::nonblocking::play();

} else if (isPlaying && !anyrtttl::nonblocking::isPlaying()) {

isPlaying = false;

Serial.println("A lejátszás véget ért. Várakozás gombnyomásra...");

}

void stopPlayback() {

if (isPlaying) {

anyrtttl::nonblocking::stop();

isPlaying = false;

Serial.println("A lejátszás megszakadt.");

}

void waitUntilRelease(int buttonPin) {

while (digitalRead(buttonPin) == LOW) {

// Wait until the button is released

}

A program két gombbal vezérelhető dallamlejátszást valósít meg egy hangszórón Arduino-n. A D2 gomb a Tetris, a D3 gomb a Mario dallamot indítja el. A lejátszás nonblocking módon történik, így közben a program fut tovább. Ha egy gombot újból lenyomnak, a lejátszás megszakad. A soros monitor minden eseményt visszajelez, például a lejátszás indítását, megszakítását és végét. Ez a példa jól szemlélteti, hogyan használhatók az RTTTL dallamok dinamikusan, az Arduino által érzékelt eseményekre reagálva. Ezzel lehetőséget ad arra, hogy különféle interaktív hangjelzéseket vagy zenei visszajelzéseket adjunk a projektjeinkhez.

Gyakori problémák és azok megoldása

A dallam nem szólal meg: Ellenőrizd, hogy a hangszóró megfelelően csatlakozik-e a boardhoz, és nincs-e szünet vagy szakadási hiba az áramkörben. Győződj meg arról is, hogy a megfelelő kimeneti pin-t használod.
A dallam akadozik: Ha több funkciót futtatsz egyszerre az Arduino-n, válaszd a nem blokkoló funkciót támogató könyvtárakat, mint a NonBlockingRTTTL vagy az AnyRtttl, hogy a dallam folyamatosan szólhasson.
A tempó nem megfelelő: Győződj meg arról, hogy a b értéke a kívánt tempóra van állítva az RTTTL kódban. Néha egy kisebb tempóérték segíthet a lassabb, precízebb dallamok lejátszásában.

Az első RTTTL projekt elkészítése után hamar ráérezhetsz, hogyan adhatod hozzá az Arduino projektjeidhez a zene hangulatát és az egyedi visszajelzéseket. A következő fejezetben részletesen bemutatásra kerül, hogyan lehet tovább testreszabni az RTTTL dallamokat a hangfrekvenciák és hangszekvenciák változtatásával.

RTTTL libraryk testreszabása és hangbeállítások

Miután létrehoztad az első RTTTL alapú Arduino projektedet, érdemes elmélyülni a hangbeállítások és testreszabási lehetőségek világában. Az RTTTL formátum rugalmassága és az Arduino képességei lehetőséget nyújtanak arra, hogy teljesen egyedi hangzásvilágot hozz létre. Az alábbiakban bemutatom, hogyan szabhatod testre a dallamokat, finomíthatod a hangfrekvenciákat és hogyan hozhatsz létre komplex hangszekvenciákat.

Arduino RTTTL könyvtárak telepítése — Testreszabás

Hangfrekvenciák beállítása

Az RTTTL formátum egyik legfontosabb eleme a dallam frekvenciája, amely meghatározza, hogy milyen magasságú hangot hallunk. Az RTTTL dallamokban a frekvencia közvetetten jelenik meg, hiszen a dallam karakterláncában csak a hangjegyeket és azok oktávját adjuk meg. Az Arduino azonban ezt az információt frekvenciává alakítja, amit aztán a hangszórón megszólaltat.

Hogyan működik a frekvenciaváltás az Arduino-ban?

Az Arduino alaplap a különböző hangjegyekhez adott frekvenciát generál. Például egy c hang az 5. oktávban (c5) alacsonyabb frekvenciájú, mint egy c hang a 6. oktávban (c6). Minél magasabb az oktáv száma, annál magasabb a frekvencia, így a hang is magasabbnak tűnik. Az RTTTL formátumban az oktávok számával könnyedén módosíthatod a hangok frekvenciáját, így játszhatsz a magas és mély hangok váltakozásával.

Példa az oktávok és frekvenciák használatára

Az alábbi példában egy egyszerű dallamot látunk, amely különböző oktávú hangokat tartalmaz, így hallható lesz a különbség az alacsonyabb és magasabb frekvenciák között:

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5
const char * melody = "Octaves:d=4,o=5,b=120: c5,d5,e5,c6,d6,e6,c7,d7,e7";

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  anyrtttl::blocking::play(BUZZER_PIN, melody);
}

void loop() { }

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

const char * melody = "Octaves:d=4,o=5,b=120: c5,d5,e5,c6,d6,e6,c7,d7,e7";

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

anyrtttl::blocking::play(BUZZER_PIN, melody);

}

void loop() { }

A fenti kód különböző oktávokat használ (c, c6, c7), így egyre magasabb frekvenciájú hangokat hallunk. Ez a megközelítés hasznos lehet például riasztó rendszerek vagy interaktív játékok létrehozásánál, ahol a hangmagasság váltakozása fontos szerepet játszik.

Hangszekvenciák létrehozása

A hangszekvenciák variálásával egyedi dallamokat hozhatsz létre, amelyek pontosan illeszkednek az adott projekthez. Az RTTTL formátum segítségével könnyedén megadhatod, hogy a hangjegyek milyen hosszan szólaljanak meg, milyen ritmusban, és mennyi szünet legyen köztük. Az alábbiakban bemutatom, hogyan kombinálhatók különböző hangjegyek és hosszak egyedi hangszekvenciák létrehozásához.

Hanghosszúság és szünetek

Az RTTTL dallam karakterláncában a hangjegyek előtt egy számmal megadhatjuk azok hosszát. Például a 4e azt jelenti, hogy a e hangjegy negyed hosszúságú, míg a 8e fele olyan hosszú, vagyis nyolcad hosszúságú. Ha szeretnénk egy kis szünetet is, egyszerűen p karaktert használhatunk a megfelelő hosszúsággal, például p4 egy negyed hosszúságú szünetet ad.

Példa hanghosszúságok és szünetek használatára

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5
const char * melody = "Rhythm:d=4,o=5,b=100: 8c,8p,8c,4e,8p,8e,4g";

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  anyrtttl::blocking::play(BUZZER_PIN, melody);
}

void loop() { }

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

const char * melody = "Rhythm:d=4,o=5,b=100: 8c,8p,8c,4e,8p,8e,4g";

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

anyrtttl::blocking::play(BUZZER_PIN, melody);

}

void loop() { }

Ebben a kódban a p karakterrel szüneteket adtunk a dallamhoz, amely ritmust és karaktert ad a dallamnak. Ezáltal egyedi, változatos hangszekvenciákat hozhatsz létre, amelyek egyedi visszajelzést nyújtanak például egy ajtócsengőhöz vagy egy riasztórendszerhez.

Illusztráció különböző RTTTL tippek vizuális elemekkel: tempóbeállítás, szünetek és hangerő variálás. Egy hőmérő ikon mutatja a tempó változását, míg egy szünet ikon a dallam szüneteit. — Tempó beállítása, szünetek használata, hangerő variálás.

A tempó (BPM) és annak hatása a hangzásra

Az RTTTL dallam tempóját a b paraméter állítja be, amely a lejátszási sebességet határozza meg ütés per perc (BPM) értékben. Az alap tempóérték 120 BPM, de ezt könnyedén módosíthatod a kívánt hatás érdekében. Például egy lassú dallam jobban illik egy figyelmeztető vagy nyugtató jelzéshez, míg a gyors tempó sürgető hangulatot kölcsönöz.

Példa tempó változtatásra

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5
const char * fastMelody = "Fast:d=4,o=5,b=180: g,g,a,a,b,b,c6"; 
const char * slowMelody = "Slow:d=4,o=5,b=60: g,g,a,a,b,b,c6";

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  anyrtttl::blocking::play(BUZZER_PIN, fastMelody);
  delay(1000);
  anyrtttl::blocking::play(BUZZER_PIN, slowMelody);
}

void loop() {
    // Üres, mert a dallamok egyszer játszódnak le egymás után 
}

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

const char * fastMelody = "Fast:d=4,o=5,b=180: g,g,a,a,b,b,c6";

const char * slowMelody = "Slow:d=4,o=5,b=60: g,g,a,a,b,b,c6";

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

anyrtttl::blocking::play(BUZZER_PIN, fastMelody);

delay(1000);

anyrtttl::blocking::play(BUZZER_PIN, slowMelody);

}

void loop() {

// Üres, mert a dallamok egyszer játszódnak le egymás után

}

A fenti kódban két különböző tempójú dallamot játszunk le. Az első dallam gyorsabb, míg a második lassabb, így jól érezhető a különbség a tempó hatására. Ez a megközelítés különösen hasznos lehet különféle események jelzésére – például gyors tempó figyelmeztető vagy sürgető jelzést sugallhat, míg a lassú tempó nyugtató hatású lehet.

Összetett dallamok és ismétlődések létrehozása

Az Arduino-val összetett dallamokat is létrehozhatsz ismétlések és különböző tempók kombinálásával. Ha például egy dallam több szakaszból áll, létrehozhatod külön-külön a szekciókat, majd egymás után lejátszhatod őket egy közös dallamként. Az ismétlések és szekvenciák különösen jól alkalmazhatók játékelemek vagy interaktív felületek visszajelzésére, ahol az események különböző dallamokkal követhetők.

Példa összetett dallam létrehozására

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5
const char * Melody1 = "Part1:d=4,o=5,b=120: e,e,f,g"; 
const char * Melody2 = "Part2:d=4,o=5,b=120: g,f,e,d";

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  anyrtttl::blocking::play(BUZZER_PIN, Melody1);
  //Kis szünet
  delay(10);  
  anyrtttl::blocking::play(BUZZER_PIN, Melody2);
}

void loop() {
 // Üres, mert a dallamok egyszer játszódnak le egymás után 
}

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

const char * Melody1 = "Part1:d=4,o=5,b=120: e,e,f,g";

const char * Melody2 = "Part2:d=4,o=5,b=120: g,f,e,d";

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

anyrtttl::blocking::play(BUZZER_PIN, Melody1);

//Kis szünet

delay(10);

anyrtttl::blocking::play(BUZZER_PIN, Melody2);

}

void loop() {

// Üres, mert a dallamok egyszer játszódnak le egymás után

}

Ezzel a módszerrel több részletből álló dallamokat hozhatsz létre, amelyeket könnyedén testre szabhatsz a saját projekted igényeinek megfelelően.

Dinamikus hangerő szabályozása és visszajelzési lehetőségek

Az Arduino nem támogat közvetlen hangerőszabályozást a hangszóró esetében, mivel az eszköz egyszerű digitális jelek alapján szólal

meg. Azonban, a hangerőt közvetetten szabályozhatjuk azzal, hogy különböző hosszúságú szüneteket vagy változatos frekvenciákat alkalmazunk. Ezzel az egyszerű trükkel egyedi hangerőérzetet kelthetsz – például a szorosabban egymás után szólaló hangjegyek hangosabbnak, míg a szünetekkel megszakított hangjegyek halkabbnak tűnhetnek.

Példa hangerőérzet változtatására

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5

// „Hangosabb” dallam szoros hangjegyekkel
const char * Melody1 = "Louder:d=4,o=5,b=140: e,e,e,e"; 
// „Halkabb” dallam szünetekkel
const char * Melody2 = "Softer:d=4,o=5,b=140: e,8p,e,8p,e";

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  anyrtttl::blocking::play(BUZZER_PIN, Melody1);
  //Kis szünet
  delay(10);  
  anyrtttl::blocking::play(BUZZER_PIN, Melody2);
}

void loop() {
 // Üres, mert a dallamok egyszer játszódnak le egymás után 
 }

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

// „Hangosabb” dallam szoros hangjegyekkel

const char * Melody1 = "Louder:d=4,o=5,b=140: e,e,e,e";

// „Halkabb” dallam szünetekkel

const char * Melody2 = "Softer:d=4,o=5,b=140: e,8p,e,8p,e";

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

anyrtttl::blocking::play(BUZZER_PIN, Melody1);

//Kis szünet

delay(10);

anyrtttl::blocking::play(BUZZER_PIN, Melody2);

}

void loop() {

// Üres, mert a dallamok egyszer játszódnak le egymás után

}

Ez a megközelítés lehetőséget ad arra, hogy a dallamok különböző érzelmi töltettel szólaljanak meg, így még inkább igazíthatók a projekt jellegéhez.

Gyakori hibák és azok elkerülése RTTTL használata közben

Az RTTTL könyvtárak használata az Arduino platformon rendkívül hasznos eszköz, amellyel könnyedén adhatsz hangalapú visszajelzéseket a projektjeidhez. Azonban, mint minden technológia esetében, itt is felmerülhetnek olyan hibák, amelyek gátolják a zökkenőmentes működést. Ebben a fejezetben összegyűjtöttem a leggyakoribb problémákat, amelyekkel az RTTTL használata során találkozhatsz, és javaslatokat adok ezek elkerülésére és megoldására.

A dallam nem szólal meg

Ez az egyik leggyakoribb probléma, és számos oka lehet. Íme néhány lépés, amely segíthet az ilyen helyzetek kezelésében.

Hibaelhárítási lépések

Ellenőrizd a hangszóró csatlakoztatását: Gyakran előfordul, hogy a hangszóró nincs megfelelően csatlakoztatva. Győződj meg arról, hogy a hangszóró egyik kivezetése az Arduino GND lábához, a másik pedig a kimeneti pinhez (például D5) csatlakozik.
Ellenőrizd a pin beállításait: Ha a kódodban megadtad a hangszóró csatlakozási pontját, győződj meg róla, hogy a megfelelő pin számot használod. Ha például a D5 pin-t használod, győződj meg róla, hogy a kódod is ezt a pin-t tartalmazza.
Teszteld egy alap RTTTL kóddal: Írj be egy egyszerű RTTTL dallamot, például e,e,f,g, és ellenőrizd, hogy működik-e. Ha ez megszólal, valószínű, hogy a bonyolultabb dallamokban lehet a hiba.
Vizsgáld meg a kódod logikáját: Nézd át a setup() és a loop() részeket, hogy biztosan ne hagyd figyelmen kívül a megfelelő hívásokat. Például ha a loop() üres, a dallam csak egyszer szólal meg induláskor.

Példa alap RTTTL kódra

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5

const char * Melody1 = "Test:d=4,o=5,b=100: e,e,f,g"; 

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  anyrtttl::blocking::play(BUZZER_PIN, Melody1);
}

void loop() { }

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

const char * Melody1 = "Test:d=4,o=5,b=100: e,e,f,g";

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

anyrtttl::blocking::play(BUZZER_PIN, Melody1);

}

void loop() { }

A dallam megszakad vagy akadozik

Ez a probléma akkor jelentkezhet, ha a dallam lejátszása blokkolja a program többi részét, vagy ha túl sok folyamat fut egyszerre az Arduino-n. Az akadozó vagy megszakadó dallam sokszor a nem blokkoló funkciók hiányából fakad.

Megoldási javaslatok:

Használj nem blokkoló könyvtárat: A NonBlockingRTTTL vagy az AnyRtttl könyvtárak kifejezetten úgy lettek fejlesztve, hogy a dallamok lejátszása közben más funkciók is futhassanak az Arduino-n. Így biztosíthatod, hogy a dallamok lejátszása nem blokkolja a többi programot.
Csökkentsd az egyidejű folyamatokat: Ha egyidejűleg több szenzorral és LED-del is dolgozol, próbáld meg csökkenteni az egyidejűleg futó feladatokat, hogy elegendő feldolgozási teljesítményt biztosíts a dallamoknak.
Időzítés pontosítása: Gyakran a megfelelő delay() hívások használata segíthet abban, hogy a dallam folyamatosan lejátszódjon. Például, ha egy bizonyos időintervallum után ismételten el akarod indítani a dallamot, használd a delay() vagy millis() funkciókat a megfelelő időzítéshez.

A dallam nem a kívánt sebességgel (tempóval) szólal meg

Az RTTTL formátumban a tempót (BPM) a b paraméterrel állítjuk be, ami a lejátszási sebességet szabályozza. Ha a dallam túl lassan vagy túl gyorsan szólal meg, lehet, hogy nem megfelelően van beállítva a tempó.

Javaslatok a tempó beállításához

Ellenőrizd a BPM értékét: A BPM értéke az RTTTL kódban található b paraméternél állítható. Ha például gyorsabb dallamot szeretnél, növeld a BPM értékét (például b=140), ha lassabbat, akkor csökkentsd (például b=90).
Teszteld különböző tempókkal: Írj be többféle BPM értéket, hogy lásd a különbséget. Próbáld ki az alábbi kódot és figyeld meg, hogy a tempó változtatásával hogyan változik a dallam sebessége.

Hanghibák: túl magas vagy túl alacsony hangok

Ha a dallam furcsán, torzan vagy a vártnál magasabb vagy mélyebb hangon szól, annak oka lehet a nem megfelelő oktáv vagy frekvencia beállítása az RTTTL karakterláncban.

Megoldási lehetőségek

Ellenőrizd az oktávot: Az RTTTL karakterláncban az o értéke határozza meg az alapértelmezett oktávot. Ha az o=5, akkor a hangok a középértéken szólnak. Kísérletezz alacsonyabb (o=4) vagy magasabb (o=6) értékkel, hogy megtaláld a kívánt hangmagasságot.
Teszteld egy alap RTTTL kóddal: Próbálj meg egy egyszerű dallamot az alap oktávban, majd változtasd meg az oktávot, hogy megtaláld az ideális beállítást. Például a d=4,o=5 beállítást variálva tapasztalhatod a különbségeket.

A hangszóró túl halk vagy túl hangos

A hangszórók jellemzően fix hangerővel szólnak, mivel egyszerű digitális jelekkel vezéreljük őket. Ha úgy érzed, hogy a hangszóró túl hangos vagy túl halk, itt van néhány trükk, amellyel ezt szabályozhatod.

Tippek a hangerő szabályozásához:

Frekvencia variálása: Bár nem lehet közvetlenül hangerőt szabályozni, a különböző frekvenciák eltérő hangerőérzetet kelthetnek. A magasabb frekvenciák élesebbek, és „hangosabbnak” tűnhetnek, míg az alacsonyabbak mélyebb és halkabb érzetet adnak.
Hangszóró burkolása: Fizikailag is csökkentheted a hangerőt azzal, hogy a hangszórót részben burkolod vagy elhelyezed egy dobozban. Ez csillapítja a hangot, és halkabb érzetet kelt.
Szünetek és ritmusok alkalmazása: Ha hosszabb szüneteket adsz a hangjegyek közé, halkabb hatást érhetsz el, míg a szorosabb, rövid hangjegyek hangosabbnak tűnhetnek. Ez a módszer különösen hasznos lehet, ha valamilyen jelzésként vagy figyelmeztetésként szeretnéd a hangot használni.

Blocking vs. Nonblocking RTTTL lejátszás Arduino lapon

Az RTTTL használata közben az egyik legfontosabb döntés, amit meg kell hoznod, hogy a dallam lejátszását blokkoló (blocking) vagy nem blokkoló (nonblocking) módszerrel szeretnéd megvalósítani. Ez a választás jelentősen befolyásolja a projekted működését és rugalmasságát. Ebben a fejezetben részletesen bemutatom a két módszer közötti különbséget, a használatuk előnyeit és hátrányait, valamint konkrét példákat adok a megvalósításukra.

Egy kétoldalas ábra, ahol az egyik oldalon a blokkoló lejátszás folyamata (Arduino, ami csak zenét játszik), a másik oldalon a nem blokkoló lejátszás látható (Arduino, ami zenét játszik és közben LED-et vezérel) — Blocking vs. Nonblocking lejátszás az Arduino-n

Mi a különbség a Blocking és a Nonblocking között?

Blocking (blokkoló) lejátszás: A blokkoló lejátszás során a dallam lejátszása közben az Arduino nem végez más feladatokat. Az anyrtttl::blocking::play() függvény hívása alatt a program várakozik, amíg a dallam teljesen lejátszódik. Ez egyszerűsíti a kódot, de egyúttal megakadályozza, hogy más funkciók is futtathatók legyenek a lejátszás közben.
Nonblocking (nem blokkoló) lejátszás: A nem blokkoló lejátszás lehetővé teszi, hogy a dallam megszólaltatása közben az Arduino más feladatokat is végrehajtson. Ezáltal például érzékelőket kezelhetünk, LED-eket vezérelhetünk, vagy más eseményeket figyelhetünk. Az anyrtttl::nonblocking::play() függvény használatával a lejátszás a háttérben zajlik.

Mikor melyiket válaszd?

Blocking módszer:
- Előnyök:
  - Egyszerűbb megvalósítás és kód.
  - Ideális, ha a projektben a dallam lejátszása közben nincs szükség más feladatokra.
- Hátrányok:
  - Az Arduino nem képes más események kezelésére, amíg a dallam szól.
  - Nem alkalmas összetett, párhuzamos működést igénylő projektekhez.
- Használat: Olyan projektekhez, ahol a dallam lejátszása az egyetlen feladat, például egyszerű riasztók, szignálok.
Nonblocking módszer:
- Előnyök:
  - A dallam lejátszása közben az Arduino más feladatokat is végrehajthat.
  - Ideális olyan projektekhez, ahol az események párhuzamos kezelése szükséges, például interaktív játékok, riasztórendszerek, komplex vezérlőrendszerek.
- Hátrányok:
  - Összetettebb kód szükséges a kezeléséhez.
  - A projekt struktúrája gondos tervezést igényel a zavartalan működéshez.
- Használat: Olyan projektekhez, ahol több funkció egyidejű kezelése fontos, például érzékelők figyelése és visszajelzés adása egy időben.

Blocking példakód

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5
const char * tetris = "tetris:d=4,o=5,b=160:e6,8b,8c6,8d6,16e6,16d6,8c6,8b,a,8a,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,2a,8p,d6,8f6,a6,8g6,8f6,e6,8e6,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,a";

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  anyrtttl::blocking::play(BUZZER_PIN, tetris);
}

void loop() {
   //nem csinálunk semmit
}

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

const char * tetris = "tetris:d=4,o=5,b=160:e6,8b,8c6,8d6,16e6,16d6,8c6,8b,a,8a,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,2a,8p,d6,8f6,a6,8g6,8f6,e6,8e6,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,a";

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

anyrtttl::blocking::play(BUZZER_PIN, tetris);

}

void loop() {

//nem csinálunk semmit

}

Magyarázat: Ez a kód egy egyszerű dallamot játszik le, és a setup() függvényben van megadva, mivel egyszer kerül lejátszásra. Ez a módszer egyszerű és hatékony, ha csak a dallam lejátszására van szükség.

Nonblocking példakód

#include <anyrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5
#define LED_PIN 13 // Egy LED a visszajelzéshez

const char * melody = "Interactive:d=4,o=5,b=120: e,e,f,g,a,g,f,e";
bool isPlaying = false;

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  // Ha nem játszik a dallam, indítsd el
  if (!isPlaying) {
    anyrtttl::nonblocking::begin(BUZZER_PIN, melody);
    isPlaying = true;
  }

  // Folyamatosan hívja a lejátszást fenntartó függvényt
  if (isPlaying && !anyrtttl::nonblocking::isPlaying()) {
    isPlaying = false; // A dallam lejátszása véget ért
  } else {
    anyrtttl::nonblocking::play();
  }

  // LED villogtatása a dallam lejátszása közben
  if (isPlaying) {
    digitalWrite(LED_PIN, millis() % 500 < 250 ? HIGH : LOW);
  } else {
    digitalWrite(LED_PIN, LOW);
  }
}

#include <anyrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

#define LED_PIN 13 // Egy LED a visszajelzéshez

const char * melody = "Interactive:d=4,o=5,b=120: e,e,f,g,a,g,f,e";

bool isPlaying = false;

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

pinMode(LED_PIN, OUTPUT);

}

void loop() {

// Ha nem játszik a dallam, indítsd el

if (!isPlaying) {

anyrtttl::nonblocking::begin(BUZZER_PIN, melody);

isPlaying = true;

}

// Folyamatosan hívja a lejátszást fenntartó függvényt

if (isPlaying && !anyrtttl::nonblocking::isPlaying()) {

isPlaying = false; // A dallam lejátszása véget ért

} else {

anyrtttl::nonblocking::play();

}

// LED villogtatása a dallam lejátszása közben

if (isPlaying) {

digitalWrite(LED_PIN, millis() % 500 < 250 ? HIGH : LOW);

} else {

digitalWrite(LED_PIN, LOW);

}

Magyarázat: Ebben a kódban a dallam lejátszása nonblocking módon történik, így az Arduino a loop() függvényen keresztül képes más feladatokat is ellátni. Ebben az esetben egy LED villog, amíg a dallam szól, demonstrálva a párhuzamos működés lehetőségét.

Összegzés

A blocking módszer egyszerű és hatékony, de korlátozott rugalmasságot kínál. Alkalmas olyan projektekhez, ahol a dallam lejátszása alatt nincs szükség más tevékenységekre. A nonblocking módszer bonyolultabb, de lehetővé teszi, hogy az Arduino több feladatot kezeljen egyszerre, így ideális összetettebb projektekhez, ahol párhuzamos eseményekre van szükség. A választás mindig az adott projekt céljától és összetettségétől függ.

Flash vagy SRAM?

Amikor Arduino projekteken dolgozol, különösen zenei projekteken, fontos megérteni, hogyan kezelheted a memóriát hatékonyan, hiszen az eszközökön elérhető memória korlátozott. Az RTTTL dallamok lejátszásához használt kódban a dallamokat tárolhatod az eszköz két fő memóriatípusában: a SRAM-ban (Static Random Access Memory) és a Flash memóriában. Az alábbiakban bemutatom, hogy miként kezelheted ezeket a memóriákat, valamint az egyes típusok használatának előnyeit és hátrányait.

Az Arduino memóriafelépítése: SRAM és Flash

Az Arduino eszközök általában kétféle memóriával rendelkeznek: a gyors, de korlátozott méretű SRAM, és a nagyobb, de lassabban elérhető Flash memória. Az SRAM az az operatív memória, amelyet a programok futás közben használnak adatok tárolására, míg a Flash a programkód és az állandó adatok tárolására szolgál, és az újraindítás után is megőrzi tartalmát.

Diagram, amely az Arduino memória két típusát (SRAM és Flash) ábrázolja. Kiemelve az előnyöket és hátrányokat (SRAM gyorsabb, de kisebb; Flash nagyobb, de lassabb). — RTTTL dallamok kezelése: SRAM vs. Flash.

Az RTTTL dallamok tárolása az SRAM-ban

Az SRAM használata előnyös lehet, ha a projekted kisebb méretű, és gyors hozzáférést igényel a változókhoz és adatokhoz. Az RTTTL dallamok betöltése az SRAM-ba egyszerű, és gyorsan elérhetők a futó program számára. Azonban az Arduino eszközökön az SRAM mérete korlátozott (tipikusan 2 kB a legtöbb AVR alapú eszközön), így a nagyobb adatok vagy komplex dallamok gyorsan kimeríthetik a rendelkezésre álló memóriát.

Előnyök:

Gyors hozzáférés az adatokhoz, ami előnyös a valós idejű feldolgozásnál.
Egyszerűbb kódolás és adatkezelés futás közben.

Hátrányok:

Korlátozott méret, amely nagyobb projektekben gyorsan megtelik.
Az adatok csak a futás idejére maradnak meg, újraindítás után elvesznek.

Az RTTTL dallamok tárolása a Flash memóriában

A Flash memória használata lehetővé teszi, hogy nagyobb mennyiségű adatot tárolj anélkül, hogy az SRAM kapacitását terhelnéd. Az Arduino programkódja általában a Flash-ben található, és a programba beágyazott adatok is itt tárolhatók. A Flash használata hasznos lehet olyan projektekben, ahol több vagy hosszabb dallamot szeretnél lejátszani, mivel ezek nem foglalják el az értékes SRAM helyet.

A Flash memóriában tárolt adatok elérése kissé eltérő szintaxist igényel. Az PROGMEM makróval jelölheted meg, hogy egy változót a Flash-ben szeretnél tárolni. Az pgm_read_* függvényekkel és a megfelelő könyvtárakkal biztosíthatod, hogy a program futás közben is elérje a Flash-ben tárolt adatokat.

Példa Flash memória használatára:

#include <anyrtttl.h>
#include <binrtttl.h>
#include <pitches.h>

#define BUZZER_PIN 5
const char tetris[] PROGMEM = "tetris:d=4,o=5,b=160:e6,8b,8c6,8d6,16e6,16d6,8c6,8b,a,8a,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,2a,8p,d6,8f6,a6,8g6,8f6,e6,8e6,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,a";
const char arkanoid[] PROGMEM = "Arkanoid:d=4,o=5,b=140:8g6,16p,16g.6,2a#6,32p,8a6,8g6,8f6,8a6,2g6";
const char mario[] PROGMEM = "mario:d=4,o=5,b=140:16e6,16e6,32p,8e6,16c6,8e6,8g6,8p,8g,8p,8c6,16p,8g,16p,8e,16p,8a,8b,16a#,8a,16g.,16e6,16g6,8a6,16f6,8g6,8e6,16c6,16d6,8b,16p,8c6,16p,8g,16p,8e,16p,8a,8b,16a#,8a,16g.,16e6,16g6,8a6,16f6,8g6,8e6,16c6,16d6,8b,8p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16g#,16a,16c6,16p,16a,16c6,16d6,8p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16c7,16p,16c7,16c7,p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16g#,16a,16c6,16p,16a,16c6,16d6,8p,16d#6,8p,16d6,8p,16c6";
// James Bond theme defined in inline code below (also stored in flash memory) 

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  anyrtttl::blocking::playProgMem(BUZZER_PIN, tetris);
  delay(1000);

  anyrtttl::blocking::play_P(BUZZER_PIN, arkanoid);
  delay(1000);

#if defined(ESP8266)
  anyrtttl::blocking::play(BUZZER_PIN, FPSTR(mario));
  delay(1000);
#endif

  anyrtttl::blocking::play(BUZZER_PIN, F("Bond:d=4,o=5,b=80:32p,16c#6,32d#6,32d#6,16d#6,8d#6,16c#6,16c#6,16c#6,16c#6,32e6,32e6,16e6,8e6,16d#6,16d#6,16d#6,16c#6,32d#6,32d#6,16d#6,8d#6,16c#6,16c#6,16c#6,16c#6,32e6,32e6,16e6,8e6,16d#6,16d6,16c#6,16c#7,c.7,16g#6,16f#6,g#.6"));
  delay(1000);

  while(true)  {  }
}

#include <anyrtttl.h>

#include <binrtttl.h>

#include <pitches.h>

#define BUZZER_PIN 5

const char tetris[] PROGMEM = "tetris:d=4,o=5,b=160:e6,8b,8c6,8d6,16e6,16d6,8c6,8b,a,8a,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,2a,8p,d6,8f6,a6,8g6,8f6,e6,8e6,8c6,e6,8d6,8c6,b,8b,8c6,d6,e6,c6,a,a";

const char arkanoid[] PROGMEM = "Arkanoid:d=4,o=5,b=140:8g6,16p,16g.6,2a#6,32p,8a6,8g6,8f6,8a6,2g6";

const char mario[] PROGMEM = "mario:d=4,o=5,b=140:16e6,16e6,32p,8e6,16c6,8e6,8g6,8p,8g,8p,8c6,16p,8g,16p,8e,16p,8a,8b,16a#,8a,16g.,16e6,16g6,8a6,16f6,8g6,8e6,16c6,16d6,8b,16p,8c6,16p,8g,16p,8e,16p,8a,8b,16a#,8a,16g.,16e6,16g6,8a6,16f6,8g6,8e6,16c6,16d6,8b,8p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16g#,16a,16c6,16p,16a,16c6,16d6,8p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16c7,16p,16c7,16c7,p,16g6,16f#6,16f6,16d#6,16p,16e6,16p,16g#,16a,16c6,16p,16a,16c6,16d6,8p,16d#6,8p,16d6,8p,16c6";

// James Bond theme defined in inline code below (also stored in flash memory)

void setup() {

pinMode(BUZZER_PIN, OUTPUT);

}

void loop() {

anyrtttl::blocking::playProgMem(BUZZER_PIN, tetris);

delay(1000);

anyrtttl::blocking::play_P(BUZZER_PIN, arkanoid);

delay(1000);

#if defined(ESP8266)

anyrtttl::blocking::play(BUZZER_PIN, FPSTR(mario));

delay(1000);

#endif

anyrtttl::blocking::play(BUZZER_PIN, F("Bond:d=4,o=5,b=80:32p,16c#6,32d#6,32d#6,16d#6,8d#6,16c#6,16c#6,16c#6,16c#6,32e6,32e6,16e6,8e6,16d#6,16d#6,16d#6,16c#6,32d#6,32d#6,16d#6,8d#6,16c#6,16c#6,16c#6,16c#6,32e6,32e6,16e6,8e6,16d#6,16d6,16c#6,16c#7,c.7,16g#6,16f#6,g#.6"));

delay(1000);

while(true) { }

}

Előnyök:

Nagyobb adatmennyiséget tárolhatsz anélkül, hogy kimerítenéd az SRAM-ot.
Az adatok az újraindítás után is megmaradnak, mivel a Flash memória nem felejt.

Hátrányok:

Lassabb elérési idő, mint az SRAM esetében.
Az adatok olvasása és kezelése kicsit bonyolultabb, mert speciális függvényekre van szükség.

SRAM vs. Flash – melyiket válaszd?

A választás az adott projekt igényeitől függ. Ha csak néhány, rövid dallamot szeretnél lejátszani, és elegendő az SRAM kapacitása, akkor érdemes az SRAM-ot használni a gyors hozzáférés és egyszerű kódolás érdekében. Ha viszont több vagy hosszabb dallamot szeretnél tárolni, a Flash memória a jobb választás, hogy megóvd az SRAM kapacitását, és elkerüld a memóriahiány miatti hibákat.

Összegzésül: a Flash memória használatával a projekted nagyobb szabadságot kap a nagyobb adatmennyiségek kezelésében, miközben a kritikus futási adatok az SRAM-ban maradhatnak. Az ideális megoldás az, ha a Flash memóriában tárolsz minden olyan adatot, amely nem változik a program futása során, és az SRAM-ot csak a dinamikus, futás közben változó adatokhoz használod.

Flashból való olvasás módszertana

A PROGMEM használatával eltárolt dallamokat többféleképpen is előhívhatod az Arduino kódodban, különösen akkor, ha különböző környezetekhez és processzorokhoz igazítod a kódot. Az alábbi példák megmutatják a lehetőségeket:

anyrtttl::nonblocking::beginProgMem()

Ez a módszer akkor hasznos, ha a dallamokat a Flash memóriában tároltad a PROGMEM makróval, és a lejátszáshoz közvetlenül a Flash-ből szeretnéd előhívni őket. Az anyrtttl::nonblocking::beginProgMem() függvény használata optimalizált olvasást biztosít a Flash memóriából.

anyrtttl::nonblocking::beginProgMem(BUZZER_PIN, tetris);

1	anyrtttl::nonblocking::beginProgMem(BUZZER_PIN, tetris);

anyrtttl::nonblocking::begin_P()

Ez a módszer szintén a PROGMEM memóriaterületet használja, de különösen akkor hasznos, ha az AVR architektúrához igazítod a kódot. Ez az eljárás biztonságos és közvetlen módja a Flash memória adatok kezelésének az Arduino platformon.

anyrtttl::nonblocking::begin_P(BUZZER_PIN, arkanoid);

1	anyrtttl::nonblocking::begin_P(BUZZER_PIN, arkanoid);

anyrtttl::nonblocking::begin() + FPSTR()

Ez a módszer az ESP8266 platformon használatos, és lehetővé teszi a Flash-ben tárolt karakterláncok egyszerű előhívását. Az FPSTR() makróval a program memóriában tárolt karakterláncot kezelheted, miközben a begin() függvény biztosítja a lejátszást.

anyrtttl::nonblocking::begin(BUZZER_PIN, FPSTR(mario));

1	anyrtttl::nonblocking::begin(BUZZER_PIN, FPSTR(mario));

anyrtttl::nonblocking::begin() + F() makró

Az F() makró használata közvetlenül beágyazott karakterláncokat tárol a Flash memóriában anélkül, hogy SRAM-ot használna. Ezt a módszert használhatod, ha nem külön változókban, hanem inline szeretnéd a zenét definiálni.

anyrtttl::nonblocking::begin(BUZZER_PIN, F("Bond:d=4,o=5,b=80:32p,16c#6,32d#6,..."));

1	anyrtttl::nonblocking::begin(BUZZER_PIN, F("Bond:d=4,o=5,b=80:32p,16c#6,32d#6,..."));

Összegzés

A PROGMEM segítségével eltárolt dallamok többféleképpen hívhatók elő, attól függően, hogy milyen platformot használsz (pl. AVR vagy ESP8266) és hogyan szeretnéd elérni az adatokat. Az alábbi táblázatban foglaltam össze a módszereket:

Módszer	Alkalmazás	Platform
`beginProgMem()`	Flash memória RTTTL olvasás	AVR
`begin_P()`	Flash memória kezelés	AVR
`begin()` + `FPSTR()`	Flash-ből olvasás makróval	ESP8266
`begin()` + `F()`	Inline string tárolás Flash-ben	Minden

Mindezek a módszerek segítenek abban, hogy a zenei projektjeid hatékonyabbak és memóriabarátabbak legyenek, miközben a Flash memória használatával nagyobb mennyiségű adatot tárolhatsz anélkül, hogy az SRAM-ot túlterhelnéd.

RTTTL alapok – összegzés

Az RTTTL nyelv segítségével könnyedén zenei visszajelzéseket adhatsz Arduino projektjeidhez, ezzel emelve azok funkcionalitását és felhasználói élményét. A cikk bemutatta az alapvető kódstruktúrákat, a kód feltöltésének lépéseit és gyakorlati tippeket adott az első projektedhez. Ha megtanulod helyesen alkalmazni az RTTTL-t és finomhangolni a dallamokat, egyedi és sokoldalú zenei visszajelzést hozhatsz létre.

Ne maradj le a következő cikkről, amelyben a gyakorlati alkalmazások kerülnek fókuszba: részletes bemutatást ad a komplex zenei effektek és interaktív vezérlési lehetőségek megvalósításáról Arduino projektekhez. →RTTTL – Arduino zenelejátszó III.

Felhasznált források

– RTTTL Ringtones for TUNE Command [PICAXE]
– AnyRtttl [GitHub]
– Melody Player [GitHub]
– NonBlockingRTTTL [GitHub]
– PlayRtttl [GitHub]
– Rtttl [GitHub]
– Ring Tone Text Transfer Language [Wikipedia]