DIY: Ręczny wyświetlacz widmowy na ATmega88

Autor: Aldaris
Redakcja: Dondu


Na wstępie odpowiedzmy sobie na pytanie czym właściwie jest wyświetlacz widmowy?

Jak sama nazwa wskazuje, wyświetlany obraz stanowi widmo, czyli wykorzystujemy bezwładność oka ludzkiego i oszukujemy własny wzrok. Dzięki temu możemy użyć jednowymiarowej linii złożonej np. z diod LED, którą odpowiednio szybko poruszając oszukamy własne oczy i stworzymy wrażenie dwuwymiarowej płaszczyzny obrazu!

... wyświetlacz wygląda tak:

... i działa następująco:

---

Zasada działania

Schemat blokowy wyświetlacza widmowego

Układ zasilany jest z akumulatora 3,6 V, litowo-jonowego o pojemności 2200mA. Zabezpieczenie stanowi dioda Schottky'ego, na której spadek napięcia wynosi około 200 mV, zatem diody RGB wraz z sterującymi je driverami SCT2024 zasilane są napięciem 3,4 V. Pozostała cześć układu, czyli serce urządzenia - ATmega88 oraz akcelerometr ADXL344 zasila stabilizator 3 V. Pobór prądu w skrajnym przypadku, czyli przy świeceniu każdego koloru wszystkich diod wynosi 950 mA, zatem minimalny czas pracy (przy ciągłym świeceniu) urządzenia zasilanego z akumulatora wynosi 2 godziny 20 minut.

Sterowniki diod LED RGB stanowi sześć 16-bitowych, szeregowo-równoległych rejestrów, które są ze sobą połączone w sposób  szeregowy (wyjście->wejście), tworząc 96-bitowy rejestr (32 diody RGB dają w sumie 96 diod). Dane do sterownika przesyłane są z wykorzystaniem magistrali SPI.

Za jasność świecenia diod odpowiada tranzystor MOSFET z kanałem P, który kluczowany jest sygnałem PWM. Magistrala I2C (TWI) wykorzystana jest do komunikacji z akcelerometrem, który przyczynia się między innymi do oszczędzania energii. Do mikrokontrolera podłączona jest także dioda sygnalizująca różne stany układu oraz przycisk, który po naciśnięciu zmienia wyświetlany obraz, lub po przytrzymaniu wyłącza urządzenie.

Dobieranie prądu wyjść SCT2024

Napięcie przewodzenia każdego z kolorów diod RGB różni się. W celu uzyskania jednolitej jasności świecenia należałoby połączyć szeregowo rezystor do każdego pojedynczego koloru. Na szczęście wyjścia układu SCT2024 działają jako źródła prądowe, a rezystor REXT umożliwia ustalenie stałego prądu dla każdego z wyjść! Pozbywamy się w ten sposób aż 96 rezystorów i uzyskujemy jednakową jasność świecenia każdego koloru.

Dokumentacja STC2024: SCT2024V01_03.pdf (kopia)

---

Schemat oraz PCB

Schemat modułu sterowania wraz z modułami RGB

Projekt schematu oraz płytki wykonany został w programie KiCad. Urządzenie zostało zaprojektowane w sposób modułowy. Powyższy schemat przedstawia część odpowiedzialną za sterowanie wraz z podłączonymi dwoma modułami RGB i w takiej konfiguracji go zbudowano.

Może pojawić się pytanie dlaczego na magistrali SPI brakuje rezystorów podciągających, skoro piny są współdzielone z interfejsem ISP. Są one zbędne, ponieważ używamy tylko linii MOSI, czyli urządzenie slave nie przesyła do mikrokontrolera żadnych danych, co mogłoby zakłócić proces programowania, a oprócz tego, wewnątrz układu znajdują się rezystory podciągające linie wejściowe do zasilania, dzięki czemu, w trakcie programowania nic nam nie miga oraz nie świeci na modułach RGB.

Schemat modułu RGB

Całość została tak zaprojektowana w ten sposób, aby można było do modułu sterującego dołączyć dowolną ilość modułów RGB. Należy przy tym pamiętać, że każdy moduł zawiera 16 diod LED RGB i co za tym idzie, wydłuża rejestr szeregowo-równoległy o 48 bitów. Płytki łączą zwory oraz gniazda AVX.

Płytki PCB

