ModelAXE

@BeeKeyPro Nigdy bym się nie spodziewał, że moje "prymitywne" eksperymenty z elektroniką mogą kogoś zainspirować

Moja taśma to było https://www.leroymerlin.pl/produkty/oswietlenie/tasmy-led-profile-zasilacze/tasmy-led/tasma-led-ip20-460-lm-m-5-m-barwa-neutralna-polux-45797752.html ale nie wiem, czy ta Twoja to jest to samo. Zasilacz to miałem jakiś nie pamiętam skąd 12V. Generalnie to mi po prostu pasowało napięcie taśmy do zasilacza i świeciło też zgodnie z oczekiwaniem.

@ethanak Drukarka żywiczna ANYCUBIC https://botland.com.pl/produkty-wycofane/21282-photon-mono-x-6k-6974662350022.html Standardowa szara żywica, wydruk "na płasko" zajmuje niecałe 15 minut. Próbowałem też wersje białe i czarne, ale najlepiej wychodzi na szaro. Same wydruki są maksymalnie ile drukarka pozwala (195mmx90mm), ale niestety jak na początku są proste to z czasem się "wyginają". Konieczne jest prostowanie przynajmniej przez jeden dzień i porządne przyklejenie do obudowy. Do generowania modelu używałem https://3dp.rocks/lithophane/ (koniecznie w trybie "Positive Image" ponieważ najpierw zrobiłem negatyw).

@BeeKeyPro Obudowę zrobiłem z kawałka płyty meblowej, takiej jak są zazwyczaj z tyłu szaf/szafek. Akurat miałem taką starą płytę pod ręką, a do tego łatwo się ją przecina zwykłym brzeszczotem. Ponieważ płyta jest "drewniana", więc sklejałem ją najtańszym klejem typu "wikol". Zasilanie natomiast to taki zwykły zasilacz 12V (te paski LED są właśnie na 12V, więc idealnie mi pasowało). Kolejne zrobiłem już z wygodniejszym rezystorem oraz z gniazdkiem na zasilanie, aby nie obcinać wtyczki tak jak w pierwszej lampce (tej drewnianej). Te kolejne lampki mają też plastikowe obudowy, a w środku paski LED są przyklejone na metalowej płytce aby lepiej rozpraszać ciepło. Zdążyłem już zrobić w sumie 5 takich lampek.

Zrobiłem na szybko eksperyment z drukarką 3D i wyszła mi lampka nocna. Wszystko zaczęło się od wydruku litofan'u, takiego jak poniżej: Dorobiłem do tego na szybko świecącą płytkę z pasków LED: Oraz mocno toporne pudełko z płyty meblowej (dodałem nawet przełącznik i potencjometr): Koniec końców wyszła mi pierwsza w życiu lampka nocna: Dałem z siebie całe 47%, ale i tak jestem bardzo dumny. Mam już od żony i córki zamówienia na dwie kolejne lampki

Jest mało miejsca, więc zasilanie jest minimalnie prosto jak tylko na razie umiałem. Dwie bateryjki pastylki (np CR2450), przetwornica i kondensator dla zasady. Do większych modeli planuję zasilanie z ogniwa LiPo 3,7V ponieważ jest więcej miejsca i mi wyszło, że będzie akurat idealne bez żadnych przetwornic. A do mniejszych modeli zastanawiam się nad jedną baterią pastylką 3V, ponieważ mogę zasilać każdą diodę osobno (bez łączenia) i też powinno być OK.

TESTUJEMY - W odpowiedzi na komentarze @_LM_ zrobiłem kilka testów weryfikujących poprawność usypiania mikrokontrolera Według specyfikacji producenta ATtiny25 w trybie "Power Down" z włączonym WDT powinno mieć zużycie prądu lekko ponad 6uA dla zasilania 5V. To jest jednak wartość 10x mniejsza niż to co mi wyszło w moim testowym układzie i programie, więc trzeba było to koniecznie sprawdzić. Na początek sprawdziłem napięcia zasilania jakie dają mi baterie oraz jakie daje przetwornica Step-Up/Step-Down, której w tym projekcie używam. Tutaj wszystko jest jak najbardziej w normie (zasilanie to 6,34V, przetwornica 5,16V). Dodatkowa kontrola specyfikacji samej przetwornicy oraz szybki pomiar zużycia prądu od razu wyjaśnia cała zagadkę. Sama przetwornica nawet bez żadnego obciążenia po prostu do swojej pracy zużywa 53uA Teraz wiedząc o tym i mierząc zużycie prądu już na samym mikrokontrolerze wychodzi 7uA z regularnymi skokami do 8uA (budzenie co 500ms). Tak więc teraz wszystko się zgadza: przetwornica 53uA + mikrokontroler 7uA-8uA +/- jakość miernika = poprzedni wynik pomiarów 58uA-60uA Aby się upewnić jeszcze bardziej minimalnie zmieniłem do testów mój program dla ATtiny i ustawiłem budzenie na WDTO_4S (czyli usypianie na 4s). Teraz wyraźnie widać, że podczas "spania" mikrokontroler zużywa 7uA i raz na 4 sekundy miernik daje radę zarejestrować 8uA-9uA (nie zawsze jednak). Z czystej ciekawości sprawdziłem jeszcze jak to wygląda dla zasilania z dedykowanego modułu dla płytek stykowych. Moduł, który posiadam umożliwia ustawienie zasilania 5V oraz 3,3V i jak zrobiłem pomiary to wartości są niemal idealne (4,98V oraz 3,32V). Zrobiłem więc pomiary zużycia prądu przez mikrokontroler i wyniki są takie same jak poprzednio (7uA-8uA oraz 5uA-6uA). Wyniki są minimalnie wyższe niż podaje producent, ale to już muszę "zwalić" na jakość mojego miernika (jest on prawie najtańszy z możliwych). Jako ciekawostkę dodam jeszcze tylko, iż miałem pod ręką regulator 5V LM2931-N (wersja LDO), ale z nim nie udało mi się dogadać. Nie dość, że napięcie wychodziło mi 5,81V to jeszcze sam regulator zużywał prądu na 0,23mA. Teraz to już chyba naprawdę wszystko co udało mi się w tym temacie zdziałać. Mam nadzieję, że te moje testy komukolwiek się na cokolwiek przydadzą

