atmega

Tutti gli articoli con tag atmega

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!!!

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.

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.