Płytki PCB zostały wykonane przez firmę (pliki ze schematem oraz mozaiką ścieżek znajdują się na końcu artykułu). Podczas projektowania korzystałem z bibliotek pobranych ze strony: KiCad - Electronic CAD libraries.

---

Program

Program napisany został w darmowym środowisku Atmel Studio. Wszystkie pliki źródłowe znajdują się w załączniku. Postaram się opisać program według części algorytmu.

Algorytm działania programu

Główna pętla programu

Po włączeniu zasilania następuje inicjalizacja urządzenia, składa się ona z kilku funkcji wewnętrznych pliku PixelPoi.c, inicjalizujących procesor oraz akcelerometr. Funkcje podzielono na mniejsze bloki, w celu uzyskania przejrzystości kodu.

void hardware_init(){
 port_init();
 cpu_init();
 SPI_init();
 TWI_init();
 ADC_init();
 wdt_init();
 ADXL344_init();
}

Biblioteka użyta do obsługi interfejsu TWI pochodzi z książki Tomasza Francuza "Język C dla mikrokontrolerów AVR"i nie będę jej opisywał.

Przetwornik analogowo-cyfrowy wykorzystywany jest do pomiaru napięcia zasilania, za diodą Schottky'ego. Pin konfigurujemy jako wejście, wyłączamy część cyfrową, używamy wewnętrznego źródła odniesienia, wynik wyrównujemy do lewej oraz preskaler ustawiamy na 16 (8 MHz / 16 = 500 kHz). Producent zaleca dokładne pomiary dla sygnału taktującego przetwornik poniżej częstotliwości 250 kHz, nam nie zależy jednak na bardzo dokładnym pomiarze i wartość odczytywać będziemy tylko z rejestru ADCH.

static inline void ADC_init(){
 DDRC &= ~_BV(PC0);    //PC0 jako wejscie
 DIDR0 |= _BV(ADC0D);  //PC0 - zablokowanie czesci cyfrowej
 ADMUX |= _BV(REFS1) | _BV(REFS0) | _BV(ADLAR);  //wew. zrodlo odniesienia,
        //wyrownanie wyniku do lewej odczytywany bedzie tylko rejestr ADCH
 ADCSRA |= _BV(ADEN) | _BV(ADPS2); //wlaczenie przetwornika, 
         //ustawienie preskalera zegara taktujacego na 16
}

Watchdog został skonfigurowany do generowania przerwań co 4sek, a funkcja resetowania procesora została wyłączona, dzięki temu uzyskaliśmy dodatkowy timer. Należy pamiętać, że ustawienie fusebitu WDTON uniemożliwi użycie Watchdoga do generowania przerwań. Należy także pamiętać, że przed zmianą rejestru WDTCSR warto wykonać reset rejestru Watchdoga, ponieważ może nastąpić jego natychmiastowe zadziałanie.

static inline void wdt_init(){
 wdt_reset(); //konfiguracja timera watchdog
 WDTCSR = _BV(WDCE) | _BV(WDE);
 WDTCSR =_BV(WDIE) | _BV(WDP3); //przerwanie watchdog co 4 sek
}

Po włączeniu zasilania akcelerometr ADXL344 znajduje się w trybie niskiego poboru mocy i należy w pierwszej kolejności zmienić tryb jego pracy. Następnie należy dokonać odpowiedniej konfiguracji. Funkcje ADXL_send_byte oraz ADXL_recive_byte zawierają wewnątrz odpowiednie instrukcje do wysłania oraz odebrania bajtu po magistrali TWI (biblioteka do obsługi TWI z książki Tomasza Francuza znajduje się w załączniku).

static inline void ADXL344_init(){
 ADXL344_send_byte(0x2D, 0x08); //POWER_CTL: tryb ciaglego pomiaru
 ADXL344_send_byte(0x31, 0x20); //DATA_FORMAT: przerwanie stanem niskim
 ADXL344_send_byte(0x2C, 0x0A); //PW_RATE: częstotliwość pomiarów 50HZ
 ADXL344_send_byte(0x3B, 0x89); //ORIENT_CONF: przerwania orient, 3D
 ADXL344_send_byte(0x2E, 0x01); //INT_ENABLE: uruchomienie przerwan orient
 ADXL344_send_byte(0x2F, 0x01); //INT_MAP: przerwanie orient na pin int2
}