BOD jest domyślnie wyłączony i takie są też domyślne ustawienia dla ATtiny25. @_LM_ według Ciebie te 58uA-60uA to jednak ciągle dużo i powinienem pokombinować bardziej aby jeszcze więcej oszczędzić?

USYPIAMY - czyli wyłączamy cały mikrokontroler kiedy program nie ma nic do robienia Jak pisałem wcześniej w moim przypadku program głównie czeka używając funkcji "delay()" i tylko czasami włącza lub wyłącza diody. Jakiś inny program może zyskać mniej oszczędności na usypianiu, ale w moim przypadku spodziewam się znaczących oszczędności. Usypianie to jest jednak tylko połowa zagadnienia, ponieważ ważniejsze jest w jaki sposób mikrokontroler ma się "obudzić". Tutaj właśnie przydatny będzie wspomniany wcześniej moduł WDT (Watch Dog Timer), który działa również w czasie kiedy sam mikrokontroler jest uśpiony. Ten moduł odpowiednio ustawiony może wygenerować tak zwane przerwanie, które obudzi nasze ATtiny po zadanym wcześniej czasie. Na początek w programie trzeba zdefiniować dołączanie dwóch kolejnych gotowych bibliotek (w sumie będą to już trzy biblioteki). // Dla oszczędności zużycia prądu kilka przydatnych operacji #include <avr/power.h> // Będziemy wyłączać część modułów #include <avr/sleep.h> // Będziemy usypiać cały kontroler #include <avr/wdt.h> // Będziemy korzystać z WDT (Watchdog Timer) Moduł WDT realizuje budzenie mikrokontrolera poprzez wywołanie przerwania, do którego możemy napisać naszą własną procedurę. Kod programu działający w momencie obudzenia mikrokontrolera i zadziałania przerwania powinien być jak najkrótszy i robić tylko niezbędne rzeczy. W przypadku mojego programu właściwie to nic nie potrzeba robić, jednak aby pokazać jak to działa można w przerwaniu zrobić taki pewien drobiazg. Samego WDT chcemy używać tylko do "obudzenia" naszego mikrokontrolera, a poza tym nie jest nam potrzebny i ma on być wyłączony. Najprościej więc będzie zrobić tak, że w obsłudze przerwania WDT wyłączymy ten moduł skoro właśnie nas obudził i nie jest już potrzebny. // Ustawiamy osbługę przerwania dla WDT - używane przez własną funkcję delaySleepWDT() ISR(WDT_vect) { // Wyłączamy WDT skoro właśnie nas obudził wdt_disable(); } Kolejnym krokiem jest przygotowanie procedury, która będzie usypiała nasz mikrokontroler i będzie używana w głównym programie zamiast "delay()". Procedura ta wykonuje to zadanie w kilku prostych krokach. Ustawiamy parametry usypiania w naszym przypadku "najgłębsze" wyłączenie "SLEEP_MODE_PWR_DOWN" oraz aktywujemy obsługę usypiania. Dla formalności warto wiedzieć, że są też dostępne inne tryby usypiania, ale nas interesuje ten najbardziej oszczędny jeśli chodzi o zużycie prądu. Ustawiamy czas po jakim ma zadziałać budzenie poprzez WDT i co ważne ustawiamy aby to budzenie było wywołaniem przerwania właśnie. Tutaj istotna jest informacja, że moduł WDT ma konkretną i ograniczoną listę czasów po jakich może budzić mikrokontroler. Niestety nie możemy sobie podać dowolnej wartości w milisekundach jak w przypadku poprzedniej funkcji np. "delay(2137)". Dopuszczalne wartości są następujące i mają dość jednoznaczne nazwy: WDTO_15MS WDTO_30MS WDTO_60MS WDTO_120MS WDTO_250MS WDTO_500MS (tej wartości używa mój program) WDTO_1S WDTO_2S WDTO_4S WDTO_8S Po konfiguracji usypiania oraz budzenia następuje wywołanie faktycznego uśpienia mikrokontrolera procedurą "sleep_mode()". Następnie "czekamy" a właściwe to "śpimy" i na koniec jak już się obudzimy to wyłączamy obsługę usypiania. Całość naszej nowej procedury wygląda więc następująco. // Własna funkcja "delay()", która wykorzystuje usypianie kontrolera i budzenie przez WDT. void delaySleepWDT() { // Konfigurujemy domyślne parametry usypiania kontrolera set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_enable(); // Konfigurujemy domyślne parametry wybudzenia przez WDT wdt_enable(WDTO_500MS); // Ustawiamy czas wybudzenia WDTCR |= (1<<WDIE); // Ustawiamy, że wybudzanie to będzie przerwanie (a nie reset) // Usypiamy kontroler zgodnie z ustawionymi parametrami sleep_mode(); // Teraz właśnie czekamy aż obudzi nas przerwanie WDT // Właśnie się obudziliśmy, więc wyłączamy usypianie (sam WDT jest już wyłączony przez fukcję obsługi przerwania) sleep_disable(); } Mając to wszystko gotowe możemy w naszym głównym programie zamienić wszystkie wywołania procedury "delay()" na nasza nową "delaySleepWDT()". // delay(500); delaySleepWDT(); Teraz możemy też w procedurze "setup()" wyłączyć wszystkie moduły mikrokontrolera skoro z żadnego z nich nie korzystamy. // Początkowa konfiguracja platformy Adruino oraz zmiennych całego programu void setup() { // Wyłączamy AC (Analog Comparator) ustawiając odpowiedni bit na 1 // #1 - ręcznie ustawiamy odpowiednie bit'y dla odpowiednich rejestrów ACSR |= (uint8_t)(1<<ACD); // Wyłączamy ADC (Analog to Digital Converter) ustawiając odpowiedni bit na 0 // #1 - ręcznie ustawiamy odpowiednie bit'y dla odpowiednich rejestrów ADCSRA &= (uint8_t)~(1<<ADEN); // Wyłączamy nie używane moduły ustawiając odpowiednie bity na 1 // #3 - zbiorcze wywołanie z biblioteki dla wszystkich modułów power_all_disable(); // Disable all modules. // Wyłączamy WDT (Watchdog Timer) ustawiając odpowiednie bity na 0 i 1 // #2 - wywołanie z biblioteki wdt_disable(); // Wyłączamy nie używany PIN pinMode(PIN_Disabled, INPUT_PULLUP); } I to by było na tyle jeśli chodzi o usypianie ATtiny w celu maksymalnej oszczędności zużycia prądu. Wypadało by jednak sprawdzić jaki udało się uzyskać efekt, a okazuje się że oszczędność jest ogromna. W moim przypadku mikrokontroler zużywa tylko 58uA-60uA, czyli 28 razy mniej prądu niż w konfiguracji domyślnej z użyciem procedury "delay()". Teraz kiedy sam mikrokontroler zużywa prąd w minimalny sposób można będzie przejść do oszczędzania prądu w innym miejscu (np. na diodach). Dla zainteresowanych umieszczam też mój program, może się komuś przyda do eksperymentów HONDA-CBR1100XX-V4a.zip Wszystkim czytającym, którzy dotrwali do tego miejsca dziękuję za uwagę.

