To miała być ciekawa prezentacja. Niestety w ostatniej chwili okazało się, że… nie będę miał dostępu do gniazdka elektrycznego! Trzeba było na szybko złożyć jakiś zasilacz “bezprzewodowy”. Przetwornica step-down na MP2307, trzy akumulatory 18650, wyłącznik, prosty alarm stanu zasilania – wszystko połączone gorącym klejem. Zadziałało!
Po kilku tygodniach okazało się jednak, że tego “zasilacza” używam… dosłownie codziennie. Postanowiłem więc zamienić prowizorkę na coś trochę bardziej eleganckiego. Powstała wersja 2 – której budowę Wam zaprezentuję.
Wersja pierwsza: prowizorka
Pierwsza wersja to niewiele więcej niż moduł przetwornicy z układem mp2307 podłączony do koszyczka z trzema akumulatorami 18650.
Moduł przetwornicy wyposażono w wyświetlacz. Wyświetlacz pokazuje napięcie wyjściowe i natężenie pobieranego prądu. Za pomocą przycisków można zmienić napięcie wyjściowe. Wszystko dostarczane jest w plastikowej obudowie.
Przetwornicę przymocowałem gorącym klejem na spodzie koszyczka. Dodałem wyłącznik i niewielki układ monitorujący napięcie baterii.
18650 to ogniwa typu Li-Ion. Pozyskuję je ze starych akumulatorów od laptopów. Polecam przeczytanie Ogniwa Li-ion.
Zbudowany układ miał jednak sporo wad. Najważniejszą z nich był kompletny brak ochrony mechanicznej akumulatorów. Brakowało jeszcze kilku funkcji. No i wygląd… dość… powiedzmy tymczasowy.
Więcej na temat tej “prowizorki” możecie dowiedzieć się z tekstu Zasilacz na szybko… opublikowanym na moim blogu uczymy.edu.pl. Tekst zawiera instrukcję kalibracji miernika napięcia.
Wersja 2.0
Mówią, że prowizorki trwają najdłużej. Ta akurat nie miała tyle szczęścia – głównie ze względu na klej użyty do łączenia elementów. Po pewnym czasie moduł przetwornicy odpadł od koszyka. Ale ze względu na użyteczność narzędzia – postanowiłem je zbudować porządnie.
Wersja 2.0 to przede wszystkim:
- Inne zasilanie: 4 akumulatory 18650 zamiast trzech plus dodatkowe gniazdo do ładowania pakietu,
- Odcinanie zasilania i wyjścia,
- Potencjometr do regulacji napięcia wyjściowego (zamiast przycisków),
- Porządna obudowa mieszcząca kable.
Pełny tekst znajdziecie na moim blogu: MP2307 zasilacza na szybko, wersja 2. Zawiera on więcej szczegółów – tutaj przytaczam tylko skrót. Przeczytajcie również:
Zasilanie 2.0
W poprzedniej wersji zasilanie pochodziło z 3 akumulatorów 18650. Takie akumulatory mają nominalne napięcie 3.7v. Trzy połączone szeregowo dają około 11.1v (więcej, gdy akumulatory są w pełni naładowane). Sama przetwornica pobierała nieco z napięcia, z urządzenia mogłem maksymalne uzyskać 10.4v. To trochę mało dla niektórych zastosowań.
W wersji 2.0 postanowiłem użyć 4 ogniwa tego typu (nominalnie 4×3.7=14.8v, maksymalnie 16.8v). Potrzebowałem do tego nowy koszyk:
Podobnie jak poprzednio – zasilanie przetwornicy będzie włączane za pomocą dodatkowego przełącznika umieszczonego na obudowie.
Nowością będzie wyprowadzenie kabli zestawu akumulatorów na zewnętrzne gniazdo. Nie po to, żeby z niego coś zasilać – ale żeby naładować baterie za pomocą zewnętrznej ładowarki. Wybrałem standardowe gniazdo dc 2.1 mm. Ponieważ moja ładowarka (redox beta) nie miała takiego wyjścia, musiałem sobie zmajstrować przejściówkę z gniazda T do wtyku dc 2.1mm.
Przyciski 2.0, czyli potencjometr
W oryginalnej przetwornicy napięcie wyjściowe ustawia się za pomocą dwóch przycisków. Każde kliknięcie podnosi lub obniża napięcie na wyjściu o 0.04v. Przyciski można też przytrzymać – wtedy wartości zmieniają się szybciej. Postanowiłem zamienić je na potencjometr.
Niestety na płytce nie znalazłem żadnego miejsca, które pozwoliłby mi się podpiąć pod kontroler i wymusić zmianę wartości napięcia. Pozostało więc trochę oszukać moduł i zamiast mechanicznie – wciskać przyciski elektrycznie.
Już po pierwszym sprawdzeniu okazało się, że gdy rozwarte, styki przycisków są w stanie niskim (masa) oraz ok. 3.2v. Po wciśnięciu przycisku – stan zmienia się na niski. W ten sposób wiedziałem już, który przycisk jest wyjściem (w stanie rozwartym masa) – a który wejściem na kontroler przetwornicy (w stanie rozwartym ten z napięciem). Po drugie, widziałem już, że sprowadzenie do masy pinu podpiętego do wejścia kontrolera powinno zadziałać tak samo, jakbym go wcisnął “mechanicznie”.
Pozostała kwestia sterowania. Chciałem mieć potencjometr. Przekręcenie go w jedną stronę miało zwiększać napięcie wyjściowe; w drugą – je zmniejszać. Ponieważ mogę jedynie “wciskać” przyciski – układ sterowania potrzebuje informacji zwrotnej. Muszę mierzyć zmiany napięcia wyjściowego w reakcji na zmianę pozycji potencjometru. Algorytm jest prosty:
- Zmieniam nastawę potencjometru,
- Przeliczam nastawę na pożądane napięcie wyjściowe. Do obliczeń potrzebne jest maksymalne napięcie, jakie może uzyskać przetwornica przy aktualnym stanie baterii,
- Mierzę napięcie na wyjściu przetwornicy,
- Obliczam różnicę między nastawą i napięciem wyjściowym,
- “Wciskam” odpowiedni przycisk aż do momentu, kiedy napięcie wyjściowe osiągnie to nastawione.
To typowe zadanie sterowania ze sprzężeniem zwrotnym. W automatyce rozwiązuje się je np. za pomocą regulatora PID. Z zestawu proporcjonalno- całkująco- różniczkujący wykorzystam tylko pierwszy człon – powinien wystarczyć.
Oczywiście podobne zadania najłatwiej zrealizować za pomocą kontrolera. Miejsca miałem jedynie na coś niewielkiego. Policzmy:
- 1 wejście analogowe do mierzenia napięcia baterii,
- 1 wejście analogowe do mierzenia napięcia wyjściowego,
- 1 wejście analogowe do mierzenia wskazań potencjometru,
- 1 wyjście cyfrowe do “wciskania” przycisku podnoszącego napięcie wyjściowe,
- 1 wyjście cyfrowe do “wciskania” przyciski obniżającego napięcie wyjściowe,
…brzmi jak… AtTiny85.
UNO R3
Zanim przesiadłem się na AtTiny85, wypróbowałem wszystko na Arduino UNO. Dużo łatwiej rozwija się na nim prototypy, do debuggowania można użyć np. komunikacji szeregowej (wbudowana w Arduino IDE konsola).
Bardziej zaawansowani czytelnicy – zamiast prostych logów na konsoli – mogą użyć np. pakietu matplotlib. Umożliwia on wizualizację zmian parametrów – co bardzo pomoże w eksperymentowaniu z nastawami regulatora.
AtTiny85
O programowaniu AtTiny pisałem: Programowanie AtTiny85 z Arduino. Po przetestowaniu algorytmu na UNO, przyszedł czas na przesiadkę na docelowe AtTiny85. Piny przyporządkowałem następująco:
- A1 (fizyczny pin 7): pomiar wskazań potencjometru,
- A3 (pin 2): pomiar napięcia baterii,
- A2 (pin 3): pomiar napięcia wyjściowego,
- D0 (pin 5): “wciskanie” przycisku podnoszącego napięcie wyjściowe,
- D1 (pin 6): “wciskanie” przycisku obniżającego napięcie wyjściowe.
Wybór pinów był podyktowany sposobem organizacji płytki.
Do pomiarów napięć baterii i wyjściowego z przetwornicy konieczny będzie dzielnik napięcia. Maksymalne napięcie baterii będzie wynosiło do ok. 16.8v (4.2v x 4 ogniwa). Przetwornik analog/cyfra AtTiny85 mierzy napięcie do poziomu zasilania (Vcc, standardowo). Ja zasilam AtTiny napięciem 3.3v (przetwornica pololu reg04b). Konieczne jest więc podzielenie napięcia z baterii tak, żeby nie przekroczyło 3.3v. Wystarczy więc dzielnik z rezystorów np. 10k i 47k. Napięcie na przetworniku będzie wynosiło:
Zastosowanie kombinacji rezystorów 10k i 47k podzieli napięcie wejściowe Uwe=17v do niemal Uwy=3v – co jest w zupełności bezpieczne dla AtTiny zasilanego 3.3v (rezystor 10kΩ idzie do masy). Z drugiej strony, po obliczeniu napięcia Uwy na AtTiny, trzeba je z powrotem przemnożyć, żeby uzyskać napięcie w mierzonym punkcie. W ten sam sposób można zmierzyć napięcie na wyjściu przetwornicy.
Napięcie na potencjometrze mierzymy podłączając jego środkowy pin do przetwornika a/c AtTiny. Skrajne piny potencjometru podłączamy do masy i zasilania 5v.
Do odczytania napięcia na wejściu analogowym służy komenda “analogRead()”. Polecenie to zwraca wartości z przedziału 0..1023, gdzie 0: 0v a 1023 – napięcie zasilania, tu: 3.3v (w domyślnym przypadku, można zmienić funkcją “analogReference()”).
Na podstawie wartości “analogRead()” napięcie na pinie kontrolera można obliczyć w następujący ten sposób:
|
1 |
float voltage = (((float) analogRead(A0) + 0.5 ) * 3.3 ) / 1023.0; |
Jeszcze lepiej stworzyć do tego funkcję:
|
1 2 3 4 5 6 7 |
float adc2voltage(int adcValue) { //Read vcc to get better calculations of adc static float refVoltage = readVcc(); float v = (((float)adcValue + 0.5 )* refVoltage) / 1023.; v = v * DIVIDER_RATIO; return v; } |
W ostatnim kroku, żeby uzyskać prawdziwe napięcie, wynik trzeba przemnożyć przez wartość dzielnika napięcia (DIVIDER_RATIO). U mnie:
|
1 |
#define DIVIDER_RATIO 5.818 |
Pozostało samo wciskanie przycisków. Potrzeba jedynie zewrzeć do masy pin wyjściowy przycisku. Świetny post na ten temat znajdziecie tutaj: Trigger Buttons with Arduino. Do podłączenia wystarczy jedna dioda 1n4148. Zabezpieczy port AtTiny przed napięciem przechodzącym przez przycisk w razie jego przypadkowego wciśnięcia gdy port kontrolera ustawiony jest jako wyjście.
Żeby wcisnąć przycisk:
|
1 2 |
digitalWrite(0, LOW); pinMode(0, OUTPUT); |
Żeby go “puścić”:
|
1 2 |
digitalWrite(0, LOW); pinMode(0, INPUT); |
Ot i cała magia:
Monitorowanie napięcia baterii – v2.0
Skoro i tak mierzę napięcie baterii (do wyskalowania potencjometru) łatwo też wykryć moment, w którym napięcie pakietu spadnie poniżej niebezpiecznego poziomu 12v. W takim momencie można by zapalić diodę, albo uruchomić buzzer. Policzyliście jednak piny AtTiny?
Niestety wykorzystałem wszystkie… No prawie:)
Opcje:
- Układ monitorowania jak w poprzednim projekcie (z TL431),
- Dioda podpięta pod pin Reset AtTiny85 – który zamienię na port wejścia/wyjścia.
Opcja 2 jest bardziej skomplikowana (i ciekawsza:)). Pin Reset AtTiny85 można wykorzystać do uruchomienia LED sygnalizującej niski poziom napięcia pakietu. ALE: w normalnej konfiguracji ustawienie tego pinu (PB5/D5) w stan niski… zresetuje kontroler. A tego nie chcemy. Pin ten można przeprogramować na normalny port zmieniając ustawienia fuse-bitów (generalnie wyłączając resetowanie). Ale wtedy… nie da radę przeprogramować AtTiny85 poprzez ISP. Programowanie AtTiny przez ISP wymaga działającego resetu – ba, do ponownej zmiany fusów reset też jest potrzebny. Innymi słowy: po zaprogramowaniu AtTiny i wyłączeniu Resetu przez zmianie fusów – nie będziecie mogli już zmienić programu na kontrolerze. Chyba, że… zbudujecie programator HVSP (High Voltage Serial Programmer):)
Sposób na zbudowanie HVSP opisałem tutaj: HVSP dla AtTiny85.
Program dla AtTiny85
Cały program wygląda tak:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 |
//Arduino UNO pins #if defined(__AVR_ATmega328P__) #define POT_PIN A0 #define BATTERYV_PIN A1 #define OUTPUTV_PIN A2 #define LED_PIN 13 #define CLICK_UP_PIN 3 #define CLICK_DOWN_PIN 2 //ATTiny85 pins #elif defined (__AVR_ATtiny85__) //AtTiny85 // //A0/D5/RESET |----| Vcc // A3/D3 | | A1/D2 // A2/D4 | | D1 // GND |----| D0 #define POT_PIN A1 #define BATTERYV_PIN A3 #define OUTPUTV_PIN A2 #define LED_PIN 5 #define CLICK_UP_PIN 0 #define CLICK_DOWN_PIN 1 #endif //Both BATTERYV and OUTPUTV use the same divider // Vin // |=| 47k // |-------ADC // |=| 10k // GND #define DIVIDER_RATIO 5.818 //Normalize pot step to... #define POT_STEP 0.1 //--------------------------------------------- //A state machine for cotrolling up/down tacts class StateMachine { private: //Key up/down const short STATE_DOWN = 1; const short STATE_UP = 0; //One of STATE_* int _state; //Last pin active int _pin; public: StateMachine() { _state = STATE_UP; _pin = -1; } //check if button is down bool isDown() { return (_state == STATE_DOWN ? true : false); } //press button down void down(int pin) { if (_state == STATE_DOWN && _pin != pin) { //Change of a pin - change of adjust direction pinMode(_pin, INPUT); _state = STATE_UP; } if (_state != STATE_DOWN ) { _state = STATE_DOWN; _pin = pin; digitalWrite(pin, LOW); // pin is the number of the digital pin pinMode(pin, OUTPUT); // Pull the signal low to activate button } } //press button up void up() { if ( _state != STATE_UP ) { _state = STATE_UP; pinMode(_pin, INPUT); } } }; //--------------------------------------------- //State machine StateMachine sm; //--------------------------------------------- //Reading reference voltage, copied from: //http://code.google.com/p/tinkerit/wiki/SecretVoltmeter float readVcc() { #if defined(__AVR_ATmega328P__) long result; // Read 1.1V reference against AVcc ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); delay(2); // Wait for Vref to settle ADCSRA |= _BV(ADSC); // Convert while (bit_is_set(ADCSRA, ADSC)); result = ADCL; result |= ADCH << 8; result = 1126400L / result; // Back-calculate AVcc in mV return (float)result / 1000.; #else //My AtTiny operates on 3.3v -when on 5v supposed to be: //return 5; return 3.3; #endif } //--------------------------------------------- float adc2voltage(int adcValue) { //Read vcc to get better calculations of adc static float refVoltage = readVcc(); float v = (((float)adcValue + 0.5 ) * refVoltage) / 1023.; v = v * DIVIDER_RATIO; return v; } //--------------------------------------------- void blinkMe(int nTimes) { for (int i = 0; i < nTimes; i++) { digitalWrite(LED_PIN, HIGH); delay(500); digitalWrite(LED_PIN, LOW); delay(500); } } //--------------------------------------------- void setup() { pinMode(CLICK_UP_PIN, INPUT); pinMode(CLICK_DOWN_PIN, INPUT); pinMode(LED_PIN, OUTPUT); blinkMe(3); } //--------------------------------------------- void loop() { //Read pot value and battery voltage int adcBatteryV = analogRead(BATTERYV_PIN); int adcOutputV = analogRead(OUTPUTV_PIN); //...convert to voltage float batteryVoltage = adc2voltage(adcBatteryV); float outputVoltage = adc2voltage(adcOutputV); //Raise alert if voltage is less than 3v/cell if ( batteryVoltage <= 12. ) { digitalWrite(LED_PIN, HIGH); } else { digitalWrite(LED_PIN, LOW); //Converter drops ! 1.6v float maxOutputVoltage = batteryVoltage - 1.6; //Variable for converting pot settting to voltage float tickPerTenth = 1023. / (maxOutputVoltage / POT_STEP); //Each click is 0.04 - need to know control possibilities int clickError = (int)(0.04 / (maxOutputVoltage / 1023.) + .5) + 1; //Convert pot setting to voltage float xV = ( (float)((1023-analogRead(POT_PIN))) / tickPerTenth) * POT_STEP; //Execute PID with kP=1. float change = xV - outputVoltage; //Each click is 0.04, how many of them I need to send //for the desired output? int clicks = (int)( change / 0.04 ); //If we are more than clickError away from requested voltage... if (clicks > clickError || clicks < -clickError ) { sm.down( clicks > 0 ? CLICK_UP_PIN : CLICK_DOWN_PIN ); } else { sm.up(); } } } //--------------------------------------------- |
Program ten zawiera wstawki z kodem dla Arduino UNO -używałem go w czasie testowania.
Teraz zaprogramujcie AtTiny poprzez Arduino IDE. Za pomocą tego samego programatora możecie sprawdzić fusy:
|
1 2 3 4 5 6 7 8 9 10 11 |
$ avrdude -P /dev/ttyUSB0 -b 19200 -c avrisp -p t85 -v ... avrdude: Device signature = 0x1e930b (probably t85) avrdude: safemode: hfuse reads as DF avrdude: safemode: efuse reads as FF avrdude: safemode: hfuse reads as DF avrdude: safemode: efuse reads as FF avrdude: safemode: Fuses OK (E:FF, H:DF, L:62) avrdude done. Thank you. |
Fusy ok, można je przeprogramować: wyłączymy dzielenie zegara przez 8 (bit CKDIV8) oraz reset (bit RSTDISBL) – UWAGA: po tej operacji, bez HVSP, nie dacie już radę przeprogramować Waszego AtTiny:
|
1 2 |
$ avrdude -P /dev/ttyUSB0 -b 19200 -c avrisp -p t85 -v -U lfuse:w:0xe2:m $ avrdude -P /dev/ttyUSB0 -b 19200 -c avrisp -p t85 -v -U hfuse:w:0x5f:m |
Teraz już nie da radę przeprogramować czipa przez ISP. Ale za to pin 1 (reset) można używać jako normalny port! Za pomocą HVSP można przywrócić fusy do stanu, który będzie umożliwiał ponowne zaprogramowanie AtTiny85.
Obudowa 2.0
I tu była największa zmiana. Postanowiłem włożyć wszystko do porządnej, drewnianej obudowy. Do jej budowy użyłem 4mm sklejki. Zacząłem od wycięcia formatek:
W bokach wywierciłem otwory, które mają zapewnić wentylację pakietu. Boczki dokleiłem do podstawki, dodałem kilka wzmocnień pod pokrywkę. Następnie zbudowałem przepierzenie dla kabli:
Przez otwory przepierzenia przejdą kable z przetwornicy. Będę je chował w przedniej części obudowy. Podzielę ją na dwie części tak, żeby “upchnięte” w nich kable zasilania i masy się nie zetknęły.
Na górnej pokrywce wyznaczyłem położenie wyświetlacza. Przerysowałem rozmieszczenie otworów z oryginalnej obudowy i wyciąłem otwór pod wyświetlacz w pokrywce:
Podobnie wyciąłem otwory na kable w dolnej części pokrywki oraz w panelu czołowym:
Teraz wyciąłem otwory na przełączniki:
Lewy przełącznik ma włączać zasilanie przetwornicy. Prawy – uruchamiać wyjście.
Przetwornica 2.0
Przetwornica musiała być trochę przerobiona. Zacząłem od wylutowania terminali:
Następnie do padów dolutowałem kable.
Składamy wszystko razem
Montaż wszystkiego okazał się nie taki trywialny. Zacząłem od przelutowania kabelków z koszyka na znacznie grubsze:
Umieściłem w obudowie koszyk na baterie i połączyłem go z wtykiem zasilającym.
Zastosowałem tu kostkę elektryczną. Podłączyłem do niej kabelki z pakietu oraz gniazda do ładowania pakietu.
W górną pokrywkę włożyłem przełączniki i przylutowałem do nich pierwsze kabelki.
Teraz podłożyłem wyświetlacz i przylutowałem resztę kabli między przetwornicą i wyłącznikami oraz do wyjścia:
Do zamontowania potencjometru najpierw musiałem dopasować płytkę PCB. Niewiele tu miejsca…
I zlutowana płytka z diodą sygnalizującą niski stan pakietu:
Integracja nie była łatwa…
W całkiem ostatnim kroku zamontowałem końcówki do kabli:
Galeria
Podsumowanie
Przedłużyło mi się trochę… Pomysł z zamianą przycisków na potencjometr znacznie skomplikował budowę zasilacza. Konieczne było przeprowadzenie wielu eksperymentów, jak i zbudowanie dodatkowych narzędzi (HVSP). W końcu wcale nie jestem pewien, czy nie lepiej było zbudować taką przetwornicą od podstaw i samemu sterować wyświetlaczem. Mimo wszystko sądzę, że…
Opłacało się!
Nauczyłem się naprawdę wiele:) No i bardzo poręczne narzędzie mi się udało.
Materiały
- Przetwornica mp2307,
- Koszyk na 4 akumulatory 18650, z akumulatorami,
- Przejściówka do ładowania: wtyk 2.1mm zasilający i gniazdo T (Redox) – dla ładowarki Redox Beta
- Przełączniki kołyskowe okrągłe,
- Kostka elektryczna,
- ATtiny85 z podstawką, jakaś przetwornica, która go zasili – ja użyłem pololu reg4b/3.3v
- Potencjometr 10k,
- Rezystory 10k, 47k,
- Diody 1n4748,
- Kawałek płytki PCB, wystarczy jednostronna,
- Śrubki fi2mm/10mm,
- Kable połączeniowe.
Dla tych, co się zniechęcają…
Nie zawsze wszystko idzie dobrze… Są taki dni, w które lepiej nie zaczynać roboty – o czym niestety dowiadujemy się zazwyczaj zbyt późno:) Ale gdy idzie źle – nie zniechęcajcie się! Osobiście wyznaję zasadę: lepiej coś skończyć – a potem poprawić, niż ciągle poprawiać, ale nigdy nie skończyć…
Przykłady? Cóż w relacji wszystko wyglądało naprawdę gładko…
Podczas robienia otworów w pokrywce po prostu źle obliczyłem miejsce wiercenia. Nie było wyboru – musiałem kawałek dalej zrobić nowe otwory.
Stary otwór zakołkowałem wykałaczką (i wikolem):
Ściąłem wykałaczkę, wyszlifowałem – a potem szlifierką zrobiłem wgłębienie na wykałaczce i wokół niej:
Czas na szpachlę:
Szpachli należy pozwolić porządnie wyschnąć. Później można ją zeszlifować. Po kłopocie.
Dodając kable do wyjścia z przetwornicy zapomniałem, że będę ich potrzebował trzech. Do tego jednego dołączyłem segment kostki elektrycznej. Z drugiej strony wyprowadziłem trzy kable:
Oczywiście, że wymierzyłem pudełko tak, żeby wszedł do niego koszyk na baterie. Wszystko dokładnie spasowałem. Niestety po włożeniu koszyka do obudowy (co nie poszło łatwo) okazało się… że ogniwa rozepchały ścianki koszyka i ostatnie z nich ledwo wepchnąłem. Nie było rady – trzeba było podszlifować ściankę wewnętrzną:
I kilka innych…
Źródła
- Wskaźniki rozładowania akumulatorów: tutaj i electro–hobby,
- Przyciski i ich symulowanie przez Arduino
- Regulatory PID
- 1023, 1024 – co do obliczania napięcia na ADC
- matplottolib – przykład, na którym oparłem swój kod do wykresów
- Odczyt napięcia zasilania na UNO
A co z balansowaniem ogniw? Nie widzę, żebyś sprawdzał napięcia indywidualnych ogniw, a na zdjęciu ładowania też nie masz połączeń potrzebnych do balansowania. W ten sposób prędzej, czy później co najmniej jedno ogniwo będziesz rozładowywał poniżej 3V,
Witam,
zgadza się – balansowanie pominąłem. Wiele razy ładowałem już takie pakiety i nigdy nie miałem z nimi problemów – dlatego tu sobie to też odpuściłem. Na szczęście wszystko jest rozbieralne, więc jak będzie potrzeba – mogę dokonać niezbędnych modyfikacji.
Pozdrawiam,
Arek
To jest tak, że nie ma potrzeby balansowania przez 1,2,3 ładowania, a przy 5 to jedna cela ma już poniżej 0V
Sprzedasz informacje co to za prezentacja?
Bo też czasami uczę elektroniki i poszukuję fajnych pomysłów na prezentację,
Witaj,
spójrz może na profil Labratorium Nowych Technologii na facebooku (zajęć, które prowadziłem w zeszłym roku) – może tam coś znajdziesz: https://www.facebook.com/lntcekdim/