Główna pętla odpowiada za sprawdzenie czy grawitacja lub siła odśrodkowa działa w osi -X akcelerometru (jeśli nie diody zostają wyłączone) i następnie wyświetla obraz, przy sprawdzeniu który powinien być obecnie rysowany. Obrazy zapisane są do pamięci flash jako dwu wymiarowa macierz w postaci ilość_linii_obrazu x 12. Dlaczego 12? Ponieważ interfejs SPI wysyła kolejno po jednym bajcie, zatem dzieląc 96 bitów (wszystkie kolory) przez 8 otrzymujemy 12 (dla dwóch połączonych ze sobą modułów).

#include "PixelPoi.h"
#include "img.h"

void RGB_line(const unsigned char matrix[][6*NO_OF_RGB_MOD], uint8_t );

int main(void)
{
 hardware_init(); //inicjalizacja urzadzenia
 
 while(1)
    {
  while(STATUS_REG & _BV(X_FLG)){ //wyswietlaj tylko, gdy grawitacja 
                             //lub sila odsrodkowa dziala na os -X
   switch(PROG_CNT){
    case 0:    
     for(uint8_t j=0; j<26; j++){
      RGB_line(&img_a, j);
      _delay_us(500);
     }
     break;
    case 1:
     for(uint8_t j=0; j<19; j++){
      RGB_line(&img_b, j);
      _delay_us(500);
     }
     break

                            //kolejne programy 
                            //case 2, 3, 4, 5... itd.     

    default:;    
   }
   
  }
  RGB_line(&img_tst, 7);//diody wylaczone poza petla
 }
}
  
void RGB_line(const unsigned char matrix[][6*NO_OF_RGB_MOD], uint8_t line){
 PORTC |= _BV(OE);
 PORTC &= ~_BV(LA);
 for(uint8_t i=0; i<(6*NO_OF_RGB_MOD); i++)
 {
  SPDR = pgm_read_byte(&matrix[line][i]);
  while(!(SPSR & _BV(SPIF)));
 }
 PORTC |= _BV(LA);
 PORTC &= ~_BV(LA);
 PORTC &= ~_BV(OE);
}//funkcja pobierajaca z pamieci flash kolejna linie do wyswietlenia
//zmiany stanow na liniach OE oraz LA sluza do wlasciwej obslugi aktywacji wyjsc
//oraz zatrzasku drivera LED -> patrz datasheet

Nie zdążyłem niestety napisać programu do generowania pliku tekstowego z macierzą obrazu, zrobię to w wolnej chwili. Wpisywanie "ręczne" wbrew pozorom nie jest trudne, ponieważ jeśli dobrze się przyjrzymy, to da się zauważyć, że sekwencja kolorów powtarza się co 3 bajty, a tworzenie symetrycznych obrazów i wzorów jest naprawdę proste! ;-)

const unsigned char PROGMEM img_tst[8][12]={
 {0b01001001, 0b00100100, 0b10010010, /*...*/ 0b00100100, 0b10010010},
    //{GRBgrbGR,  BgrbGRBg,  rbGRBgrb  /*...*/     BgrbGRBg    rbGRBgrb},
  //32 31 30     29 28      27 26   /*...*/      5  4  3      2  1
        /*...*/
};//struktura macierzy obrazu

Struktura ramki danych dla linii z 32 diod LED wygląda następująco:

Ramka danych obrazu

Barwy możliwe do wyświetlenia:

G	R	B	KOLOR
1	1	1	Biały
1	1	0	Żółty
1	0	1	Cyjan
1	0	0	Zielony
0	1	1	Magneta
0	1	0	Czerwony
0	0	1	Niebieski
0	0	0	Czarny

Mieszanie barw RGB

Przerwanie Watchdog

Przerwanie Watchdog występuję co 4 sekundy. W przerwaniu dokonujemy pomiaru napięcia zasilania i jeśli jest ono zbyt niskie usypiamy procesor. Sprawdzamy także, czy układ znajduje się w pozycji innej niż -X, jeśli tak, zamrugamy diodą sygnalizując w ten sposób, że urządzenie jest włączone, ponieważ linia diod RGB w pozycji innej niż -X jest wyłączona.

Pod makrem ADC_MIN ukryta jest wartość 0x7F, która została obliczona w następujący sposób: minimalne przyjęte napięcie akumulatora (dioda niebieskiego i zielonego koloru przestaje świecić - zbyt niskie napięcie) wynosi 3,35 V, zatem za diodą Schottky'ego wynosi ono 3,1 V, a z kolei napięcie podawane na przetwornik ADC, poprzez dzielnik rezystancyjny jest równe 0,5 V.