Ten artykuł jest krótką relacją z moich doświadczeń odnośnie oszczędzania zużycia prądu w mikrokontrolerach ATtiny. Zająć się tym tematem zostałem niejako zmuszony z powodu zbyt krótkiego działania oświetlania, które robiłem do dwóch innych projektów. Oświetlenie do modelu HONDA CBR1100XX SUPER BLACKBIRD oraz Oświetlenie do modelu KAWASAKI NINJA H2 CARBON BAZA - czyli testy zacząłem do wykonania wzorcowej konfiguracji, na której mogłem sprawdzać zużycie prądu całego układu oraz samego mikrokontrolera. W tej konfiguracji używam fabrycznie nowego mikrokontrolera ATtiny25, do którego wgrałem mój program w podstawowej wersji. Program jest jeszcze bez żadnych mechanizmów oszczędzani prądu i używa najprostszej funkcji "delay()". Sam program to właściwie nic wielkiego nie robi tylko raz na jakiś czas włącza i wyłącza diody (czyli głównie czeka w funkcjach "delay()" właśnie). Zużycie prądu całego układu to minimum 2,66mA (kiedy świecą tylko dwie diody) i wskakuje maksymalnie na poziom zużycia około 11mA. Testując sam mikrokontroler (wykonujący ten sam program, ale bez podłączonych diod) zużycie prądu jest stałe na poziomie 1,67mA. ZEGAR - czyli jak częstotliwość pracy mikrokontrolera wpływa na zużycie prądu. Okazuje się iż domyślnie fabrycznie nowe ATtiny25 pracuje z częstotliwością 1MHz, ale potrafi szybciej. Wewnętrzny zegar ma częstotliwość 8MHz a nowe ATtiny25 dzieli tą wartość przez 8 i stąd się bierze 1MHz. Programując mikrokontroler można jednak bardzo łatwo ustawić aby dzielnik nie był używany i mikrokontroler pracował z szybkością 8MHz. Okazuje się jednak iż większa częstotliwość to większe zużycie prądu na poziomie około 6,75mA-6,80mA (w tą stronę więc nie chcemy iść). Można jednak iść w drugą stronę i zmniejszyć częstotliwość, a najprościej do 128KHz w trybie WDT. W tym przypadku w ogóle nie korzystamy z głównego zegara, a zamiast niego z dodatkowego zegara modułu WDT (do tego jeszcze wrócę). Warto jednak dodać, iż w tym trybie nie każdy program będzie działał poprawnie (akurat ten mój działa OK). Tutaj widać znaczącą poprawę ponieważ zużycie prądu jest na poziomie 0,57mA, a mierząc bardziej dokładnie to 576uA. OSZCZĘDZAMY - czyli wyłączamy moduły mikrokontrolera, z których nie korzystamy Zamiast zmieniać domyślną częstotliwość pracy mikrokontrolera (zostajemy w dalszych testach na 1MHz) można wyłączać nie używane moduły. Ponieważ mój program jest bardzo prosty, to na początek wyłączam moduł AC (Analog Comparator) oraz ADC (Analog to Digital Converter). Przy okazji "wyłączam" też jeden nie używany PIN ponieważ według dokumentacji to też pomaga w oszczędzaniu prądu. // Początkowa konfiguracja platformy Adruino oraz zmiennych całego programu void setup() { // Wyłączamy AC (Analog Comparator) ustawiając odpowiedni bit na 1 // #1 - ręcznie ustawiamy odpowiednie bit'y dla odpowiednich rejestrów ACSR |= (uint8_t)(1<<ACD); // Wyłączamy ADC (Analog to Digital Converter) ustawiając odpowiedni bit na 0 // #1 - ręcznie ustawiamy odpowiednie bit'y dla odpowiednich rejestrów ADCSRA &= (uint8_t)~(1<<ADEN); // Wyłączamy nie używany PIN pinMode(PIN_Disabled, INPUT_PULLUP); } Po tej drobnej zmianie okazuje się, że zużycie prądu jest na poziomie 1,30mA (niby niewielka zmiana, ale idziemy w dobrym kierunku). Okazuje się, że można jeszcze wyłączyć cztery inne moduły mikrokontrolera ustawiając odpowiednie bity w odpowiednim rejestrze. Moduły te nazywają się "Timer 1", "Timer 0", "USI (Universal Serial Interface)" oraz "ADC (Analog to Digital Converter)". Wszystkie te moduły można wyłączyć jedną komendą. // Wyłączamy nie używane moduły ustawiając odpowiednie bity na 1 // #1 - ręcznie ustawiamy odpowiednie bit'y dla odpowiednich modułów PRR |= (uint8_t)(1<<PRTIM1) | (uint8_t)(1<<PRTIM0) | (uint8_t)(1<<PRUSI) | (uint8_t)(1<<PRADC); Zużycie prądu jest na poziomie 1,10mA (dokładnie idealnie 1100uA) ale niestety mój program w takiej konfiguracji nie działa. Okazuje się iż używana w programie funkcja "delay()" korzysta z modułu "Timer 0" i tego niestety nie możemy wyłączyć (na razie). Nie wyłączamy więc tego jednego moduły, a przy okazji zmieniamy program na łatwiejszą wersję z wykorzystaniem gotowej biblioteki. // Dla oszczędności zużycia prądu kilka przydatnych operacji #include <avr/power.h> // Będziemy wyłączać część modułów // Wyłączamy nie używane moduły ustawiając odpowiednie bity na 1 // #2 - indywidualne wywołania z biblioteki dla odpowiednich modułów power_timer1_disable(); // Disable the Timer 1 module. // power_timer0_disable(); // Disable the Timer 0 module. power_usi_disable(); // Disable the Universal Serial Interface module. power_adc_disable(); // Disable the Analog to Digital Converter module. W tej formie program ponownie działa poprawnie, a zużycie prądu jest na poziomie 1,14mA (dokładnie to 1147uA). Aby zejść poniżej 1mA trzeba będzie wykorzystać usypianie mikrokontrolera. Usypianie to jest nieco szerszy temat, który opiszę w drugiej części artykułu już niedługo.

