[062] Piszczące Arduino

Drugą pod względem popularności drogą przekazywania informacji człowiekowi przez komputery są dźwięki. Mogą być to tylko proste piski oznaczające jakieś istotne stany, w których maszyna się znalazła, ale obecnie spotyka się jak najbardziej ludzkie odgłosy, bowiem cyfrowe przetwarzanie dźwięku stało się ogólnie dostępne i tanie. Tym jednak zajmiemy się później, na początek – najprościej, więc opowiem teraz o metodach generacji odgłosów, które można sobie zaimplementować we własnych rozwiązaniach. Na wstępie pytanie: czym piszczeć? Piszczadeł jest wiele, zróbmy sobie krótki przegląd.

Popularnym urządzeniem jest tak zwany buzzer aktywny, czyli zwykle taki walec, który piszczy, gdy podłączyć do niego napięcie. Zaleta jest oczywista: jest napięcie – jest huk, nie ma – jest cisza. Poza włączeniem i wyłączeniem napięcia nie trzeba generować żadnych przebiegów ani robić cokolwiek skomplikowanego. Wady są dwie: wysokość dźwięku została wybrana przez producenta piszczka i praktycznie nie ma tutaj możliwości sterowania głośnością. W pewnym zakresie można ją regulować, dokładając w szereg rezystor, ale nie ma gwarancji, że generator będzie pracować stabilnie. W praktyce można zalepić otwór taśmą, co obniża głośność.

Podobny do buzzera aktywnego jest takiż, tyle że pasywny. Jest to zwykle piezoelektryk naklejony na blaszkę osadzoną w obudowie albo w ogóle jej pozbawiony. Najczęściej nie wytwarza zbyt dużego poziomu dźwięków jak również w ogóle nie generuje tonów niższych. Ma jednak zalety: jest tani i potrzebuje śladowe ilości energii, bo w zasadzie jest kondensatorem. Dołączenie równolegle do niego rezystora o wartości kilkuset omów zwykle zwiększa głośność takiego przetwornika.

W końcu mamy różnego rodzaju przetworniki zbudowane w idei głośników. Mają one najlepsze brzmienie i mogą zagrać głośniej. Wadą jest zwykle zbyt mały opór, by móc je bez ryzyka podłączyć wprost do wyjść Arduino. Tam w zasadzie powinno się podłączać obciążenia nie większe niż kilkudziesięciomiliamperowe. W praktyce do takiego głośnika szeregowo podpiąłem rezystor 220 omów. Poziom głośności nie jest zbyt duży, ale do zabawy wystarczy. Gdy trzeba narobić huku, jednotranzystorowy wzmacniacz powinien dać sobie radę.

Skoro już wiemy co możemy podłączyć, czas spojrzeć na Arduino i zastanowić się, co możemy otrzymać. Otóż będąc urządzeniem cyfrowym, da nam ono falę prostokątną. Kształt ten brzmi bardzo agresywnie, ale akurat w tym przypadku to dobrze, bo nie trzeba wiele mocy, by otrzymać głośne dźwięki. A te możemy generować na wiele sposobów: czysto programowo, z pomocą procedur, przerwań, timerów, a nawet generując przebiegi samplowane. Zatem czas na przykłady.

Na początek – najprościej. Użyjemy aktywnego buzzera, który jak mówiłem, piszczy zawsze, gdy jest zasilany. I znowu użyję płytki edukacyjnej TME. Mam tu bowiem taki piszczek już osadzony i podłączony do pinu drugiego. Poza tym mam tutaj także klawiaturę, którą wykorzystam do jego aktywacji.

const byte pstryczek = 5;  // Adres pstryczka włączającego piszczenie.
const byte piszczek = 2;   // Adres portu, do którego podłączony jest piszczek.

void setup() {
  pinMode(pstryczek, INPUT_PULLUP);  // Deklaruj linię pstryczka jako wejście podciągnięte wewnętrznie do wysokiego stanu.
  pinMode(piszczek, OUTPUT);         // Deklaruj linię piszczka jako wyjście.
}

void loop() {
  if (digitalRead(pstryczek) == HIGH) {  // Jeśli przycisk został wciśnięty...
    digitalWrite(piszczek, HIGH);        // Włącz piszczek.
  } else {                               // Jeśli zaś puszczony...
    digitalWrite(piszczek, LOW);         // Wyłącz piszczek.
  }
}

Szkic jest nad wyraz skromny, wręcz prymitywny, ale nie znaczy, że kompletnie nieużyteczny. Najpierw deklarujemy adres przycisku, który będzie uruchamiał brzęczenie (5) oraz adres portu, do którego dołączono buzzer (2) Deklarujemy także funkcje wspomnianych portów: klawiatura to wejście, a piszczek – wyjście.

W głównej pętli będziemy sprawdzać stan portu klawiatury. Jeśli jest wysoki – a w przypadku braku inwerterów, co będzie mieć miejsce przy pracy bezpośredniej z Arduino – niski, należy podać napięcie na buzzer. Jeśli przycisk zostanie zwolniony, należy to wyjście wyzerować. Proste, a wręcz prostackie. Ale wiedzieć o tym trzeba. Czas na coś ambitniejszego.