Przeglądając notę katalogową mikrokontrolera możemy znaleźć wzór na obliczenie wartości rejestru przetwornika: Vin * 1024 / Vref, gdzie Vin jest naszym napięciem 0,5 V, a Vref, to napięcie referencyjne, które dla tego procesora jest równe 1,1 V. Otrzymujemy w ten sposób 0x1D1. Ponieważ wynik przesuwamy w lewo (skonfigurowane to zostało w ADC_init), w rejestrze ADCH pojawia się wartość 0x74 (116) i dla bezpieczeństwa i spokoju ducha zwiększamy do 0x7F (127). ;-)

Podczas usypiania procesora należy pamiętać o wyłączeniu Watchdoga oraz uśpieniu akcelerometru, ponieważ przerwania wybudzały by mikrokontroler. Opóźnienia delay oczywiście zastosowane z prostoty i lenistwa. ;-)

uint8_t ADC_one_measurement(){
 ADCSRA |= _BV(ADSC); //uruchomienie pojedynczej konwersji
 while(ADCSRA & _BV(ADSC));//czekaj do zakonczenia konwersji
 return ADCH;
}

static inline void wdt_stop(){ //wylaczenie watchdoga
 wdt_reset(); 
 WDTCSR = 0;
}

static inline void power_down(){
 cli();
 timer1_stop(); 
 ADXL344_send_byte(0x2D, 0x00); //POWER_CTL: uspienie akcelerometru
 wdt_stop(); //wylaczenie watchdoga, aby nie wybudzal procesora
  sleep_bod_disable(); //wylaczenie ukladu BOD
 sei();
  sleep_cpu();
}

static void led_blink(){
 PORTD |= _BV(LED);
 _delay_ms(50);
 PORTD &= ~_BV(LED);
 _delay_ms(100);
 PORTD |= _BV(LED);
 _delay_ms(50);
 PORTD &= ~_BV(LED);
 _delay_ms(100);
}

ISR(WDT_vect){
 if(ADC_one_measurement() < ADC_MIN){//jezeli napiecie zasilania jest
                               //zbyt niskie uspij
  led_blink();
  sleep_cpu();
 }
 if(!(STATUS_REG & _BV(X_FLG))){//jezeli urzadzenie znajduje sie w 
                                //innym polozeniu niz -X, to zamrugaj dioda
  led_blink();
 }
}

 

Przerwanie akcelerometru

Przerwanie pochodzące od akcelerometru pojawia się w momencie zmiany jego orientacji. Ustawiając urządzenie linią diod pionowo w górę, układ ADXL344 zorientowany jest tak, jak na rysunku - grawitacja działa tylko w dodatnim kierunku osi X. Po otrzymaniu przerwania musimy dokonać odczytu najpierw z rejestru flag źródeł przerwań, a następnie z rejestru orientacji, aby mogło pojawić się kolejne przerwanie.

Podczas inicjalizacji skonfigurowano układ do pomiaru orientacji w przestrzeni XYZ. W momencie ustawienia urządzenia linią diod RGB w kierunku ziemi jak i zarówno podczas obracania nim w powietrzu (siła odśrodkowa działa na zewnątrz - w tym przypadku kierunku ujemnym osi X), diody RGB zaczynają świecić. Początkowo obraz był rysowany tylko w trakcie obracania urządzeniem, pod wpływem przeciążenia większego niż 1 g, ale okazało się to niepraktyczne, ponieważ podczas zmiany programu nic się nie wyświetlało na diodach RGB.

Pod makrodefinicją STATUS_REG ukryty jest rejestr ogólnego przeznaczenia GPIOR0 i używany jest jako rejestr statusu.

ISR(INT0_vect){ //przerwanie akcelerometru zmiany polozenia urzadzenia XYZ
 uint8_t xyz;
 xyz = ADXL344_recive_byte(0x30); //INT_SOURCE
 xyz = ADXL344_recive_byte(0x3C); //ORIENT jezeli nie odczytamy powyższych
                    //rejestrow,to nie zostanie wygenerowane kolejne przerwanie
 if((xyz & 0b00000111)==0x04){ //sprawdzenie czy grawitacja lub sila 
                                   //odsrodkowa dziala na os -X
  STATUS_REG |= _BV(X_FLG);
 }else{
  STATUS_REG &= ~_BV(X_FLG);
 }
}