Przez "kilka dni" mnie nie było i w tym czasie udało się skończyć cały model, więc opiszę co i jak zrobiłem. Wszystkie części zostały pomalowane a elektronicznie to zaszalałem nawet ponieważ jednak zrobiłem świecące kontrolki na desce rozdzielczej. Odnośnie sterowania ostatecznie zdecydowałem się na przetwornicę StepUp/StepDown oraz ATtiny25. Z dokumentacji przetwornicy oraz kursów forbot'a dowiedziałem się, że nie zaszkodzi dodać jeszcze dwa kondensatory (jeden 100uF, a drugi 100pF). Całość postarałem się zlutować najlepiej jak umiem w jak najbardziej kompaktowej formie. Wyszedł mi taki całkiem zgrabny "pajączek". Połączenie oświetlenia z sterowaniem tworzy jeszcze większego "pajączka", ale wszystko działa tak jak powinno. W ten sposób udało się zrobić cały model, który prezentuje się jak widać poniżej. Dziękuję wszystkim, którzy pomogli mi w realizacji, a w szczególności @ethanak za podpowiedź z tą przetwornicą. Ponieważ piszę ten post już sporo po zakończeniu modelu to muszę dodać, że jednak część elektroniczna ma sporą nieplanowaną wadę Okazało się iż oświetlenie działa tylko lekko ponad 4 godziny, a miało działać dużo dłużej niż w poprzednim modelu. Musiałem chyba źle przeliczyć rezystory, zrobić jakieś zwarcie lub cos źle zlutować (np. złe rezystory). Na schemacie zapisałem rezystory jakie wyliczyłem, że według mnie powinny być, ale faktycznie to już nie sprawdzę jakie zrobiłem. Teraz jedyne co mogłem zrobić to sprawdzić ile prądu "zjada" mój model na świecenie i wychodzi na to iż są to jakieś ogromne wartości. HONDA zużywa minimum 16,1mA i wskakuje czasem na poziom zużycia 36,4mA KAWASAKI miało za duże zużycie, a jak zmierzyłem to ma minimalnie 5,2mA i wskakuje czasem na 10,7mA. Będę musiał chyba wrócić do nauki oszczędzania prądu tak jak mi nawet przepowiedział to @ethanak Bez tego kolejne modele może i będą migać jak bym chciał, ale jednak zdecydowanie za krótko. Zrobię z tego chyba osobny blog, na którym będę opisywał moje postępy w nauce. Jeszcze raz dziękuję wszystkim za pomoc i do usłyszenia wkrótce

