Abbiamo la nostra amata PCB "morta" oppure abbiamo a che fare con una MCU in cui il bootloader non è (ancora) installato.
Sappiamo che ci sono diversi ISP programmer che possiamo usare: ma quale scegliere?

A volte abbiamo sotto agli occhi tutto quello che ci può servire... e spesso non ce ne accorgiamo.

Qui di seguito vedremo come utilizzare un Arduino Uno al nostro scopo.
Questa piccola board infatti è un po' come un piccolo coltellino multiuso e può essere utilizzata per eseguire diversi compiti compreso quello di comportarsi come un ISP programmer.

Avremo quindi bisogno di:

• un Arduino Uno
• una breadboard
• pin di collegamento di varia lunghezza
• 3 LED di colori diversi (opzionali)
• 3 resistenze da 220 Ohm (opzionali)

Il processo che seguiremo è molto semplice: Arduino verrà programmato per comportarsi come un ISP programmer, nello specifico un AVRISP - ovvero una sorta di clone di un programmer, ora fuori commercio, distribuito direttamente da Atmel fino a qualche anno fa.
Collegheremo Arduino con una breadboard dove sarà posizionata la nostra MCU - nel mio caso un ATmega32A.

La programmazione di Arduino è banale, basta richiamare uno sketch già pronto negli esempi:

• File » Examples » 11.ArduinoISP » ArduinoISP

Lo sketch è ben commentato e per chi volesse ne consiglio un'attenta lettura.
Arduino ha già un'interfaccia ISP - proprio vicino al suo ATmega328P - ma nel nostro caso utilizzeremo dei PIN specifici:

• 10 - RST (giallo)
• 11 - MOSI (verde)
• 12 - MISO (arancione)
• 13 - SCK (blu)

Per avere dei feedback durante l'utilizzo di Arduino come ISP è possibile utilizzare anche dei LED, così collegati:

• 7 - programmazione (verde): lampeggia quando vengono trasferiti dati
• 8 - errore (rosso): si accende quando ci sono errori
• 9 - heartbeat (blu): segnala il funzionamento del programmer

Nel mio esempio ho utilizzato dei banali LED da 5 mm con delle resistenze di sicurezza pari a 220 Ohm.
I LED sono assolutamente opzionali: il sistema funziona anche senza.

Tornando alla programmazione dello sketch: con un Arduino Uno non c'é bisogno di fare alcuna modifica ma per sicurezza è meglio togliere il commento alla riga 81 che diventa quindi:

  #define USE_OLD_STYLE_WIRING

La define USE_OLD_STYLE_WIRING serve infatti per dichiarare i PIN 11, 12 e 13 e il loro utilizzo.
Nel codice volendo possono essere modificate altre define e customizzare così i PIN utilizzati:

  #define PIN_MOSI	11
  #define PIN_MISO	12
  #define PIN_SCK	13
  #define RESET     	4
  #define LED_HB    	7
  #define LED_ERR   	6
  #define LED_PMODE 	5

Prendiamo infine nota del clock della seriale che viene impostato a 19200 alla riga 142:

  #define BAUDRATE	19200

A questo punto siamo pronti per verificare il codice - lo sketch è già rilasciato perfettamente funzionante quindi non dobbiamo aspettarci delle sorprese - e caricarlo su Arduino: se abbiamo utilizzato i LED quello di hearbeat (nel mio caso quello blu) dovrebbe iniziare a lampeggiare lentamente, segnalando che la board è pronta per ricevere comandi.

È quindi arrivato il momento di fare i collegamenti verso la MCU.
È sufficiente recuperare il datasheet relativo per controllare la posizione dei PIN:

I PIN che ci interessano sono:

• 6 - MOSI - da collegare al PIN 11 di Arduino con il cavo verde
• 7 - MISO - da collegare al PIN 12 di Arduino con il cavo arancione
• 8 - SCK - da collegare al PIN 13 di Arduino con il cavo blu
• 9 - RST - da collegare al PIN 10 di Arduino con il cavo giallo
• 10 - VCC - da collegare alla +5V di Arduino con il cavo rosso
• 11 - GND - da collegare al GND di Arduino con il cavo nero

Fatti i collegamenti è tutto pronto: è possibile utilizzare il programma avrdude per testare la corretta comunicazione con la nostra MCU.

Possiamo quindi lanciare il comando:

avrdude -c avrisp -p m32a -P /dev/ttyACM0 -b 19200

Facciamo però attenzione ai parametri che utilizziamo:

• -c indica il tipo di programmer che stiamo utilizzando, nel nostro caso un Arduino programmato per comportarsi come un AVRISP
• -p indica la MCU che vogliamo programmare, nel mio esempio una ATmega32A
• -P indica la porta seriale a cui è collegato il nostro Arduino
• -b indica la velocità di trasmissione seriale e deve essere allineata con quanto indicato nello sketch caricato su Arduino

In caso di corretta comunicazione dovremmo avere un output simile a questo:

~$ avrdude -c avrisp -p m32a -P /dev/ttyACM0 -b 19200

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.02s

avrdude: Device signature = 0x1e9502 (probably m32a)

avrdude done.  Thank you.

Arrivati a questo punto siamo pronti per programmare la nostra MCU, caricando ad esempio un bootloader.

In un prossimo post vedremo come ottenere lo stesso risultato con un programmer dedicato, nel caso specifico USBasp.