Był sobie pewien zasilacz... » Elektronika » poradnik zrób to sam na Majsterkowo.pl

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:

float voltage = (((float) analogRead(A0)  + 0.5 ) * 3.3 ) / 1023.0;

1	float voltage = (((float) analogRead(A0) + 0.5 ) * 3.3 ) / 1023.0;

Jeszcze lepiej stworzyć do tego funkcję:

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;
}

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:

#define DIVIDER_RATIO 5.818

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:

digitalWrite(0, LOW);
pinMode(0, OUTPUT);

1 2	digitalWrite(0, LOW); pinMode(0, OUTPUT);

Żeby go “puścić”:

digitalWrite(0, LOW);
pinMode(0, INPUT);

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:

//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();
    }
  }
}
//---------------------------------------------

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:

$ 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.

$ 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:

$ 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

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

Ocena: 4.88/5 (głosów: 8)

6 komentarzy do “Był sobie pewien zasilacz…”

pm7 11 grudnia 2016, godz. 11:26

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,
Odpowiedz
- Elektronika Bez Spięcia Autor 11 grudnia 2016, godz. 14:41
  
  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
  Odpowiedz
atomd 12 grudnia 2016, godz. 21:47

To jest tak, że nie ma potrzeby balansowania przez 1,2,3 ładowania, a przy 5 to jedna cela ma już poniżej 0V
Odpowiedz
atomd 13 grudnia 2016, godz. 17:02

Sprzedasz informacje co to za prezentacja?
Odpowiedz
- atomd 13 grudnia 2016, godz. 17:03
  
  Bo też czasami uczę elektroniki i poszukuję fajnych pomysłów na prezentację,
  Odpowiedz
  - Elektronika Bez Spięcia Autor 29 grudnia 2016, godz. 18:58
    
    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/
    Odpowiedz

Jak kłaść płytki podłogowe? 5 praktycznych wskazówek

Zasilanie, moc, moment obrotowy… Sprawdź, co musisz wiedzieć, wybierając wkrętarkę

RYOBI na święta. Wybieramy prezent dla majsterkowicza

Wieszak na klucze kategorii 5e

Frezarka CNC – Profesjonalne sterowanie amatorskimi maszynami. (LPT)

Jak Zrobić Teleskop. Amatorski teleskop dla początkujących. Teleskop Newtona Zrobiony w Domu.

Wzmacniacz lampowy DIY na ECL86 EM84

Sony wireless stereo headset w nowym wydaniu

AUDIOREAKTYWACJA czyli REMONT MAŁYCH TONSILI

Koparka – zabawka dla dziecka

Jak zrobić Skuter Elektryczny (350W dla dziecka)Z niezłym Kopem!

Powiadamianie o nowej poczcie z Arduino

Wieszak na klucze kategorii 5e

Psi zaprzęg dla dziecka.

Lampy ze starych megafonów

Frezarka CNC – Profesjonalne sterowanie amatorskimi maszynami. (LPT)

Jak Zrobić Teleskop. Amatorski teleskop dla początkujących. Teleskop Newtona Zrobiony w Domu.

Cloud for my Sunshine | Lampka dla dziecka DIY

Stanowisko do gier samochodowych na bazie arduino.

Zabezpieczenie gniazda 230V za pomoca Arduino Nano

Arduino – współpraca z projektorami NEC, EPSON

Smart listwa zasilająca

Asystent Google na Raspberry Pi

Czujnik Parkowania

Budowa zgrzewarki Li-ion

Smart listwa zasilająca

Disc VUmetr by hetm4n

Smart listwa zasilająca

Inteligentna listwa zasilająca – IoT

Raspberry Pi instalacja Domoticza – systemu inteligentnego domu

Supla.org Termometr z podwójnym pomiarem

SUPLA, Nodemcu v3, cztery gniazdka plus DHT22 plus sterowanie głosem (Google Home)

Monitoring temperatury przez internet: WEMOS D1 (esp8266) + SUPLA

Rejestrowanie wskazań liczników wody, gazu i prądu – opis trzech sposobów zliczania impulsów

Arduino – współpraca z projektorami NEC, EPSON

Tenso 2019 – czyli taka waga z Arduino, loggerem SD i wyświetlaczem na Androidzie

Stanowisko do gier samochodowych na bazie arduino.

Zasilacz uniwersalny 1,2V do 24V o mocy 120 W

Budowa zgrzewarki Li-ion

Black&Decker 18V Li-ion – wymiana ogniw

Telegraf

ZASILACZ POMOCNICZY

Renowacja zniszczonego parapetu- czyli mała rewolucja tuż przed remontem

Odbudowa zniszczonego stołu barowego

Ratowanie starego zniszczonego mebla, czyli renowacja DIY

Otis’owe legowisko. Legowisko dla psa

Ramka z mosiężnymi wstawkami

Biurko z rurek i desek paletowych

Krzesełko dla dziecka. Jak odnowić

Samolot z drewna – prosty model z patyczków do lodów.

Mikołaj z orzecha

Niebanalny Regał Z Drzewem

Otis’owe legowisko. Legowisko dla psa

Tablica „ORGANIZER”

Lampka nocna. Rakieta Saturn V

DaVinci PRO – Tuning Sprzętu

Łatwy do druku uchwyt na komputer rowerowy.

Drukarka Prusa i3 MK3 – rozwiązanie problemu z ekstruderem

DaVinci PRO – Tuning Sprzętu

Łatwy do druku uchwyt na komputer rowerowy.

Drukarka Prusa i3 MK3 – rozwiązanie problemu z ekstruderem

DaVinci PRO – Tuning Sprzętu

Konfigurowanie MKS Gen L, czyli przesiadka elektroniki drukarki 3D (część 1/2)

Wersja pierwsza: prowizorka

Wersja 2.0

Zasilanie 2.0

Przyciski 2.0, czyli potencjometr

UNO R3

AtTiny85

Monitorowanie napięcia baterii – v2.0

Program dla AtTiny85

Obudowa 2.0

Przetwornica 2.0

Składamy wszystko razem

Galeria

Podsumowanie

Materiały

Dla tych, co się zniechęcają…

Źródła

Inteligentne sterowanie światłem w mieszkaniu