Teraz jestem jeden maleńki kroczek do przodu. Stan "wiem, że nic nie wiem", to i tak więcej niż poprzedni stan "nie wiem nawet tego, że jestem totalnym ignorantem, ponieważ nic nie wiem"

No dobra, fajne to i ciekawe, ale znacząco przekracza moje potrzeby "początkującego elektronika hobbysty". Wspaniały jest ten nasz świat i wychodzi na to iż właściwie to niewiele z niego rozumiemy.

Posunąłem nieco do przodu prace modelarsko-lutownicze. Zamontowałem główny wyłącznik zasilania, zlutowałem światła stop oraz przednie światła mijana i drogowe. Zrobiłem też wstępną wersję schematu całej instalacji. Wszelkie uwago co do schematu mile widziane. Odezwę się wkrótce jak będzie coś więcej do pokazania.

Zrobiłem testy z przetwornicą Pololu S7V7F5 i wyniki są następujące. Baterie już nieco osłabły do 6.01V, ale zgodnie z obietnicą producenta napięcie zasilania jest stabilne u mnie 5.13V. Zużycie prądu w zależności od ilości świecących diod wacha się od 5.24mA do maksymalnie 14.86mA. Wychodzi na to iż mam już trzy możliwości wyboru zasilania mojego modelu. Przetwornica wydaj się być najbardziej rozsądna, ponieważ podobno będzie również "podciągać" napięcie kiedy baterie zostaną już rozładowane. Tylko faktycznie cena w porównaniu do diod i stabilizatora jest jakby nieco wygórowana. Fajnie, że jest tyle możliwości. Odezwę się wkrótce jak będę miał coś nowego do napisania.

Dzięki @matsobdev popatrzę na te akumulatory. Zaskoczyłeś mnie, że ktokolwiek jeszcze czyta ten mój worklog

Bardzo miła niespodzianka proszę kolegi. Okazuje się, że taka przetwornica jest dołączona do FORBOT - podstawy elektroniki 2 - zestaw elementów, więc już mam jedną sztukę To jest faktycznie maleństwo, które powinno się już zmieścić w moim modelu. Zaraz wezmę się do eksperymentów, tylko poczytam ten kawałek kursu aby dowiedzieć się więcej o tym wynalazku Za to właśnie lubię FORBOT, że tolerujecie takich nowicjuszy jak ja i za każdym razem mogę się czegoś nowego dowiedzieć. Nie znalazłem tylko żadnego systemu "plusów na profil" lub innej możliwości docenienia najbardziej pomocnych użytkowników forum. Odezwę się wkrótce co mi wyszło z eksperymentów.

