[160] Arduino Q cz. 7
Na płytce Arduino Q znajdziemy 104 diody świecące, ułożone w matrycę 13x8. Rzecz taka pojawiła się już w Uno R4, a tutaj przybyła dodatkowa kolumna. Do czego można użyć takiego wyświetlacza? Do wielu rzeczy. Zacznijmy od prezentacji liczb. Układ dla takich zastosowań nie jest najszczęśliwszy, minimalna matryca dla cyfry do 4x5 diod, czyli mając ich 104, można byłoby przedstawić cztery znaki. W naszym przypadku wstawimy trzy na matrycy 4x6, nieco czytelniejszej i zostanie jeszcze miejsce na przecinek lub apostrof. Albo na diody stanu. Przypomnę, że jedna kolumna w matrycy musi się zmarnować na odstęp.
Jak się to realizuje programowo? Trochę naokoło.
#include <Arduino_LED_Matrix.h> // Biblioteka rysująca tablice na wyświetlaczu.
Arduino_LED_Matrix display; // Deklaruj nazwę tablicy.
byte picture[104] = { // Tablica zapalonych diod.
1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1,
0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1,
0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0,
0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0,
1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0
};
void setup() {
display.begin(); // Inicjuj tablicę.
display.setGrayscaleBits(1); // Ustaw dwustanową jasność.
display.draw(picture); // Przenieś zawartość tablicy na wyświetlacz.
}
void loop() {}Zacznijmy od zaprojektowania całej grafiki, tj. ustawienia wszystkich diod. W tym celu należy sięgnąć do biblioteki Arduino_LED_Matrix.h, która skraca działania, ograniczając naszą potrzebę wywoływania adresu każdej diody. Są one podłączone do kolejnej grupy pinów kontrolera, nie będącej dostępną na wyprowadzeniach płytki.
Następnie trzeba zdefiniować nazwę obiektu display, czyli naszego wyświetlacza i zbudować tablicę picture, w której jedynki to zapalone diody, a zera – zgaszone. Można to zrobić ręcznie, nie jest to trudne, bo wszystko widać wprost. Można też skorzystać z edytorów, między innymi oficjalnego, który wygeneruje tablicę po wyklikaniu obrazka.
Następnie inicjujemy procedurę, ustawiamy tryb graficzny – bo mamy dwa, ale o tym zaraz i wywołujemy przepisanie tablicy na wyświetlacz. A jak wyświetlić albo zgasić konkretny piksel? No właśnie, naokoło.
#include <Arduino_LED_Matrix.h> // Biblioteka rysująca tablice na wyświetlaczu.
Arduino_LED_Matrix display; // Deklaruj nazwę tablicy.
byte picture[104] = { // Tablica zapalonych diod.
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
void setup() {
display.begin(); // Inicjuj tablicę.
display.setGrayscaleBits(1); // Ustaw dwustanową jasność.
bitSet(picture[14], 0); // Zaświeć piksel o adresie 14.
bitSet(picture[89], 0); // Zaświeć piksel o adresie 89.
display.draw(picture); // Przenieś zawartość tablicy na wyświetlacz.
}
void loop() {}W tym celu musimy tak samo jak poprzednio, powołać do życia tablicę picture, ale z wyłączonymi wszystkimi diodami. By włączyć konkretną diodę, trzeba będzie odwołać się do jej adresu za pomocą linii bitSet(picture[numer diody], 0). Diody liczymy od zerowej, po kolei i kończymy na sto trzeciej. Powyższy szkic da nam taki efekt:
Jeśli byśmy chcieli diodę zgasić, należy użyć funkcji bitClear. Tak na marginesie, na oficjalnej ściądze jest błąd: diody liczy się od jedynki, a nie od zera.
Wykorzystanie tego sposobu pozwala stworzyć matrycę kontrolek. Jeśli zdecydujemy się na kwadraty o wymiarach 3x3 piksele, dostaniemy ich sześć. Ten szkic aktywuje miganie kontrolki pierwszej i piątej.
#include <Arduino_LED_Matrix.h> // Biblioteka rysująca tablice na wyświetlaczu.
Arduino_LED_Matrix display; // Deklaruj nazwę tablicy.
byte picture[104] = { // Tablica zapalonych diod.
0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
void setup() {
display.begin(); // Inicjuj tablicę.
display.setGrayscaleBits(1); // Ustaw dwustanową jasność.
}
void loop() {
bitSet(picture[15], 0); // Zaświeć piksel o adresie 15
bitSet(picture[71], 0); // Zaświeć piksel o adresie 71.
display.draw(picture); // Przenieś zawartość tablicy na wyświetlacz.
delay(250);
bitClear(picture[15], 0); // Zaświeć piksel o adresie 15.
bitClear(picture[71], 0); // Zaświeć piksel o adresie 71.
display.draw(picture); // Przenieś zawartość tablicy na wyświetlacz.
delay(250);
}Mniej czytelna podstawa 2x2 da nam 12 kontrolek i w tym wypadku aktywna jest pierwsza, szósta i dwunasta. Kolejne inwencje pozostawiam czytelnikom.
Na koniec przedstawię jeszcze jedną możliwość wyświetlacza: zmianę jasności świecenia diod. Tutaj właśnie wrócę do tajemniczego setGrayscaleBits – parametru, który może przyjmować kilka różnych wartości, z czego sensowne są dwie: jedynka i trójka. Stanowią one o głębokości bitowej jasności. Jedynka oznaczała diodę włączoną lub wyłączoną, trójka umożliwia użycie siedmiu stopni jasności. Jasność tę koduje się w tablicy, osadzając teraz liczby od zera do siedmiu.
#include <Arduino_LED_Matrix.h> // Biblioteka rysująca tablice na wyświetlaczu.
Arduino_LED_Matrix display; // Deklaruj nazwę tablicy.
byte picture[104] = { // Tablica zapalonych diod.
0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0,
0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0,
0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0,
0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0,
0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0,
0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0,
0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0,
0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0
};
void setup() {
display.begin(); // Inicjuj tablicę.
display.setGrayscaleBits(3); // Ustaw trzybitową jasność.
display.draw(picture); // Przenieś zawartość tablicy na wyświetlacz.
}
void loop() {}Zakodowałem w ten sposób taką grafikę. Żeby utrzymać symetrię, musiałem zrezygnować z najjaśniejszej wartości. Wygląda to bardzo fajnie.
Sterowanie pojedynczymi pikselami także jest możliwe, ale mamy tu kolejny błąd i jasność tych pikseli może być ustawiana tylko w trzech krokach – od zera do dwójki.
#include <Arduino_LED_Matrix.h> // Biblioteka rysująca tablice na wyświetlaczu.
Arduino_LED_Matrix display; // Deklaruj nazwę tablicy.
byte picture[104] = { // Tablica zapalonych diod.
0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0,
0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0,
0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0,
0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0,
0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0,
0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0,
0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0,
0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0
};
void setup() {
display.begin(); // Inicjuj tablicę.
display.setGrayscaleBits(3); // Ustaw trzybitową jasność.
bitSet(picture[0], 0); // Zapal piksele w rogach, ze zmieniającą się jasnością.
bitSet(picture[12], 1);
bitSet(picture[91], 2);
display.draw(picture); // Przenieś zawartość tablicy na wyświetlacz.
}
void loop() {}Należy pamiętać, że zgaszenie tych pikseli będzie możliwe tylko wtedy, jeśli zadeklarujemy im tę samą jasność, w przeciwnym razie czynność będzie zignorowana.
Mimo tego postanowiłem zakończyć dzisiejszą opowieść napisaniem miłego wygaszacza, który korzysta z możliwości indywidualnego zapalania pikseli ze zróżnicowanym poziomem.
#include <Arduino_LED_Matrix.h> // Biblioteka rysująca tablice na wyświetlaczu.
Arduino_LED_Matrix display; // Deklaruj nazwę tablicy.
byte picture[104] = { // Tablica zapalonych diod.
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
void setup() {
display.begin(); // Inicjuj tablicę.
display.setGrayscaleBits(3); // Ustaw trzybitową jasność.
display.draw(picture); // Przenieś zawartość tablicy na wyświetlacz.
}
void loop() {
bitSet(picture[random(104)], 0);
bitSet(picture[random(104)], 1);
bitSet(picture[random(104)], 2);
bitClear(picture[random(104)], 0);
bitClear(picture[random(104)], 1);
bitClear(picture[random(104)], 2);
bitClear(picture[random(104)], 0);
bitClear(picture[random(104)], 1);
bitClear(picture[random(104)], 2);
bitClear(picture[random(104)], 0);
bitClear(picture[random(104)], 1);
bitClear(picture[random(104)], 2);
display.draw(picture);
delay(10);
}W pierwszej kolejności zapalamy trzy piksele na losowych pozycjach, a każdy z inną jasnością. Następnie gasimy również losowe piksele z każdą z trzech jasności, ale tych gaszeń wprowadziłem trzykrotnie więcej. Dzięki temu wyświetlacz nie jest „przegadany” świecącymi się diodami i efekt – mimo prymitywizmu algorytmu – wygląda świetnie, przywołując pulpity różnych maszyn starych filmów science fiction, na których bez sensu najczęściej mrugały sobie światełka.
W sieci znajdziemy biblioteki wyświetlające napisy na tym prostym wyświetlaczu, łącznie z ich przewijaniem oraz konwertery animacji i filmów. Tych ostatnich raczej nie pooglądamy sobie, ale animacje mogą wyglądać ciekawie.
Inne artykuły z tej kategorii
Nasi partnerzy
