High Power RGB Lamp 1.0 – Lampada RGB LED con Arduino (mini pro) e LED strip RGB

Pubblicato da Luca Soltoggio in 19 marzo 2012
Pubblicato in: Circuiti, Progetti Arduino. Tag: , , , , , , , . 81 commenti

Finalmente dopo una lunga assenza, in cui ero immerso nella realizzazione finale di questo mio progetto, CE L’HO FATTA!!!
Dopo mesi di progettazione, studi, ricerche e ostacoli vari, la RGB LED Lamp 1.0 by Toggio è realtà.
Posto subito il video che mostra il risultato definitivo ottenuto:

Ed ora una breve cronistoria.
Una delle cose che mi ha attirato di più quando ho sentito parlare di Arduino, era la luce, e in particolar modo ho sempre avuto il sogno di realizzare una lampada a LED RGB.
Niente di difficile, si potrebbe pensare… Solo che lungo questo percorso ho trovato diversi ostacoli.
Innanzitutto non ho trovato progetti completi in rete… Si trova qualcosa, ma, a mio avviso, con algoritmi fatti male, con poche spiegazioni, con metodi elaborati.
Io volevo una cosa semplice da regalare alla persona che amo e che mi ha dato una bellissima figlia…
Volevo qualcosa che avesse una luce abbastanza potente, senza però scaldare troppo. Volevo qualcosa che avesse la possibilità di scegliere il colore e non una semplice “color cycler”. Volevo qualcosa che fungesse anche da lampada standard. Ed infine volevo qualcosa che fosse modulare e upgradabile in futuro.
Dopo queste riflessioni, ho cominciato a studiare innanzitutto l’hardware. Non volevo usare l’Arduino UNO perchè mi sembrava eccessivamente grande per il mio progetto. Ho deciso quindi (e qui si potrebbe aprire un’enorme parentesi) di utilizzare una board non tanto diffusa ma a mio avviso eccezionale (tant’è che ne ho comprate 4 o 5): la Arduino Mini Pro.
(Resta inteso che nel progetto di questo post, può essere tranquillamente sostituita con una UNO o qualsiasi altra Arduino board.)
E’ una board estremamente piccola (18mm x 33mm), compatibile al 100% con Arduino Dumilanove, e a basso consumo. Esiste in quattro versioni: con Atmega328 a 3.3V e 5V e con Atmega168 a 3.3 e 5V.
Ho quindi optato per questo progetto per la versione a 5V con Atmega168. In definitiva si tratta di una soluzione molto economica (costa circa la metà dell’Arduino UNO), alquanto compatta e bella da vedere.
Ho poi pensato di utilizzare  delle comodissime Strip LED RGB, che offrono numerosi vantaggi rispetto ad utilizzare led di potenza a 1W o a 3W: non scaldano, si alimentano a 12V e offrono una potenza fino a 13-14W per metro lineare.
Ogni canale può essere alimentato da un’uscita PWM di Arduino tramite un semplice transistor (nel mio caso ho usato dei BC337, ma per potenze superiori si possono usare altri transistor o addirittura dei Mosfet).
Ho quindi provveduto a costruire una specie di shield per la mia board. In pratica ho realizzato un circuito in cui la Arduino Mini Pro possa inserirsi con dei connettori strip ed essere eventualmente rimossa per aggiornare il firmware. Il tutto è stato progettato con Fritzing e realizzato da Fritzing Fab.
Il risultato finale del circuito stampato è il seguente:

Si possono notare le due file di fori dove andrà montata la Mini Pro… Praticamente è una shield al contrario 🙂
Ma facciamo un passo indietro e vediamo lo schema di circuito:

Spero sia abbastanza chiaro anche se non l’ho disegnato proprio benissimo!
In ogni caso il funzionamento è il seguente: I due potenziometri da 10k posti tra i +5V e la massa, sono i due input analogici che permettono di regolare la luminosità e altri parametri stabiliti dal software. Il deviatore a 3 posizioni SW2, permette di selezionare tre funzioni diverse per la lampada. Le uscite digitali 3,5,6 vanno a pilotare tramite un resistore i 3 transistori BC337 che andranno a dare corrente alle 3 uscite negative R,G,B della striscia a LED. Il positivo comune va ai +12V, mentre l’Arduino è alimentato tramite porta RAW (ingresso da 7V a 13V) tramite un diodo che oltre a fornire protezione da eventuale inversione di polarità, abbassa leggermente la tensione. SW1 è semplicemente il ponte dove andrà collegato un normalissimo interuttore di accensione.
Una volta saldati i vari componenti, connettori e potenziometri, montato il circuito, incapsulata la board Arduino, e montato il tutto dentro una scatola da elettricista, il risultato è quello della foto seguente:

La dimensione della scatola è di circa 10cmx10cmx7cm.
Per la parte superiore, ho utilizzato circa 70cm di striscia led RGB, per una potenza totale di circa 10W. Per farla stare tutta l’ho arrotolata intorno al perno di supporto di una campana da CD. Ho tagliato con un taglierino tale perno e l’ho incollato con dei distanziatori sopra la scatola. Ho poi incollato con della colla a caldo la striscia a led avvolgendola sul perno… Insomma un lavoro un po’ artigianale ma il risultato alla fine è il seguente:

Il vetro che si vede sulla scrivania leggermente spostato rispetto alla lampada, è il pezzo finale che manca: la copertura in vetro di una lampada IKEA, opportunamente fatta tagliare da un vetraio locale, affinché rimanga vuota sui due lati. Questa coperturà verrà infine appoggiata sopra la scatola da elettricista ed incollata, ottenendo il seguento risultato:

Mica male vero?
Ovviamente manca ancora la ciliegina sulla torta, una parte non meno importante: il software.
Il codice autoesplicativo è il seguente:

/*
RGB Led Lamp 1.0a
by Luca Soltoggio
15/03/2012
https://arduinoelettronica.wordpress.com/
*/

int rpin = 3;   // pin RED
int gpin = 5;   // pin GREEN
int bpin = 6;   // pin BLU
unsigned int r=0, g=0, b=0,bm=0;   // valori rgb e coefficiente divisore del blu
unsigned int valh=0, vals=0, valv=0;   // hue, saturation, value
unsigned int sensorValue;  // variabile che memorizza il valore dei potenziometri

const int analogInPin = A0;  // pin dei potenziometri
const int analogInPin2 = A1;
const int digitalInPin = 10;  // pin del deviatore
const int digitalInPin2= 11;

int red[]={255,255,135};  // array con i valori RGB della funzione "Bianco"
int green[]={157,255,158};
int blue[]={51,255,255};

boolean DIG1, DIG2;