Dotarłem już z pomysłami do przetwornic DC-DC Step-Up/Step-Down tylko rozmiary mnie niestety trzymają. Model motocykla w skali 1:12 ma na tyle mało miejsca, że nie upchnę czegoś tak wielkiego, a nie szukałem jeszcze, czy są jakieś mniejsze przetwornice. Nad akumulatorkiem LiPo też już myślałem, ale z tego co wstępnie patrzyłem rozmiary są zupełnie poza dostępnym miejscem w tej skali. Ten projekt motocykla to nie jest jednak koniec moich pomysłów. Aktualnie mam w planie trzy inne projekty, które powinny zmieścić zarówno akumulatorek jak i przetwornicę. To będzie jednak dość odległa przyszłość, ale na zachętę mogę podać iż myślę o takich trzech modelach: Enzo Ferrari w skali 1:12 Harley-Davidson FLSTFB w skali 1:6 HONDA CRF1000L w skali 1:6 Wracając jednak do stanu obecnego muszę zdecydować, czy użyć zestawu diod, czy stabilizatora. Martwi mnie jednak odpowiedź @ethanak, z której zrozumiałem iż po pewnym czasie regulator zacznie bardziej szkodzić niż pomagać. Może jednak pomysł z diodami będzie lepszy? Zużywa mniej prądu, a zmiany napięcia są w sumie do zaakceptowania. No i jak z czasem będzie spadać napięcie to cały układ powinien ciągle działać (według specyfikacji ATtiny25 do 2.7V a nawet 1.8V). Będę czytał, myślał, kombinował i dam znać co mi wyszło w kolejnym wpisie.

Kolega @ethanak napisał, że można użyć LDO tylko nie napisał co to takiego jest. Wpisałem więc w "popularny sklep internetowy" tekst "LDO 5V" i znalazłem stabilizator liniowy LM2931, a przy okazji okazało się, że LDO to znaczy Low DropOut Zakupiłem więc kilka stabilizatorów LM2931AZ-5 (5V) w obudowie TO-92 (a przy okazji poznałem kolejną tajną nazwę). Czekając na przesyłkę w specyfikacji wyczytałem, że ten cały dropout jest faktycznie niski ponieważ w przedziale od 0.05V do 0.30V. Zabrałem się więc do eksperymentów, a na początek porównałem sobie ten nowy stabilizator z tym z kursów Forbot'a LM7805 (5V). Przy zasilaniu z baterii 9V oba stabilizatory dają faktycznie idealne napięcie 5V. Jednak ja chcę zasilać mój model z dwóch baterii 3V ukrytych pod siedzeniem, które mają razem nominalnie 6V. Tutaj okazuje się, że LM7805 jednak nie działa jak należy (zapewne z powodu swojego minimalnego dropout'u 2V). Skoro stabilizator LM2931AZ dział jak należy, to mogłem przejść do dalszej części eksperymentów. Zrobiłem pomiary mojego układu testowego z wymyślonym wcześniej zasilaniem składającym się z trzech diod 1N4148. Tak jak się spodziewałem w tym przypadku napięcie na ATtiny25 nie jest stabilne i ciągle się zmienia podczas pracy (minimalnie ale jednak). Najwyższe zużycie pądu jakie zaobserwowałem to było nieco ponad 9mA. Po przerobieniu mojego układu testowego na korzystanie z zasilania LM2931AZ okazało się iż wyniki są inne w obu mierzonych aspektach. Dzięki stabilizatorowi zasilanie na ATtiny25 jest ciągle idealnie 5V (no tak faktycznie to zmienia się od 5.01V do 5.02V). Za to maksymalne zużycie prądu jakie zaobserwowałem niestety wzrosło do ponad 15mA (to jest wzrost o prawie 70%). Z wcześniej robionych kursów Forbot'a zrozumiałem, że układy scalone lubią mieć jednak stabilne zasilanie. Tak sobie więc wykombinowałem, że to powinno być jednak warte poświecenia tych kilku dodatkowych mA. Docelowo ilość diod w całym modelu będzie większa niż w układzie testowym, wiec ta różnica 6mA nie powinna być tak znacząca. Na razie to tyle z moich eksperymentów. Odezwę się znowu jak wymyślę coś nowego. ps. Do testów użyłem kondensatora 220uF, a w specyfikacji LM2931 jest, że powinno być 100uF. Mam nadzieję, że to nie "zepsuło" moich testów oraz wniosków. Kupię sobie kilka kondensatorów 100uF i ewentualnie powtórzę testy.