ADXL334 rejestr flag przerwań oraz orientacji

Orientacja akcelerometru ADXL344

Przerwanie przycisku

Wciśnięcie przycisku wywołuje przerwanie (dla odmiany przerwanie maskowane pin change), które wykonywane jest atomowo i nie może zostać przerwane przez inne przerwanie. Dziwnie to brzmi, ale tak działa, no cóż. ;-)

W następnej kolejności timer1 jest rekonfigurowany do obsługi przycisku, a sygnał PWM wyłączony i przy tym zasilanie zostaje zdjęte z anod diod RGB. Mignięcie diodą sygnalizuje wciśnięcie klawisza i prosta eliminacja drgań styków na pętli while. Kolejna pętla to ponownie while i jest ona wykonywana do czasu trzymania wciśniętego przycisku lub do upłynięcia czasu jednej sekundy.

Po upływie jednej sekundy (przy założeniu ciągłego wciśnięcia klawisza) następuję sprawdzenie, czy procesor był uśpiony, jeśli tak, zostaje wybudzony, jeśli nie - zostaje uśpiony, poprzez przerwanie pętli instrukcją break i wykonanie lub nie warunku if znajdującego się zaraz za pętlą. Zdjęcie palca z klawisza przed upływem jednej sekundy zmienia wyświetlany obraz na kolejny, pod warunkiem, że procesor nie był uśpiony, w przeciwnym razie następuje jego uśpienie.

Na sam koniec timer1 jest ponownie konfigurowany i sygnał PWM przywrócony do sterowania jasnością świecenia.

Pojawiają się kolejne makrodefinicje zamieszczone w pliku PixelPoi.h. DUTY_PWM służy do ustalania jasności świecenia, PROG_CNT (GPIOR1) jest licznikiem aktualnie wyświetlanego obrazu, a NUMB_OF_PROG mówi o ilości użytych obrazów.

static inline void timer1_pwm_init(){
 //zmiana konfiguracji timera1 na rzecz pwm
 TCCR1B = 0;
 OCR1A = (100-DUTY_PWM) * 2.5;  
 //tryb 8-bitowy, zatem regulacja liczbami 0-255, gdzie 0 -> 100%, 255 -> 0%
 TCCR1B = _BV(WGM12) | _BV(CS11); 
 //wybor trybu pwm 8-bitowego oraz taktowanie timera1 sygnalem fcpu / 8
 TCCR1A = _BV(COM1A1) | _BV(WGM10);

}

static inline void timer1_sw_init(){
 //zmiana konfiguracji timera1 na rzecz przycisku
 TCCR1B = 0;
 TCCR1A = 0;
 TCNT1 = 0;
 TCCR1B =  _BV(CS12) | _BV(CS10); //taktowanie timera1 sygnalem fcpu / 1024
 PORTB |= _BV(PWM); //wylaczenie klucza tranzystorowego
}

ISR(PCINT2_vect){
 ATOMIC_BLOCK(ATOMIC_FORCEON){//wykonanie bloku w sposob atomowy
  timer1_sw_init();//rekonfiguracja timera1 do obslugi przycisku    
  
  PORTD |= _BV(LED); 
  while(TCNT1 < 200){//eliminacja drgan stykow (okolo 25ms)
   asm("nop");
  }
  PORTD &= ~_BV(LED);
 
  while((!(PIND & _BV(SW)))){//jesli przycisk jest wcisniety
   if(TCNT1>8000)
   {//jesli przycisk jest wcisniety dluzej niz sekunde
    if(STATUS_REG & _BV(SLEEP_FLG)){
    //jesli procesor byl uspiony
     STATUS_REG &= ~_BV(SLEEP_FLG); 
    //ustwaienie flagi po przerwaniu petli nastapi obudzenie
     wdt_init(); //uruchomienie watchdoga
     ADXL344_send_byte(0x2D, 0x08); 
    //rejestr: POWER_CTL: tryb ciaglego pomiaru
     led_blink();
     break;     
    }else{//jesli procesor pracowal normalnie
     STATUS_REG |= _BV(SLEEP_FLG); 
    //po przerwaniu petli nastapi uspienie
     led_blink();
     break;     
    }
    PORTD ^= _BV(LED);
   }
  }
  //cnt = TCNT1;
  
  if(STATUS_REG & _BV(SLEEP_FLG)){
   //usypia procesor, gdy flaga uspienia jest ustawiona
   power_down();
  }
  
  if(TCNT1>500){//inkrementuje licznik wyswietlanego programu
   if(PROG_CNT < NUMB_OF_PROG){
    PROG_CNT++;
    }else{
    PROG_CNT = 0;
   }
   
  }
  timer1_pwm_init(); //włączenie PWM na anodach diod RGB
 }
}