long previousMillis = 0;

int i=0,j=0;
int dl=0;  // delay

void setup()
{
  pinMode(digitalInPin,INPUT);
  pinMode(digitalInPin2,INPUT);
}

void loop()
{
  DIG1=digitalRead(digitalInPin);
  DIG2=digitalRead(digitalInPin2);

  if (DIG1) {
    bm=1.1;
    HSV_Game();
  }
  else if (DIG2) {
    bm=1.9;
    RAINBOW_Game();
  }
  else {
    bm=2.4;
    LIGHT_Game();
  }

  analogWrite(rpin, r/1.09);  // ROSSO
  analogWrite(gpin, g/1);  // VERDE
  analogWrite(bpin, b/bm);  // BLUE
}

// funzione di armonizzazione dei valori analogici tramite media aritmetica
int SensorSmooth (int pin) {
  sensorValue=0;
  for (int i = 0; i<10; i++) {     sensorValue+= analogRead(pin);   }   return int ((float)sensorValue/10+0.5); } // prima funzione: selezione del colore e della luminosità tramite potenziometri void HSV_Game() {   valh = SensorSmooth(analogInPin);   vals = 255;   valv = SensorSmooth(analogInPin2);   valh = map(valh,0,1023,0,359);   valv = map(valv,0,1023,32,255);   hsv2rgb(valh,vals,valv,r,g,b); } // seconda funzione: selezione di bianco caldo, bianco neutro e bianco freddo, oltre alla luminosità void LIGHT_Game() {   valv = SensorSmooth(analogInPin2);   valv = map(valv,0,1023,16,255);   valh = SensorSmooth(analogInPin);   if (valh=742) valh=2;   if (valh>2) valh=1;
  r=red[valh]*valv/255;
  g=green[valh]*valv/255;
  b=blue[valh]*valv/255;
}

// terza funzione: selezione della velocità di rotazione tra tutti i colori e della luminosità
void RAINBOW_Game() {
  dl = SensorSmooth(analogInPin); // tempo di pausa
  dl = map(dl,0,1023,1,100);
  valv = SensorSmooth(analogInPin2);
  valv = map(valv,0,1023,64,255);
  unsigned long currentMillis = millis();
  switch (j) {
    case 0:
      r=255*valv/255;
      g=i*valv/255;
      b=0*valv/255;
      break;
    case 1:
      r=(255-i)*valv/255;
      g=255*valv/255;
      b=0*valv/255;
      break;
    case 2:
      r=0*valv/255;
      g=255*valv/255;
      b=i*valv/255;
      break;
    case 3:
      r=0*valv/255;
      g=(255-i)*valv/255;
      b=255*valv/255;
      break;
    case 4:
      r=i*valv/255;
      g=0*valv/255;
      b=255*valv/255;
      break;
    case 5:
      r=255*valv/255;
      g=0*valv/255;
      b=(255-i)*valv/255;
  }
  if (currentMillis-previousMillis > (long)(100-dl)) {  // usa millis invece che delay
    previousMillis=currentMillis;
    i=i+1;
    if (i==256) {
      i=1;
      j=j+1;
      if (j==6) j=0;
    }
  }
}

/* Funzione che trasforma HSV in RGB
(c) Elco Jacobs, E-atelier Industrial Design TU/e, July 2011
http://code.google.com/p/shiftpwm/source/browse/trunk/examples/ShiftPWM_Example1/hsv2rgb.cpp?r=3
*/
void hsv2rgb(int hue, int sat, int val, unsigned int& r, unsigned int& g, unsigned int& b)
{
    int H_accent = hue/60;
    int bottom = ((255 - sat) * val)>>8;
    int top = val;
    int rising  = ((top-bottom)  *(hue%60   )  )  /  60  +  bottom;
    int falling = ((top-bottom)  *(60-hue%60)  )  /  60  +  bottom;

    switch(H_accent) {
        case 0:
                r = top;
                g = rising;
                b = bottom;
        break;

        case 1:
                r = falling;
                g = top;
                b = bottom;
        break;

        case 2:
                r = bottom;
                g = top;
                b = rising;
        break;

        case 3:
                r = bottom;
                g = falling;
                b = top;
        break;

        case 4:
                r = rising;
                g = bottom;
                b = top;
        break;

        case 5:
                r = top;
                g = bottom;
                b = falling;
        break;
    }
}

La pagine Fritzing del progetto (dove è possibile anche scaricare il codice sorgente) la trovate qui:
http://fritzing.org/projects/high-power-rgb-lamp-10-with-arduino/

Alla prossima!!!

ISArduino – Micro Robot Inseguitore solare con Arduino

Pubblicato da Luca Soltoggio in 29 febbraio 2012
Pubblicato in: Arduino, Progetti Arduino. Tag: , , , , , , . 77 commenti

Ecco qui un semplice inseguitore solare, realizzato con Arduino…
E’ solo una bozza, uno spunto da migliorare per creare nuovi progetti.
L’idea è molto semplice. Utilizzando due fotoresistenze (LDR), una che punta leggermente verso destra e l’altra leggermente verso sinistra, andiamo a leggerne i valori e muoviamo un servo a rotazione continua nella direzione della fotoresistenza che riceve più luce, finchè la luminosità non è circa uguale.
Il risultato finale è quello che vediamo nel seguente video:

Come potete vedere ho utilizzato Arduino Mini Pro come piattaforma, ma non cambia assolutamente nulla rispetto all’utlizzo con Arduino UNO. L’unica differenza è che nell’alimentare l’Arduino Pro Mini ho dovuto usare un regolatore esterno, perchè quello interno non è sufficiente per pilotare il servo.
Ma veniamo all’elenco dei materiali necessari:
1 – Una board Arduino UNO (o Duemilanove o qualsiasi altra board compatibile)
2 – Due fotoresistenze LDR da 20K (eventualmente con pochi aggiustamenti possono andare bene anche di altri valori)
3 – Due resistenze da 4.7K (eventualmente con condizione di luce differenti si possono usare valori differenti)
4 – Un servo a rotazione continua. (Difficili e/o costosi da trovare, ho modificato un servo standard seguendo le indicazioni che trovate a  uno di questo link (http://www.gioblu.com/tutorials/azionamenti/188-modifica-rotazione-continua-microservi oppure http://robodroid.wordpress.com/2011/12/29/micro-servo-a-rotazione-continua/ oppure ancora http://www.robot-italy.com/article_info.php?articles_id=1)
5 – Una batteria da 9V, una breadboard, dei supporti di plastica e poco altro

I componenti vanno collegati nel seguente modo ad Arduino:

Come vedete il tutto è molto molto semplice.
Se volete scaricare il file in formato fritzing, questo è il link.
http://fritzing.org/media/fritzing-repo/projects/i/isarduino-micro-robot-inseguitore-solare-con-ardui/fritzing/ISArduino.fzz
Veniamo ora al codice che è il seguente:

/*
ISArduino 0.1
Inseguitore Solare con Arduino
by Luca Soltoggio - 2012
https://arduinoelettronica.wordpress.com
*/

#include <Servo.h> 
#include <Narcoleptic.h>
/* 
Libreria che permette di mandare in standby il microcontrollore
nei momenti di inattività (delay), risparmiando parecchia energia.
Si può eventualmente anche non utilizzare (in tal caso va sostituita
l'ultima istruzione Narcoleptic.delay(15) con delay(15).
*/
 
Servo myservo;
int Value;
int Center=105; 
/*
La variabile Center rappresenta il valore di centratatura
del servo a rotazione continua. Nel mio caso è 105, di solito è 90. 
Con questo valore il servo deve restare fermo.
*/

void setup() { 
  Serial.begin(9600);
  myservo.attach(9); // Collega il servo al PIN 9
}

void loop() {
  int sensorValue = analogRead(A0);  // Legge il valore del sensore LDR di sinistra
  int sensorValue2 = analogRead(A1); // Legge il valore del sensore LDR di destra
  
  Value=(sensorValue-sensorValue2)/10;  
  /* 
  Calcola la differenza tra i due sensori e li divide per 10, 
  in questo modo una differenza di 10 equivale a 1, una differenza
  di 53 equivale a 5 e cosi via
  */
  
  if (Value==0) myservo.detach(); else myservo.attach(9); 
  /* 
  Se la differenza è uguale a 0 scollega il servo altrimenti lo 
  collega (serve per risparmiare energia)
  */
  
  if (Value>10) Value=10; 
  if (Value<-10) Value=-10;
  /* 
  Limita la differenza massima tra -10 e + 10
  (per evitare una velocità eccessiva)
  */
  
  Serial.println(Value); // Debug - Visualizza il valore sulla seriale
  myservo.write(Center+Value); 
  /* 
  Se il valore di Value è positivo, sposta il Servo a DX, se è negativo a SX.
  La velocità è direttamente proporzionale al valore assoluto di Value
  */
  
  Narcoleptic.delay(15);
  /* 
  Invece che usare un semplice delay, usiamo questo, così risparmiamo energia.
  Si può eventualmente sostituire con delay(15).
  */
}

Anche il codice è molto semplice ed autoesplicativo, quindi non mi dilungo più di tanto.
Se volete scaricare lo sketch per Arduino, lo trovate qui:
http://fritzing.org/media/fritzing-repo/projects/i/isarduino-micro-robot-inseguitore-solare-con-ardui/code/inseguitore_solare.ino

Qui di seguito trovate invece il link alla pagina Fritzing del progetto:
http://fritzing.org/projects/isarduino-micro-robot-inseguitore-solare-con-ardui/

Programmare l’Attiny85 (o Attiny45, Attiny84, Attiny25, Attiny2313) con Arduino

Pubblicato da Luca Soltoggio in 19 febbraio 2012
Pubblicato in: Arduino, Programmazione Arduino. Tag: , , , , , , , , , . 10 commenti

Eccoci dunque a questo tanto atteso post.
In questo articolo vedremo come programmare alcuni Atmel della famiglia Attiny, in particolare quelli evidenziati nel titolo, utlizzando le librerie Arduino e Arduino Uno come ISP. Ovviamente il tutto può essere fatto anche utilizzando un programmatore dedicato, ma qui non mi soffermo su questo argomento più di tanto in quanto le differenze sono minime.
Partiamo da una premessa: sull’Attiny non andiamo a caricare il bootloader, ma procediamo ad un caricamento degli sketch direttamente nella memoria del microcontrollore. Quindi questa è una prima differenza rispetto agli Atmega328. Esistono forse cercando qua e là alcuni bootlaoder anche per Attiny, ma non ha molto senso montarli per diversi motivi. Il primo è l’esigua memoria che hanno questi microcontrollori (8kb per l’Attiny85 rispetto ai 32kb dell’Atmega328). In secondo luogo la maggior parte degli Attiny non hanno la seriale hardware, quindi non avrebbe senso montare un bootloader se poi non ci serve a fare l’upload via seriale.
Vediamo ora i vantaggi dell’Attiny85 rispetto all’Atmega328:
1 – minore consumo elettrico (quindi adatto per progetti a batteria)
2 – minore dimensione (l’Atmega328 ha 28 piedini, mentre l’Attiny85 ne ha solo 8)
3 – minor costo
Ovviamente presenta lo svantaggio che avendo meno piedini abbiamo un numero limitato di I/O rispetto ai fratelli maggiori.
Per quanto riguarda la programmazione è molto simile a quella vista nel post precedente e in quello prima ancora.
Vediamo innanzitutto la piedinatura dell’Attiny85 che useremo come esempio in questo articolo:

Mentre dal punti di vista di Arduino:

                             +-\/-+
    Ain0       (D  5)  PB5  1|    |8   VCC
    Ain3       (D  3)  PB3  2|    |7   PB2  (D  2)  INT0  Ain1
    Ain2       (D  4)  PB4  3|    |6   PB1  (D  1)        pwm1
                       GND  4|    |5   PB0  (D  0)        pwm0
                             +----+

Quindi se voglio usare il PIN6 come uscita digitale userò pinMode(1,output) e se volessi leggere l’ingresso analogico dal PIN3 userò analogRead(A2).
Ovviamente anche qui come in arduino possiamo usare gli ingressi analogici come uscite digitali.
La seriale hardware non esiste come dicevamo, ma possiamo utlizzare il PIN2 (PB3) come seriale software monodirezionale. Praticamente usando i comandi standard di arduino tipo Serial.begin(9600), sul PIN2 abbiamo il segnale di TX, collegabile all’RX di un convertitore USB-SERIALE per comunicare dall’Attiny verso il PC, quindi è come se avessimo una “seriale in sola lettura”.
Ma veniamo alla pratica: rispetto alla programmazione dell’Atmega328, la programmazione dell’Attiny richiede la modifica e/o l’aggiunta di alcune librerie all’IDE.
Consiglio di usare la versione 0023 dell’IDE, scaricabile dal sito di Arduino (con altre versioni non sono riuscito), e di creare una cartella apposita separata da usare unicamente per la programmazione degli Attiny.
Quindi se abbiamo già Arduino (ad esempio sotto la cartella c:\Arduino), andremo a creare una nuova cartella che chiameremo ad esempio c:\Arduino-Tiny.
Fatto questo dobbiamo andare a scaricare il core arduino-tiny-0022-0009.zip, che trovate qui, poi dobbiamo scaricare la libreria PinChangeInterrupt-0001.zip che troviamo qui e infine la libreria TinyTuner-0003.zip che trovate qui. Il primo files lo scompattate così com’è dentro la cartella hardware (es.: c:\Arduino-Tiny\hardware). Vi chiederà di sovrascrivere alcuni files. Ditegli di si senza problemi. Le altre due librerie le scompattate sotto la cartella libraries (es.: c:\Arduino-Tiny\libraries). A questo punto dovrebbe essere tutto apposto. Potete eseguire l’upload dei vostri esempi usando il seguente schema:

Praticamente è come per l’Atmega328. Il pin 10 va collegato al RESET, e i pin 11, 12, 13 ai pin MOSI, MISO, SCK (cioè in questo caso 5, 6, 7), più ovviamente l’alimentazione.
Ricordatevi come sempre di inserire il condensatore da 22uF tra GND e RESET dell’Arduino UNO altrimenti la board si resetterà e l’upload non funzionarà generando un errore di sincronizzazione!!!
A questo punto aprendo dil nostro IDE, e aprendo uno sketch di esempio possiamo selezionando Tools –> Boards –> Attiny85 @1Mhz e poi File –> Upload to I/O Board.
Vi darà un errore di tipo “PAGEL”, ma si può ignorare. Vedrete il messaggio “Done Uploading” che vi avviserà che tutto è andato a buon fine.
Come vedete è molto semplice.
Gli Attiny escono di fabbrica con i fuse impostati in maniera tale che il microcontrollore utilizzi l’oscillatore interno a 1Mhz. E’ l’opzione migliore per la maggior parte dei progetti, ma se aveste bisogno di una velocità maggiore si può programmare l’Attiny in maniera tale che utilizzi il proprio oscillatore interno a 8Mhz oppure utlizzando un oscillatore esterno a 16Mhz (vedi post precedenti). Se vogliamo cambiare velocità al nostro Attiny, utlizzando as esempio l’oscillatore interno a 8Mhz, dobbiamo settare i fuse, facendo un’upload di un bootloader vuoto, contenente solo i settaggi che ci interessano. Per fare ciò è sufficiente selezionare da Tools –> Boards il settaggio che ci interessa (ad esempio Attiny85 @ 8Mhz), e poi Tools –> Burn bootloader —> w/Arduino as ISP.
A questo punto probabilmente vi darà il seguente errore:

avr_read(): error reading address 0x0000
read operation not supported for memory "lock"
avrdude: failed to read all of lock memory, rc=-2

Errore dovuto al fatto che manca nel file c:\Arduino-Tiny\hardware\tools\avr\etc\avrdude.conf la riga che riguarda l’operazione memory lock.
Quindi andiamo ad editare tale file e aggiugiamo la seguente riga:

read            = "0 1 0 1  1 0 0 0  0 0 0 0  0 0 0 0",
                  "0 0 0 0  0 0 0 0  o o o o  o o o o";

Nella sezione dell’Attiny85 sotto la riga memory “lock” che dovrebbe apparire così dopo la modifica:

#   ATtiny85 has Signature Bytes: 0x1E 0x93 0x08.
     memory "signature"
         size            = 3;
         read            = "0  0  1  1   0  0  0  0   0  0  0  x   x  x  x  x",
                           "x  x  x  x   x  x a1 a0   o  o  o  o   o  o  o  o";
       ;
     memory "lock"
         size            = 1;
         write           = "1 0 1 0  1 1 0 0  1 1 1 x  x x x x",
                           "x x x x  x x x x  1 1 i i  i i i i";
         read            = "0 1 0 1  1 0 0 0  0 0 0 0  0 0 0 0",
                           "0 0 0 0  0 0 0 0  o o o o  o o o o";
        min_write_delay = 9000;
        max_write_delay = 9000;
       ;

Ora eseguendo l’operazione di bootloader dovrebbe andare.
Se vogliamo possiamo andare a sistemare anche il problema del messaggio “PAGEL”  aggiungeno le seguenti righe:

     pagel            = 0xB3;
     bs2              = 0xB4;

Sotto la riga chip_erase_delay = 4500; nella sezione relativa all’Attiny85. In questo modo dovrebbe apparire così dopo le modifiche:

#------------------------------------------------------------
# ATtiny85
#------------------------------------------------------------

part
     id            = "t85";
     desc          = "ATtiny85";
     has_debugwire = yes;
     flash_instr   = 0xB4, 0x02, 0x12;
     eeprom_instr  = 0xBB, 0xFF, 0xBB, 0xEE, 0xBB, 0xCC, 0xB2, 0x0D,
                     0xBC, 0x02, 0xB4, 0x02, 0xBA, 0x0D, 0xBB, 0xBC,
                     0x99, 0xE1, 0xBB, 0xAC;
## no STK500 devcode in XML file, use the ATtiny45 one
     stk500_devcode   = 0x14;
##  avr910_devcode   = ?;
##  Try the AT90S2313 devcode:
     avr910_devcode   = 0x20;
     signature        = 0x1e 0x93 0x0b;
     reset            = io;
     chip_erase_delay = 4500;
     pagel            = 0xB3;
     bs2              = 0xB4;

     pgm_enable       = "1 0 1 0  1 1 0 0    0 1 0 1  0 0 1 1",
                        "x x x x  x x x x    x x x x  x x x x";

In questo modo l’errore è corretto ma solo sull’Attiny85. Per risolvere il problema anche per gli altri microcontroller, qui vi ho dato uno spunto. Fate eventualmente una ricerca su google con l’errore che vi è apparso durante l’upload del bootloader.
Potrebbe verificarsi un’ulteriore errore (non ricordo la dicitura) quando fate l’upload di sketch molto grossi.
In questo caso so che era legato ad un bug dell’avr-gcc, e per risolvero bisogna scaricare il tools Winavr, installarlo, e copiare il contenuto della cartella c:\WinAvr\tools\ in c:\Arduino-Tiny\hardware\tools\ sostituendo tutti i files presenti (eccetto il file avrdude.conf precedentemente modificato).
Questa ultima parte è un po’ più complessa, ma vedrete che se seguirete tutto alla lettera non sarà difficile.
Al prossimo post allora!!!

Atmega328 standalone senza il bootloader di Arduino

Pubblicato da Luca Soltoggio in 10 febbraio 2012
Pubblicato in: Arduino, Programmazione Arduino. Tag: , , , , , , , . 8 commenti

Nel post precedente abbiamo visto come programmare il bootloader di Arduino su un Atmega328 standalone, mentre in un’altro post abbiamo visto come effettuare l’upload degli sketch sul microcontrollere con bootloader Arduino.
In questo post vogliamo invece evidenziare quella che a mio parere è l’obiettivo finale dei progetti prototipizzati con Arduino: programmare l’Atmega328 senza bootloader, in maniera tale da sovrascrivere con i nostri sketch completamente la memoria del microcontrollore.
Ma per quale motivo dovremo farlo? I principali vantaggi sono l’esecuzione immediata del nostro programma all’accensione dell’Atmega e maggiore spazio a disposizione per i nostri programmi nella memoria del microcontrollore. Lo svantaggio è dato dal fatto che non è più possibile programmarlo tramite semplice seriale (a meno di ricaricargli il bootloader), ma occorre utilizzare un programmatore dedicato (o un ArduinoISP) e il tempo di upload dello sketch e parecchio più lungo. Consiglio quindi di utilizzare eventualmente questa modalità solo a progetto finito, mentre di utilizzare il bootloader di Arduino quando stiamo facendo il debug dei nostri programmi (quindi upload continui).
Ma veniamo alla pratica. La programmazione si attua nella stessa modalità del post precedente, con una piccola modifica. Dobbiamo editare il solito file boards.txt ed aggiungere la  riga xxxxxxx.upload.using=arduino:arduinoisp nella configurazione della board che ci interessa programmare, dove xxxxxxx corrisponde al nome della board. Facciamo un’esempio pratico, prendiamo la configurazione da inserire nel file boards.txt che abbiamo visto l’altra volta per l’Atmega a 8Mhz, con questa nuova aggiunta diventerebbe così:

##############################################################

atmega328bb.name=ATmega328 on a breadboard (8 MHz internal clock)

atmega328bb.upload.protocol=stk500
atmega328bb.upload.maximum_size=32768
atmega328bb.upload.speed=57600
atmega328bb.upload.using=arduino:arduinoisp

atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0x05
atmega328bb.bootloader.path=arduino:atmega
atmega328bb.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F

atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
atmega328bb.build.core=arduino:arduino

##############################################################

Con questa aggiunta specifichiamo che l’upload dello sketch non deve andare a finire sulla nostra Arduino UNO, ma sull’Atmega che vogliamo programmare.
Da notare anche la modifica (opzionale) di atmega328bb.upload.maximum_size il cui valore diventa 32768. Praticamente è lo spazio massimo in byte a disposizione per caricare il nostro sketch. Non essendoci più il bootloader lo spazio liberato rimane a nostra disposizione.

1 – Carichiamo tramite la IDE (versione 0022) lo sketch d’esempio ArduinoISP sulla nostra Arduino UNO
2 – Spegniamo il tutto e poi colleghiamo un condensatore da 22uF tra il RESET e il GND di Arduino UNO
3 – Colleghiamo il pin 10 di Arduino UNO al pin di RESET dell’Atmega e i pin 11,12,13 ai pin 17,18,19 del microcontrollore (o ai pin 11,12,13 di un’altra board Arduino) come nella figura:

4 – Eseguiamo l’upload dello sketch usando il comando tradizionale File –> Upload to I/O board

E il gioco è fatto… Abbiamo programmato il microcontrollore per lavorare in standalone senza bootloader Arduino e senza (o quasi) componenti esterni.
Come  vedete è molto semplice e ci permette non solo di programmare gli Atmega328 standalone, ma anche una scheda Arduino completo.
Ad esempio io utilizzo questo sistema con le Arduino Mini Pro. Sono schede economiche, che hanno praticamente tutte le funzionalità della Arduino UNO, ma sono molto piccole. Di solito invece che utilizzare un Atmega328 in standalone all’interno di un progetto ben definito, utilizzo queste piccole schedine, e una volta che il tutto è pronto per essere inscatolato, gli faccio l’upload dello sketch bypassando il bootloader, in particolare modo per renderlo più veloce all’accensione.
Le scheda Arduino Mini Pro è prodotta da Sparkfun ed è disponibile a 3,3V, 5V e con Atmega168 e Atmega328. Io consiglio se gli sketch non superano i 16kB di utilizzare l’Atmega168 e di usare la versione 8Mhz a 3,3V soprattutto se il vostro progetto funziona a batteria perchè consuma parecchio meno.
Ovviamente in fase di programmazione dovremo selezionare la scheda corrispondente dall’elenco delle boards, ad esempio Arduino Pro or Pro Mini (5V, 16 MHz) w/ ATmega168.
Ma il bello non finisce qui…
Con questo sistema possiamo programmare anche gli Attiny, i fratelli minori degli Atmega. Ne esistono diverse versioni ma i più interessanti sono gli Attiny85 a 8 piedini e l’Attiny2313 a 20 piedini. Hanno il vantaggio che consumano pochissimo, sono più piccoli e più economici.
L’Attiny85 ha solo 5 I/O, ma per tanti progetti va più che bene, considerando anche il costo di circa 2,50 € in Italia.
Inoltre lavorando con clock interno ad 1Mhz il consumo è veramente bassissimo, e la dimensione è come quella di un NE555.
Pensate quindi quanti progetti che possiamo semplificare utlizzando gli Attiny. Anche solo per esempio un controllo PWM di una striscia LED, che richiederebbe operazionali, condensatori, NE555 ecc. con un semplice Attiny85, un potenziometro, un transistor, pochissimi altri componenti e 2 righe di codice, il gioco è bello che fatto…
Al prossimo post allora!

Caricamento bootloader su Arduino standalone – Arduino UNO ISP

Pubblicato da Luca Soltoggio in 7 febbraio 2012
Pubblicato in: Arduino, Programmazione Arduino. Tag: , , , , , , , , , , , . 16 commenti

Nel post precedente abbiamo visto come programmare un Arduino in modalità standalone.
Uno dei requisiti era quello che il bootloader fosse già precaricato.
Ma se avessimo un Atmega328 vergine, oppure volessimo programmare il nostro micro per essere utlizzato senza un oscillatore esterno come dobbiamo fare?
Se abbiamo già un programmatore AVR, la cosa è semplicissima, e non la descrivo qui, anche perchè non tutti possediamo tale accessorio.
Vediamo quindi come usare la nostra Arduino UNO come programmatore ISP.
Si dice che con la UNO non sia possibile ma in realtà con un piccolo escamotage, è possibile bypassare il problema.
Non scoraggiatevi se ci sono problemi di sincronizzazione durante l’upload del bootloader, per ogni problema c’è la soluzione… ma vediamo la procedura.
Per prima cosa consiglio vivamente di utlizzare la versione 0022 dell’IDE di Arduino. Con la versione 1.0 sono riuscito saltuariamente e con difficolta.
Consiglio quindi di tenere le due installazioni del software installate. In una cartella la 1.0 e in un’altra la 0022. Possono coesistere entrambe senza darsi fastidio più di tanto l’una con l’altra.
Apriamo quindi l’IDE 0022 a carichiamo dai file di esempio lo sketch ArduinoISP. Questo esempio permette di trasformare la nostra board in un programmatore AVR. Una volta che l’upload è stato eseguito possiamo collegare la nostra UNO secondo il seguente schema:

Dobbiamo quindi collegare come in figura il pin 10 della UNO al pin RESET dell’Atmega, e i pin 11, 12, 13 ai pin 17, 18, 19 del microcontroller (o ai pin 11, 12, 13 di un’altra board Arduino).
Nello schema non è segnato, ma prima di procedere oltre dobbiamo assolutamente collegare un condensatore da 22uF tra il GND e il RESET della board Arduino altrimenti durante l’upload avverrà l’autoreset e l’IDE darà un errore di sync in fase di upload.
A questo punto possiamo tranquillamente selezionare dal menu Tools –> Board –> Arduino Duemilanove or Nano w/ ATmega328 e lanciare Burn Bootloader –> w/ Arduino as ISP e se tutto è stato eseguito correttamente dovremmo avere il nostro bootloader caricato sul microcontroller, pronto per essere programmato tramite seriale come indicato nel post precedente. La nostra Arduino UNO possiamo invece riprogrammarla normalmente (ricordiamoci di togliere il conensatore inserito precedentemente).
Ovviamente possiamo caricare il bootloader non solo su un Arduino standalone o su breadboard, ma anche su un’altra scheda Arduino UNO, 2009, Mini, ecc.
Se invece volessimo programmare la board con una configurazione minmale, senza oscillatore esterno?
La procedura è leggermente diversa perchè nelle Board predefinite dell’IDE non c’è una configurazione di questo tipo.
Va aggiunta manualmente quindi nel file boards.txt che si trova nella cartella di arduino (sotto hardware\arduino) la seguente configurazione:

##############################################################

atmega328bb.name=ATmega328 on a breadboard (8 MHz internal clock)

atmega328bb.upload.protocol=stk500
atmega328bb.upload.maximum_size=30720
atmega328bb.upload.speed=57600

atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0x05
atmega328bb.bootloader.path=arduino:atmega
atmega328bb.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F

atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
atmega328bb.build.core=arduino:arduino

##############################################################

A questo punto avremo uno schema tipo il seguente:

Ricordiamoci sempre di inserire il condensatore da 22uF tra GND e RESET, e verifichiamo che lo sketch ArduinoISP sia caricato sulla nostra board.
A questo punto possiamo caricare il bootloader selezionando Tools –> Board –> ATmega328 on a breadboard (8 MHz internal clock)
Se tutto va bene, dovremmo avere il nostro Atmega328 con il bootloader Arduino caricato e funzionante a 8Mhz. In questa modalità potremo alimentare il nostro circuito definitivo con 3.3V (se vogliamo) permettendo un consumo minore del nostro progetto.
Se l’upload a 16Mhz è andato a buon fine e quello a 8Mhz no, è perchè il primo caricamento di bootloader a 8Mhz va fatto con il circuito configurato ancora con il cristallo esterno, in quanto se togliamo l’oscillatore il circuito non è in grado di comunicare con il programmatore ISP. Successivamento ogni ulteriore caricamento può essere fatto senza il circuito oscillatore.
E qui anticipo una chicca che sarà oggetto del nostro prossimo post. Se io ho finito il mio progetto e quindi non mi serve più utilizzare il bootloader di Arduino (perchè non mi interessa più la possibilità di fare l’upload via seriale – vedi post precedente), posso fare l’upload dello sketch direttamente nella memoria dell’Atmega328 sovrascrivendo il bootloader. E per farlo devo semplicemente utilizzare gli stessi collegamenti visti qui sopra…
Ma per ora ci fermiamo e continueremo a parlarne nel prossimo post.

Arduino standalone (Arduino senza Arduino)

Pubblicato da Luca Soltoggio in 6 febbraio 2012
Pubblicato in: Arduino. Tag: , , , , , , , , , . 7 commenti

In questo post vorrei mostrare come utilizzare Arduino in configurazione standalone, ovvero utlizzare l’Atmega328 (munito di bootloader) in circuito senza dover portarsi dietro tutta la nostra board Arduino Uno (o quella che avete).
Il concetto è questo: ho finito il mio progetto con Arduino (ad esempio una con LED RGB) e sono pronto per realizzare la versione definitiva da inscatolare in una lampada.
Potrei si usare la board Arduino, ma sarebbe sconveniente sia dal punto di vista del costo, che dal punto di vista delle dimensioni e dei consumi… In realtà quello che a noi serve è semplicemente il microcontroller dotato di bootloader e pochi altri componenti esterni.
Se il nostro Atmega non ha il bootloader, dobbiamo caricarglielo, ma andiamo con ordine… Poniamo che al momento abbiamo già il bootloader onboard.
Per poter fare l’upload degli sketch dobbiamo utlizzare i collegamenti come indicato in figura:

E’ importante rimuove il microcontroller dalla scheda con cui andiamo a programmare, altrimenti programmeremmo quello al posto del nostro Atmega standalone.
Come vedete lo schema è molto semplice, si collega l’alimentazione, i pin TX e RX dei rispettivi microcontroller e il pin RESET.
A questo punto dal nostro Arduino IDE possiamo andare a fare l’upload dello sketch, dopo aver selezionato ovviamente “Arduino Duemilanove or Nano w/ ATmega328” dal menu Tools –> Board. E’ il gioco è fatto.
Ovviamente lo stesso discorso varrebbe se l’Atmega fosse programmato per lavorare con l’oscillatore interno a 8mhz. Con la differenza che non ci sarebbero i due condensatori e il cristallo indicati in figura. Per utilizzare però l’oscillatore interno, va riprogrammato il bootloader (lo vedremo nel prossimo post).
Qualora avessimo a disposizione (e vi consiglio di prenderlo perchè è un’accessorio che costa poco ed è veramente utile) un convertitore USB/Seriale tipo lo Sparkfun FTDI Basic o l’Arduino USB-Serial Light il collegamento sarebbe tipo il seguente:

Non è niente di complicato, semplicemente i collegamenti sono quasi come prima: VCC, GND, RX, TX, mentre il reset è un po’ diverso perchè richiede un condensatore da 100nF tra il PIN DTR (o RTS – da non confondere con RST) e il PIN RST dell’Atmega.
Abbiamo quindi visto come programmare un Atmega328 in standalone con il bootloader già preinstallato; nel prossimo post vedremo come caricare il bootloader su un’Atmega328 vergine sia in versione con cristallo esterno a 16mhz, sia in versione con oscillatore interno a 8mhz.

Due semplici led driver per Power LED – Parte2: Transistor

Pubblicato da Luca Soltoggio in 5 febbraio 2012
Pubblicato in: Circuiti. Tag: , , , , , , . 14 commenti

Nel post precedente abbiamo visto un semplice LED driver basato sull’integrato LM317, ma come spiegato uno dei difetti di quel circuito è il dropout elevato.
Vediamo quindi oggi uno schema basato su un singolo transistor (nel nostro caso un BC337, ma qualsiasi NPN va bene purchè se ne conoscano i valori in gioco), che ha un dropout di circa 1,25V.
Il circuito è il seguente:

Ovviamente si può inserire anche solo un LED. Ne ho messi tre in serie a titolo d’esempio, poichè siamo in grado di pilotare 3 LED da 1w con un efficienza abbastanza elevata. Nell’esempio in figura, abbiamo una potenza dissipata dai LED di circa 3W, mentre l’intero circuito consuma circa 4W.
Ma vediamo il principio di funzionamento:
I LEDR è un LED standard e serve  come voltaggio di riferimento per il transistor. Il dropout del led rosso è di circa 1,8v, quindi sul collettore del transistor avremo all’incirca 950mV. Applicando sempre la legge di Ohm 0,950/2,8=339, quindi con R2 a 2,8V si ha un passaggio di corrente di 339mA, che scorrerrà anche attraverso l’emettitore di Q1. In questo modo avremo un corrente costante indipendentemente dal voltaggio di ingresso. Questo è vero finchè il voltaggio, sarà sufficiente a mantenere 1,8V sul LEDR, ovvero 1,2V sull’emettitore di Q1. Insomma in parole povere dobbiamo prevedere che il voltaggio in ingresso sia di almeno 1,2V superiore al dropout dei led che si va a pilotare. I led bianchi da 1W per esempio hanno un voltaggio massimo dichiarato di 3,6V, percui 3,6×3=10,8V. 10,8+1,2=12V. In questo caso siamo perfetti. Consiglio sempre un voltaggio di circa 1,5V in più per sicurezza.
Se il carico da pilotare è maggiore di 500-600mA, è possibile diminuire il valore di R1 fino a 470Ω.
Se volessimo superare invece i 750mA, dovremmo sostituire il transistor con un darlington tipo il BD677A che può erogare fino a 4A di corrente!!!
Potete sperimentare il circuito variandone i valori, utlizzando il simulatore gratuito online a questo link.
Ovviamente anche questo circuito è “PWM capable”. Possiamo quindi alimentare il tutto tramite un circuito PWM, oppure utlizzare il seguente schema per utilizzare ad esempio un’uscita PWM di Arduino:

In questo caso dovremo diminuire leggermente la resistenza R2 a causa del fatto che il voltaggio con cui pilotiamo l’ingresso di Q1 non è 12V ma 5V.
L’importante come sempre è sperimentare, sperimentare, sperimentare!!!

Due semplici led driver per Power LED – Parte1: LM317

Pubblicato da Luca Soltoggio in 3 febbraio 2012
Pubblicato in: Circuiti. Tag: , , , , , , , , , . 12 commenti

L’utilizzo dei LED nella vita quotidiana, negli ultimi anni ha sempre più preso piede.
Con l’uscita sul mercato di LED di potenza da 1W, 3W, 5W, 10W e così via la possibilità di illuminare con questi diodi le nostre vite è alla portata di tutti.
Purtroppo i sistemi a LED di potenza integrati (tipo lampadine di marca) hanno dei costi ancora abbastanza elevati, ma i singoli diodi led sono abbordabilissimi.
Il problema per tanti è l’alimentazione, in quanto rispetto ai classici LED da 20ma che tipicamente si alimentano a 12V con una resistenza in serie da 470Ω , questo tipo di LED hanno bisogno, a maggior ragione viste le potenze in gioco, di essere alimentati non a tensione costante, ma a corrente costante.
Quando si compra un LED di potenza, spesso il venditore fornisce anche il suo alimentatore specifico a prezzi non sempre accettabili.
Da qui nasce la mia ricerca sui vari siti e blog di un sistema per alimentare questi LED, che mi dia la possibilità anche di essere dimmerato eventualmente da un circuito PWM o da un microcontroller (tipo Arduino).
Ho trovato due progetti interessanti, semplici, di facile realizzazione, sperimentati e soprattutto economici e costruiti con componenti molto comuni e diffusi.
Il primo circuito che vi voglio presentare, è costruito utilizzando l’integrato LM317, che è un regolatore variabile di tensione, ma in questo caso lo utilizzeremo come regolatore di corrente.

Il circuito qui mostrato è abbastanza semplice da capire. Tra Vout e ADJ è presente un voltaggio di riferimento di 1,25V, quindi applicando la legge di Ohm I=V/R, con un voltaggio di 1,25V e una resistenza di 3,6Ω, avremo una corrente costante di circa 347ma che scorre attraverso il LED1, indipendentemente dal voltaggio di ingresso. Questo circuito è quindi adatto per esempio per alimentare un LED da 1w (che tipicamente va alimentato con una corrente di assorbimento di 350ma).
Ovviamente si possono mettere più LED in serie, ma va tenuto conto del dropout del circuito che è di circa 3V, quindi il voltaggio in ingresso deve essere di almeno 3V superiore a quello nominale del (o dei) LED. Se però il voltaggio è troppo alto l’integrato si scalderà troppo poichè tutto il voltaggio in eccesso verrà dissipato proprio dall’LM317.
Infatti questo circuito dal punto di vista del rendimento non è il massimo; per alimentare un LED da 1W, il circuito assorbe circa 4W.
Bisogna tener conto anche del fatto che la resistenza dissipa una potenza pari a 1,25V per la corrente di circuito (in questo caso 347mA), dovremmo quindi prestare attenzione che le resistenze abbiano una potenza adeguata (eventualmente se ne possono mettere due o più in serie o in parallelo).
Il tutto è “PWM capable”, possiamo quindi alimentare il tutto con un circuito PWM di potenza adeguato (magari ne pubblico uno in un prossimo post), oppure pilotarlo da un circuito PWM a bassa potenza, tipo l’uscita di Arduino a 5V e allora lo schema sarà così modificato:

Abbiamo dovuto modificare il valore della resistenza R1 perchè introducendo la R2, il valore di riferimento mi si porta a 1,75v circa. Eventualmente va sperimentato e misurato con un amoperometro.
In questo  circuito VCC che rappresenta l’ingresso TTL del nostro circuito (l’uscita PWM di un Arduino, piuttosto che l’uscita logica di un NE555), quando è a ad un valore alto (+5V), il transistor Q1 conduce e il piedino ADJ dell’LM317 va a massa, inibendo il passaggio di corrente nella R1 e quindi nel LED. Viceversa se porto l’ingresso logico ad un valore basso (0V) il transistor non conduce permettendo il passaggio di corrente: il LED si accende come nel’esempio precedente. Ovviamente lavora a logica invertita e quindi nella programmazione del microcontrollore se ne dovrà tenere conto, o al limite si può aggiungere un transistor ulteriore per invertire nuovamente la logica.
In un prossimo post, vedremo di realizzare un’altro circuito che abbia la stessa funzione, utlizzando però un transistor al posto dell’LM317.

Arduino e Atmega328: Un po’ di chiarezza

Pubblicato da Luca Soltoggio in 2 febbraio 2012
Pubblicato in: Arduino. Tag: , , , , , , , , , , , , , , , . 16 commenti

Fino a qualche settimana fa, nemmeno io sapevo con precisione qual’era la differenza tra Arduino, ed il suo “core” Atmega328.
Leggevo qua e la che l’Atmega328 può lavorare in stand-alone, con o senza il bootloader di Arduino, e addirittura, nella sua configurazione minimale, senza alcun componente esterno.
Ero confuso quindi su cosa facesse esattamente Arduino e su cosa facesse l’Atmega328 “senza Arduino”, non trovando nemmeno tante informazioni in merito su Internet.
Alla fine, con tanta pazienza, “sbocconcellando” qua e la qualche informazione sui vari blog, leggendo riviste e libri specializzati, e facendo delle prove sul campo, finalmente mi si è accessa la lampadina (o il LED) in testa e tutto mi è apparso più chiaro.
Ho deciso quindi di pubblicare questo post dove spiego brevemente ed in maniera semplice (e probabilmente anche in maniera non del tutto professionale – chiedo quindi scusa se ci sono delle imprecisioni) cos’è Arduino e cosa lo differenzia dall’Atmega328 (che è inserito nelle schede Arduino di ultima generazione).
Se dovessi definire il progetto Arduino, lo definirei una piattaforma Hardware e Software opensource, che permette di sfruttare in maniera più semplice e rapida le potenzialità offerte dal microcontrollore Atmega328.
La parte Hardware, tipicamente è rappresentata dalle schede elencate sul sito ufficiale, con tanto di schemi aperti che ci permettono di realizzare da noi le varie schede Arduino o di modificarle e personalizzarle a nostro piacimento. La parte Software invece è raprresentata dal tanto citato bootloader, dalle librerie (presenti sempre sul sito) e dall’IDE, l’interfaccia che permette di programmare e “debuggare” la nostra scheda Arduino.
Ma quali sono le differenze tra Arduino e il suo microcontrollore Atmega328 e quali vantaggi ci offre Arduino nella programmazione del microcontrollore?
Dal punto di vista Hardware, la scheda di Arduino (prendiamo come esempio Arduino UNO) è pronta all’uso: ha tutto quello che ci serve per programmare il microcontrollore collegando la scheda semplicemente alla porta USB del PC; contiene al suo interno un connettore di alimentazione, una porta usb, un integrato che fa da convertitore USB/Seriale, un LED ci accensione, un LED di controllo collegato al PIN 13, due led di segnalazione TX/RX, le strip header femmina per il collegamento degli ingressi/uscite tramite cavetti per breadboard e ovviamente il nostro microcontrollore Atmega328 con bootloader Arduino già caricato.
In questo modo aprendo l’IDE e selzionando la porta seriale del PC possiamo caricare i nostri sketch con un semplice tasto ed in pochi secondi (tipicamente 2-3). L’upload avviene tramite la porta seriale emulata dall’USB, che va a collegarsi ai PIN TX e RX dell’Atmega (piedini rispettivamente 3 e 2).
Dal punto di vista Software , il bootloader precaricato sull’Atmega (indipendentemente che sia montato su una scheda Arduino o semplicemente su una breadboard), è quello che permette la comunicazione seriale con il nostro PC. Senza il bootloader, per caricare gli sketch (i nostri “programmi”), avremmo bisogno di un programmatore per AVR, più costoso, un po’ più macchinoso da utilizzare e più lento nel caricare gli sketch. Il bootloader è quindi un programma, un firmware potremmo dire, il cui compito è praticamente quello di caricare i nostri sketch compilati all’interno della memoria flash del microcontrollore tramite comunicazione seriale, facendo si che tale programmazione non vada a sovrascrivere la zona di memoria dove è presente il bootloader. Quindi quando facciamo l’upload di uno sketch andiamo a scrivere in una zona di memoria libera e il bootloader non viente toccato e rimane integro.
Il vantaggio rispetto all’Atmega senza bootloader come abbiamo già visto è quello di poter effettuare l’upload tramite una semplice comunicazione seriale, e ad una velocità maggiore rispetto a quello che avremmo caricando direttamente gli sketch tramite programmatore AVR.
L’altra parte che riguarda il software sono le librerie incluse nell’IDE di Arduino. Tali librerie aggiungono svariate funzioni e costanti che permettono di semplificare enormemente il codice che andiamo a scrivere rendendolo molto più fruibile rispetto a quello standard del microcontrollore. Il tutto viene gestito tramite l’IDE, che è l’intefaccia di Arduino con cui noi scriviamo gli sketch, li “uploadiamo” e li “debugghiamo”.
Fatta questa premessa (sperando di non avervi tediato e di essere riuscito a spiegare senza creare ulteriore confusione) nei prossimi post andremo a vedere come fare a costruire un’Arduino stand-alone e come programmare un’Atmega328 senza bootloader, soluzione che a volte può risultare vantaggiosa.

Ciao mondo!!

Pubblicato da Luca Soltoggio in 1 febbraio 2012
Pubblicato in: Senza categoria. 1 Commento

Eccomi qui con questo nuovo Blog…
Sono un’appassionato di elettronica e di Arduino, e ho quindi deciso di condividere i miei progetti nonchè le soluzioni ad alcuni problemi che ho incontrato e che continuo ad incontrare in questo affascinante mondo.
A breve pubblicherò il mio primo progetto (una lampada RGB con Arduino) e alcuni consigli sulla programmazione dell’Atmega328 e dell’Attiny85 in Standalone.

A presto!!!