To ja też się pochwalę moją wersją zadania domowego numer 4.6 Właściwie to ten mój cały program w pętli loop() ma raptem sześć linijek i gotowe. #define foto_Gorny A4 // Wejście dla fotorezystora górnego #define foto_Dolny A5 // Wejście dla fotorezystora dolnego #define PIN_GornyMax 13 // Numer PIN dla diody górnej mocnej #define PIN_Gorny 12 // Numer PIN dla diody górnej #define PIN_Srodek 11 // Numer PIN dla diody środkowej #define PIN_Dolny 10 // Numer PIN dla diody dolnej #define PIN_DolnyMax 9 // Numer PIN dla diody dolnej mocnej int OdczytRoznica = 0; // Różnica w odczytach void setup() { // Konfiguracja wyjść pod diody LED pinMode(PIN_GornyMax, OUTPUT); pinMode(PIN_Gorny, OUTPUT); pinMode(PIN_Srodek, OUTPUT); pinMode(PIN_Dolny, OUTPUT); pinMode(PIN_DolnyMax, OUTPUT); } void loop() { // Pobieramy odczyty, dzielimy przez 100 i liczymy różnicę w odczytach (wszystko po to aby porównywać różnice w "setkach") OdczytRoznica = ( analogRead(foto_Dolny) / 100 ) - ( analogRead(foto_Gorny) / 100 ); // Ustalamy, które diody mają świecić digitalWrite(PIN_GornyMax, OdczytRoznica <= -3); digitalWrite(PIN_Gorny, OdczytRoznica == -2); digitalWrite(PIN_Srodek, (OdczytRoznica >= -1) && (OdczytRoznica <= 1)); digitalWrite(PIN_Dolny, OdczytRoznica == 2); digitalWrite(PIN_DolnyMax, OdczytRoznica >= 3); // Czekamy nieco aby za szybko nie zmieniać świecenia diod delay(100); } Oczywiście na początku zrobiłem wielowariantowego if {} else {} Później wykombinowałem sobie, że przecież HIGH == 1 == TRUE oraz LOW == 0 == FALSE I tak doszedłem do tego, że warunki mogę zamieścić już w samej funkcji digitalWrite()

Pokombinowałem nieco z ustawieniami menedżera płytek oraz z parametrami kompilacji. Osiągnąłem wyniki nawet "niższe" niż @ethanak, więc jednak umożliwiające wykorzystanie ATtiny13 (gdybym tylko takie miał). ATtiny25 - dla wersji V3a, sprawdzone i nawet działa Szkic używa 1506 bajtów (73%) pamięci programu. Maksimum to 2048 bajtów. Zmienne globalne używają 20 bajtów (15%) pamięci dynamicznej, pozostawiając 108 bajtów dla zmiennych lokalnych. Maksimum to 128 bajtów. ATtiny25 - dla wersji V4a, sprawdzone i nawet działa Szkic używa 948 bajtów (46%) pamięci programu. Maksimum to 2048 bajtów. Zmienne globalne używają 17 bajtów (13%) pamięci dynamicznej, pozostawiając 111 bajtów dla zmiennych lokalnych. Maksimum to 128 bajtów. ATtiny13 - dla wersji V3a, nie ma jak sprawdzić, czy działa ponieważ nie mam ATtiny13 Szkic używa 922 bajtów (90%) pamięci programu. Maksimum to 1024 bajtów. Zmienne globalne używają 11 bajtów (17%) pamięci dynamicznej, pozostawiając 53 bajtów dla zmiennych lokalnych. Maksimum to 64 bajtów. ATtiny13 - dla wersji V4a, nie ma jak sprawdzić, czy działa ponieważ nie mam ATtiny13 Szkic używa 364 bajtów (35%) pamięci programu. Maksimum to 1024 bajtów. Zmienne globalne używają 8 bajtów (12%) pamięci dynamicznej, pozostawiając 56 bajtów dla zmiennych lokalnych. Maksimum to 64 bajtów. Na razie chyba wystarczy kombinowania z kompilacjami. Przy okazji robiąc pomiary spaliłem bezpiecznik w mierniku i będę musiał teraz z tym sobie poradzić Dam znać jak będę miał jakieś nowe postępy prac.

Kompiluję na Arduino Uno R3 aby orientacyjnie zobaczyć jaki ten program będzie miał rozmiar. Tego nie rozumiem jak zrobiłeś 384 bajtów, ponieważ wgrywając wersję V2a oraz V3a na ATtiny25/ATtiny85 dostawałem znacząco większe wyniki. @ethanak napisz coś więcej, którą wersję programu kompilowałeś (V2a, V3a, czy V4a) i jak to robiłeś? Odnośnie tego tematu: To wiem już, że powinienem użyć regulatora napięcia, ale nie mogłem znaleźć takiego co by mi zrobił z nominalnych 6.0V oczekiwane 5.0V. Teraz ewentualnie poszukam takiego co robi z nominalnych 6.0V oczekiwane 3.3V, ale jeszcze nie wiem, czy takie w ogóle istnieją. Będę się uczył i kombinował dalej. Wkrótce dam znać co mi z tego wyszło w kolejnej części mojej opowieści. ps. Widziałem, że są możliwości "usypiania" mikrokontrolera, ale na razie to jest poza moimi umiejętnościami. No chyba, że to jakaś prosta sprawa zamiast delay(ms) jest coś w stylu "zaśnij_i_oszczędziaj_prąd(ms)" (doczytam sobie jeszcze).