Do pobrania

Spakowane pliki .rar z projektem urządzenia: Projekt-KICad.rar (kopia)
oraz kodem źródłowym: Source.rar (kopia)

Podsumowanie

Niestety zdjęcia robione trybem automatycznym w aparacie nie odzwierciedlają kolorów. Filmy również nie odzwierciedlają kolorów wyświetlanych przez urządzenie, a kamerę nie sposób tak łatwo oszukać jak ludzkie oko.

Zdjęcie znajdujące się na początku artykułu oraz poniższe oddają w pewnym stopniu żywe kolory, ale konsekwencją tego jest rozmycie. Zastosowane diody RGB są bardzo jasne i podczas robienia zdjęć i filmów współczynnik wypełnienia sygnału PWM ustawiony był tylko na 10%! (przy 100% trudno patrzeć na urządzenie).

Możliwości zmian

W pętli głównej programu można zauważyć po każdym wyświetleniu linii opóźnienie 500 μs. Zostało ono dobrane doświadczalnie w celu prawidłowego wyświetlania obrazu (interfejs SPI jest bardzo szybki i bez opóźnienia nie było możliwości prawidłowego wyświetlania).

Program można także zrealizować tylko za pomocą przerwań, a pętle główną zoptymalizować i umieścić w przerwaniu timera. Jeżeli chcemy wyświetlać statyczne grafiki, potrzebna jest nam synchronizacja. Można przykładowo badać dwa punkty: moment kiedy urządzenie skierowane jest pionowo w górę - siła grawitacji odejmie się od siły odśrodkowej oraz moment, w którym urządzenie skierowane jest pionowo w dół - siła grawitacji doda się do siły odśrodkowej; czyli badając minima i maksima siły działającej na oś X podczas obrotu.

Można także pokusić się o dodanie więcej opcji do przycisku, przykładowo może to być zmiana jasności świecenia czy oprócz inkrementacji licznika aktualnie wyświetlanego obrazu także jego dekrementacja (przydatne przy dużej liczbie programów).

---

Orientacyjne ceny elementów (za jedną sztukę):

• Mikrokontroler Atmega88PA - 5zł
• Akcelerometr ADXL344 - 10zł
• Driver LED SCT2024 - 1,50zł
• Dioda LED RGB WW-FCE50TC-C - 1zł
• Gniazdo akumulatora KEYS1042 - 6,50zł
• Akumulator ICR18650-22F - 20zł
• Dla leniwych - wykonanie PCB około 55zł

Zdjęcia:

---

Dziękuję za oddany głos i zachęcam wszystkich do zbudowania własnego wyświetlacza widmowego! Niestety nie udało mi się wszystkich pomysłów zrealizować i przy tym zmieścić się w ramach czasowych.

Program oraz pliki KiCada można traktować jako pewną ideę, ale życzę każdemu zaprojektowania i zaprogramowania tego lepiej niż ja! ;-) Osobiście zamierzam rozwijać w dalszym ciągu swój projekt, wzbogacając go przede wszystkim o obwody ładowania akumulatora czy komunikację USB.

Wszelkie sugestie oraz rady mile widziane. Jeśli ktoś zbuduje własną wersję, będzie mi bardzo miło, jeśli się nią pochwali. ;-)

Pozdrawiam serdecznie i życzę wesołych świąt Bożego Narodzenia oraz szczęśliwego Nowego Roku!

Wojtek

---

Uwagi redakcji

Właściwie nie mamy większych uwag do tego artykułu jak i całego projektu, stąd też nasza ocena była prawie maksymalna. Zastosowane rozwiązanie z wymiennym akumulatorem ma swoje zalety. Inną wersją mogłaby być dedykowana przetwornica do LiIon z ładowarką np. na USB, byłoby być może wygodniej i można by trochę bardziej wydrenować akumulator. Ale to tylko pomysł do przedyskutowania :-)