Użyję teraz wspomnianego małego głośniczka, który podłączę do mojej płytki, do portu jedenastego.

const byte pstryczek = 5;  // Adres pstryczka włączającego piszczenie.
const byte piszczek = 11;  // Adres portu, do którego podłączony jest piszczek.

const int wysokosc = 1000;  // Wysokość generowanego tonu.

void setup() {
  pinMode(pstryczek, INPUT_PULLUP);  // Deklaruj linię pstryczka jako wejście podciągnięte wewnętrznie do wysokiego stanu.
  pinMode(piszczek, OUTPUT);         // Deklaruj linię piszczka jako wyjście.
}

void loop() {
  while (digitalRead(pstryczek) == HIGH) {  // Dopóki pstryczek jest wciśnięty...
    digitalWrite(piszczek, HIGH);           // Ustaw wysoki stan na wyjściu głośnika.
    delayMicroseconds(wysokosc);            // Zaczekaj chwilę.
    digitalWrite(piszczek, LOW);            // Wstaw niski stan na wyjściu głośnika.
    delayMicroseconds(wysokosc);            // Zaczekaj chwilę.
  }
}

Deklaracje są identyczne, z tym, że numer portu wyjściowego zmienił się (11). Wprowadzę tutaj nową stałą: wysokosc, która będzie odpowiadać za wysokość dźwięku, bowiem teraz będziemy mogli sobie ją dobrać do własnych upodobań. Parametr ten nie ma wprost dokładnego odniesienia do skali muzycznej czy w hercach i im jest niższy, tym wyżej zapiszczy dźwięk. Ogólnie można powiedzieć, że wartość tysiąc to mniej więcej kiloherc.

W głównej pętli, stworzymy własną pętlę, która będzie się realizować podczas trzymania wciśniętego przycisku. W niej to, po stwierdzeniu, że przycisk wciąż jest wciśnięty, następuje wypchnięcie membrany wysokim stanem, chwila przerwy, zatrzymanie zasilania głośnika, czyli powrót membrany do pozycji spoczynkowej, ponownie chwila przerwy i tak w nieskończoność, aż przycisk zostanie puszczony. W praktyce usłyszymy pisk. Problem polega na tym, że w chwili gdy głośnik jęczy, nic się tutaj nie da zrobić. Zatem praktyczne zastosowanie tego rozwiązania jest rzadkie. Przypatrzmy się jednak użytecznej modyfikacji.

const byte pstryczek = 5;  // Adres pstryczka włączającego piszczenie.
const byte piszczek = 11;  // Adres portu, do którego podłączony jest piszczek.

const int wysokosc = 400;  // Wysokość generowanego tonu.
const byte dlugosc = 80;   // Długość piknięcia.

void setup() {
  pinMode(pstryczek, INPUT_PULLUP);  // Deklaruj linię pstryczka jako wejście podciągnięte wewnętrznie do wysokiego stanu.
  pinMode(piszczek, OUTPUT);         // Deklaruj linię piszczka jako wyjście.
}

void loop() {
  if (digitalRead(pstryczek) == HIGH) {        // Dopóki pstryczek jest wciśnięty...
    zapiszcz();                                // Piknij.
                                               // Reszta kodu.
    while (digitalRead(pstryczek) == HIGH) {}  // Czekaj na puszczenie przycisku.
  }
                                               // Reszta kodu.
}

void zapiszcz() {                       // Procedura piknięcia.
  for (byte x = 0; x < dlugosc; x++) {  // Pętla stanowiąca o długości trwania sygnału.
    digitalWrite(piszczek, HIGH);       // Ustaw wysoki stan na wyjściu głośnika.
    delayMicroseconds(wysokosc);        // Zaczekaj chwilę.
    digitalWrite(piszczek, LOW);        // Wstaw niski stan na wyjściu głośnika.
    delayMicroseconds(wysokosc);        // Zaczekaj chwilę.
  }
}

W tym szkicu osadziłem jeszcze jedną stałą: dlugosc. Proces pikania jest podobny, ale oddelegowany do osobnego podprogramu i wykonuje się przez chwilę wyznaczoną wspomnianą długością. Co prawda wtedy także mamy blokadę całości, lecz z natury takie rozwiązania służą generowaniu króciutkich piknięć potwierdzających na przykład wciskanie klawiszy. I tak właśnie tutaj jest, po wciśnięciu przycisku program zapika krótko i wróci do pętli, w której można osadzić jakieś pożyteczne czynności. Tak na marginesie, taki mechanizm był wbudowany w ZX Spectrum – tam pikania potwierdzały działanie kiepskiej klawiatury, a podczas emisji dźwięków w BASIC-u nie można było robić niczego innego.

W kolejnym artykule odciążymy komputerek od zajmowania się piszczeniem non stop i zaczniemy wygrywać melodyjki.