Niesamowita sprawa ten cały prąd. Sam jestem zupełnie początkujący, ale artykuł jest bardzo ciekawy i nawet dla mnie bardzo pomocny.

Potrzebuję odrobiny wsparcia bardziej doświadczonych elektroników. Proszę @Treker, @ethanak lub kogokolwiek innego o pomoc i komentarz, czy to co kombinuję poniżej to ma w ogóle sens. Zrobiłem sobie pomiary mojej instalacji i wychodzą mi następujące wyniki: Napięcie zasilania: 6.16V (tyle daje nowy komplet baterii) Napięcie za diodą: 5.45V (akurat tyle ile potrzeba do maksymalnego zasilania ATtiny25) spadek napięcia na diodzie to 0.71V, czyli właściwie idealny wynik Prąd całego układu: 15,33mA (i tutaj zaczynam kombinowanie, czy można jakoś "zaoszczędzić" na zużywanym prądzie) Według dokumentacji ATtiny25 zasilanie może być z zakresu od 2.7V do 5.5V. Skoro zwykłą diodą krzemową mogę zmniejszyć napięcie o 0.7V, to czemu by nie zmniejszyć o 4 x 0.7V, czyli o 2.8V (nominalnie z 6.0V do 3.2V)? Zamieniłem jedną diodę na cztery diody w mojej instalacji i porobiłem kolejne pomiary: Napięcie zasilania: 6.19V (tym razem nieco więcej, ale rozumiem, że to jest OK) Napięcie za diodami: 3.36V (akurat z lekkim zapasem ile potrzeba do minimalnego zasilania ATtiny25) spadek napięcia na czterech diodach to 2,83V, czyli właściwie idealny wynik Prąd całego układu: 6,60mA (ponad połowę mniej niż poprzednio z jedną diodą) wychodzi 57% "oszczędności", czyli jeśli dobrze kombinuję dwa razy dłuższe działanie na tych samych bateriach. Tutaj właśnie pojawia się pytanie do bardziej doświadczonych elektroników, czy ja prawidłowo sobie tutaj kombinuję? Po pierwsze, czy to tak można sobie zmniejszać napięcie diodami? Po drugie czy to faktycznie oznacza, że pobór prądu jest ponad połowię mniejszy, czyli będzie dwa razy dłuższe działanie układu? Jeśli bateria nieco się rozładuje, to 4 diody mogą dać napięcie za bardzo na granicy minimalnego zasilania. Kombinuję więc dla bezpieczeństwa, czy nie dać jednak 3 diody jeśli cały pomysł ma w ogóle sens. Czekam na jakąś poradę, a w tak zwanym międzyczasie kombinuję sobie dalej.

Osobiście nieco "zaszalałem" i zrobiłem zadanie 2.5 z dodatkowymi wariantami komend: lewy, prawy, oba, razem. Chodziło mi o to aby można było sterować każdą diodą osobno oraz wspólnie zmieniać "oba" jednocześnie lub zapalać/gasić "razem". #define PIN_Lewy 8 #define PIN_Prawy 7 #define TXT_Lewy "lewy" #define TXT_Prawy "prawy" #define TXT_Oba "oba" #define TXT_Razem "razem" String odebraneDane = ""; bool swieciLewy = false; bool swieciPrawy = false; bool swieciRazem = false; void setup() { Serial.begin(9600); pinMode(PIN_Lewy, OUTPUT); pinMode(PIN_Prawy, OUTPUT); digitalWrite(PIN_Lewy, LOW); digitalWrite(PIN_Prawy, LOW); } void loop() { if(Serial.available() > 0) { odebraneDane = Serial.readStringUntil('\n'); if (odebraneDane == TXT_Lewy || odebraneDane == TXT_Oba) { if (swieciLewy) { digitalWrite(PIN_Lewy, LOW); swieciLewy = false; swieciRazem = false; } else { digitalWrite(PIN_Lewy, HIGH); swieciLewy = true; swieciRazem = swieciLewy && swieciPrawy; } } if (odebraneDane == TXT_Prawy || odebraneDane == TXT_Oba) { if (swieciPrawy) { digitalWrite(PIN_Prawy, LOW); swieciPrawy = false; swieciRazem = false; } else{ digitalWrite(PIN_Prawy, HIGH); swieciPrawy = true; swieciRazem = swieciPrawy && swieciLewy; } } if (odebraneDane == TXT_Razem) { if (swieciRazem) { digitalWrite(PIN_Lewy, LOW); digitalWrite(PIN_Prawy, LOW); swieciRazem = false; swieciLewy = false; swieciPrawy = false; } else{ digitalWrite(PIN_Lewy, HIGH); digitalWrite(PIN_Prawy, HIGH); swieciRazem = true; swieciLewy = true; swieciPrawy = true; } } if (odebraneDane != TXT_Lewy && odebraneDane != TXT_Prawy && odebraneDane != TXT_Oba && odebraneDane != TXT_Razem) { Serial.println("Nie ma takiej diody: \""+odebraneDane+"\" !"); } delay(1000); } }