Se afișează postările cu eticheta ATtiny85. Afișați toate postările
Se afișează postările cu eticheta ATtiny85. Afișați toate postările

sâmbătă, 25 ianuarie 2020

Tester pentru acumulatori LiPo 3S

   Lidiano (pippo), un cititor a-l blogului, m-a rugat sa ii scriu un program pentru un tester pentru acumulatori LiPo 3S dupa modelul celui de baterie auto cu ATtiny85, cel din articolul Indicator stare acumulator auto cu LED multicolor comandat de un ATtiny85(45)
   Am primit de la el un minim de "caiet de sarcini":
   Dupa ce am mai conversat pe email si m-am mai documentat, am desenat urmatoarea schema, pentru ledul lui RGB, cu anod comun:
partea de praguri fiind calculate pe o foaie de hartie:
   Aceste praguri, le-am transpus in programul RGB_LiPo3S_checker1a.ino, astfel:
adica
cu mentiunea ca la exista un mic histerezis de 3 biti pentru a aparea aprinderi intre stari.
   Schema, pentru led multicolor cu anod comun, redesenata in Eagle PCB si colorata in Paint arata asa:
Pentru led multicolor cu catod comun, schema este cea prezentata la inceputul articolului.
   Programul RGB_LiPo3S_checker1a.ino permite sa se foloseasca ori led cu anod comun
ori cu catotd comun
functie de ce linii se activeaza.
   Montajul realizat de Lidiano:
   Microcontrolerul trebuie sa fie setat pe 8MHz cu oscilator intern pentru a avea o animatie ca in filmuletul realizat de Lidiano numit Lipo 3S tester
   Pentru detalii despre programarea microcontrolerului ATiny85(45) cititi informatiile din articolul Programarea unui microcontroler ATtiny85 cu sketch Arduino.
    Lidiano a facut teste fizice si mi-a trimis si poze:
- tensiune prea mare pe acumulator
- acumulator complet incarcat
- acumulator incarcat
- acumulator incarcat suficient
- acumulator insuficient incarcat
- acumulator descarcat

luni, 26 noiembrie 2018

Folosire programator Tiny AVR

   Făcând rost, pentru teste, de un programator numit Tiny AVR ce este comercializat de Sparkfun, am zis sa îl probez rapid. Pentru a-l utiliza, am folosit imformaţiile oferite în articolul Tiny AVR Programmer Hookup Guide.
   Dupa introducerea programatorului într-o mufă USB primim un mesaj ca este un dispozitiv conectat, doar ca nu este instalat corect.
    Pentru sistemul de operare Windows 7 (pe 64 biţi), în CONTROL PANEL -> SYSTEM găsim informaţia
Descarcăm driverul de la https://github.com/sparkfun/Tiny-AVR-Programmer/tree/master/Drivers
se dezarhivează şi se actualizează driver-ul
şi vom avea un alt dispozitiv
   Am deschis programul Arduino IDE 1.8.5, unde am deja instalată partea de ATtiny25/45/85
alegând programatorul mai înainte instalat
   Pentru a avea placa de dezvoltare ATtiny25/45/85 în versiunea Arduino IDE 1.8.5 se intră la plăcile de dezvoltare si se caută ATtiny, instalandu-le, după cum mai prezentasem şi în alte articole anterioare.
   Am pus un ATtiny85 în soclu şi l-am programat
   Am făcut nişte filmuleţe, în care se vede modul simplu de utilizare în care am folosit programele (sketch-urile) postate pe https://github.com/tehniq3/ATtinyx5_test:
PS: recomand şi studierea articolului ATTiny Adventures: Exploring the Mysteries!

vineri, 21 iulie 2017

Programator pentru ATtiny25/45/85 cu Arduino Nano

   Pentru proiecte simple cu Arduino se pot folosi microcontrolere mai slabute cum sunt cele din seria ATtiny25/45/85, vedeti proiectele:
Indicator stare acumulator auto cu LED multicolor comandat de un ATtiny85(45)
Termometru dublu cu ATTiny85
ATtiny85 si senzorul de umiditate si temperatura DHT11
ATtiny85 si senzori de temperatura DS18B20
   Pentru programare se foloseste o placa Arduino (Nano in cazul meu, dar merge la fel si cu Uno), dupa cum am prezentat in articolul Programarea unui microcontroler ATTiny85 cu sketch Arduino.
   Nu mai repet modul de programare, ci voi prezenta schema unui montaj pentru programare, care se poate face pe cablaj, pentru a fi mereu la indemana:
   Fata de schema din articolul anterior, am mai pus si 3 leduri, care indica intrarea in modul de programare (led verde), "bataile inimii", adica comunicarea (led galben) si daca apare vreo eroare (led rosu).
   Cablajul cu piese ar arata asa
   Cablajul pentru metoda transferului de toner (prezentata in articolele Cum facem un cablaj (partea a 2-a) respectiv Cum facem un cablaj) se gaseste AICI !!!

PS: revin in curand cu poze ....

joi, 29 ianuarie 2015

ATtiny85 si senzori de temperatura DS18B20

   Dupa cum am scris in articolul precedent ( ATtiny85 si senzorul de umiditate si temperatura DHT11 ) pentru a putea folosi instructiuni care au legatura cu timpii, trebuie ca microcontrolerul ATtiny85 sa fie setat corespunzator si asta se face prin intercalarea unui pas ("scriere bootloader" prin setare placa de dezvoltare ca "ATtiny85 la 8MHz" si programator "Arduino ca ISP"). Acest pas trebuie facut o singura data, deoarece nu scrie cu adevarat un bootloader de Arduino, doar schimba un "fuse".
   Schema folosita pentru teste este:
iar real, e ceva de genul:
   Zona colorata cu galben e partea de stabilizare de 5v realizata cu LM7805, pentru a putea alimenta montajul de la un alimentator sau masina... daca se fac teste cu alimentator de 5V, acea parte poate lipsi.
   Pe ecran, cu 2 senzori DS18B20, am urmatoarele informatii:
   In filmuletul ATTiny85 si DS18B20 se vede si faptul ca ATtiny85 sesiszeaza si cati senzori de temperatura de tip DS18B20 sunt conectati la el. Senzorii DS18B20 se pun in paralel, cum am prezentat in articolul Mai multi senzori de tip DS18B20 (sau MAX31820) in paralel (2).
   Sketch-ul folosit de mine este:
/*
this sketch is adapted by niq_ro from
http://www.tehnic.go.ro
http://www.niqro.3x.ro
http://nicuflorica.blogspot.ro/
http://arduinotehniq.blogspot.com/
this sketch is made for use DS18B20 sensor(s) with ATtiny85 at 8MHz

 * 3-pin Arduino interface for HD44780 LCDs via 74HC595 Shift Register
 *     by Rowan Simms   code@rowansimms.com
 *     License: Creative Commons - Attribution.
 *     Full Documentation and Description:  http://rowansimms.com/article.php/lcd-hookup-in-seconds
 *
 * This sketch allows Arduinos to use a shift register to control an LCD, allowing 
 * a reduction in pins it requires from 6 to 3 while still retaining full control
 * including backlight on/off.
 * This requires the use of the LiquidCrystal595 library
 * available at: http://code.google.com/p/arduino-lcd-3pin/
 */

#include <LiquidCrystal595.h>    // include the library
LiquidCrystal595 lcd(0,1,2);     // datapin, latchpin, clockpin

#include <OneWire.h>
// http://www.pjrc.com/teensy/td_libs_OneWire.html
// http://milesburton.com/Dallas_Temperature_Control_Library
OneWire  ds(3);  // on phiscal pin 2  (a 4.7K resistor is necessary)  

byte grad[8] = {
  B01110,
  B10001,
  B10001,
  B01110,
  B00000,
  B00000,
  B00000,
};

int ics =0; //count number of sensor

void setup() {
    lcd.begin(16,2);             // 16 characters, 2 rows
 lcd.createChar(0, grad);

    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("Wow. 3 pins!");
    lcd.setCursor(0,1);
    lcd.print("Fabulous");
delay(2000);
lcd.clear();

  // Print a message to the LCD.
  lcd.setCursor(1, 0);
  lcd.print("temperatura in");
  lcd.setCursor(1, 1);
  lcd.print("mai multe zone");
  delay (2500);
  lcd.clear();
}


void loop() {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius;
  
  
  if ( !ds.search(addr)) {
    lcd.clear();   
    lcd.setCursor(0, 1);
    lcd.print("doar ");
    lcd.print(ics);
    lcd.print(" senzor(i)");    
    ds.reset_search();
    delay(250);
   ics=0;
    return;
  }
  
ics++; 

  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1);        // start conversion, with parasite power on at the end
  
  delay(1000);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.
  
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }
  // Convert the data to actual temperature
  // because the result is a 16 bit signed integer, it should
  // be stored to an "int16_t" type, which is always 16 bits
  // even when compiled on a 32 bit processor.
  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
  }

lcd.clear();
lcd.setCursor(0, 1);
  lcd.print("ROM=");
  for( i = 0; i < 8; i++) {
    lcd.print(' ');
    lcd.print(addr[i], HEX);
  }

  if (OneWire::crc8(addr, 7) != addr[7]) {
      lcd.print("CRC is not valid!");
      return;
  }

  celsius = (float)raw / 16.0;

  lcd.setCursor(0,0);
  lcd.print("Temp");
  lcd.print(ics);
  lcd.print(" = ");
  lcd.print(celsius);
  lcd.write(byte(0));
  lcd.print("C   ");
  
  delay(3000);
}