Continua a leggere »]]>

Il videogioco ET per Atari 2600

Nel 1982 uscì un film che riscosse un successo planetario, E.T. l’extraterrestre. Sull’onda del successo della pellicola, Atari pensò di pubblicare un videgioco per la sua console 2600 che riprendesse il personaggio di ET. Il lavoro fu affidato a Howard Scott Warshaw, già autore di famosi titoli per questa console quali Yar’s Revenge e Raiders of the Last Ark. Il tempo a lui concesso fu però molto poco perché i vertici di Atari volevano cavalcare l’onda del successo del film ancora in proiezione nelle sale cinematografiche: ciò che Warshaw realizzò fu perciò un gioco poco curato e molto al di sotto del livello qualitativo dei suoi 2 precedenti lavori. Il gioco fu accolto così male dalla critica e dal pubblico che Atari fu costretta non solo a ritirare le copie già vendute ma addirittura a distruggere milioni di cartucce che stagnavano nei suoi magazzini, con un enorme danno economico per l’azienda.

Nel corso degli anni ET ha conservato la fama di pessimo gioco che si era costruito in quel periodo e non c’è classifica su internet in cui non compaia come il peggior videogioco mai realizzato, un’etichetta che il suo creatore ha sempre respinto con forza, considerando ET un buon gioco ed il massimo che egli potesse fare nel poco tempo che ebbe a disposizione per realizzarlo.

La seguente intervista è stata pubblicata da Beep! Bop! Boop! nel 2004 ma il sito non è più online ed è raggiungibile solo tramite Web.archive.org.

Intervista ad Howard Scott Warshw – di Charles F. Gray (25/10/2004)

Charles F. Gray: Ciao, Howard. Grazie per averci concesso un pò del tuo tempo per questa intervista. Non ti farò tutte quelle domande a cui hai già risposto in altre interviste. Piuttosto, vorrei parlare di nuovi, o per lo meno, più recenti aspetti ed idee circa il tuo coinvolgimento con Atari, in special modo nel gioco in cartuccia per Atari 2600 E.T.: The Extra Terrestrial. Come ti suona?

Howard Scott Warshaw: Suona bene, Charles.  Vorrei sentire nuove domande, soprattutto a riguardo di E.T.

CFG: Immagino che la maggior parte delle persone che leggerà quest’intervista conoscerà bene il tuo coinvolgimento nella grande società di videogiochi che era Atari negli anni ’80 ma, per chi non ne fosse a conoscenza, vorrei spiegare un pò come stanno le cose. Dunque, quando è iniziata la storia con Atari e come sei stato assunto lì?

HSW: Iniziai quando lavoravo presso Hewlett Packard, dove non mi trovavo molto bene e per rompere un pò la monotonia ero solito fare un pò di casini. Uno dei miei colleghi era solito raccontare le storie di “Howard” a sua moglie, che gli ricordava ciò che succedeva anche dove lei lavorava… Atari Mi raccontò questa cosa ed io andai per un colloquio. Dopo qualche incontro, non mi fecero nessuna offerta, principalmente perché pensavano fossi troppo sincero e che non mi sarei ambientato lì. Fu così che letteralmente li implorai e supplicai di prendermi almeno in prova affinché potessi mostrare loro che si sbagliavano. Alla fine accettai il taglio del 20% dello stipendio ma fui felice di farlo. Sapevo che quello era il posto per me. Ed in breve tempo tutti seppero che quello era davvero il posto giusto per me.

CFG: Ed in quali titoli per l’Atari 2600 hai dato una mano nella programmazione?

HSW: Non solo una mano, ho messo tutto me stesso in Yar’s Revenge, Raiders of the Lost Ark, E.T. ed un gioco chiamato Saboteur che Atari rinominò in The A-Team ma che poi non riuscì a vendere prima che fallisse (ma che sta per uscire molto presto, grazie ad alcuni appassionati) [N.d.Leo: il gioco è effettivamente stato pubblicato alcuni anni fa da un gruppo di programmatori amatoriali]

CFG: Ho molti ricordi di me bambino che gioco con la mia Atari 2600 cercando di vincere a quei giochi in cartuccia che hai creato. Qual è il tuo gioco preferito fra quelli che hai programmato?

HSW: Yar’s è probabilmente il mio favorito, perché quello fu un gioco che realizzai per me. Mi chiesi se era possibile fare un gioco che mi sarebbe piaciuto, una cosa che piaceresse a molti giocatori. Esso ha anche molti primati per la VCS [N.d.Leo: il nome originale della 2600]: è il primo gioco resettabile da joystick, il primo ad avere un’esplosione a tutto schermo, il primo gioco che mostra il codice sullo schermo (the zona ionica è in pratica il codice assembly delle istruzioni ), il primo gioco per VCS che si è pensato di convertire in un arcade!!, l’*unico* titolo ad aver sconfitto Missile Command in un test di gioco, il primo gioco che piacque ad un pubblico femminile, il primo gioco con un fumetto che narrava i retroscena (scritto da me), la prima azienda colpita da un Easter egg, ed il primo titolo nella storia di Atari a uscire con il nome del suo programmatore. Sì, Yar’s è proprio il mio figlio prediletto

CFG: E la storia secondo cui Yar’s Revenge era stato chiamato così per via del capo di Atari, Ray Kassar, è vera?

HSW: Ah sì, la storia di come Yar’s Revenge divenne Yar’s Revenge è buona. Eccola… inizialmente

Yar’s non era Yar’s, era un gioco senza titolo in fase di sviluppo. C’erano alcuni titoli proposti dal reparto commerciale ma li reputavo un pò brutti ed io volevo qualcosa di speciale per il mio gioco. Perciò chiesi se era troppo tardi per proporre il mio ed i ragazzi del commerciali mi dissero che potevo, se mi sbrigavo. Me ne uscci con Yar’s Revenge perché sapevo che “revenge” (vendetta) era una buona parola per un titolo e Yar, beh, lo vedrai subito. Stetti perciò sveglio tutta la notte a scrivere una piccola storia di fantascienza intitolata “The Yarian Revenge of Rassak IV”. Un’intera storia su queste creature chiamate Yars provenienti dal sistema solare Rassak. Pensavo che un prologo abbinato ad esso avrebbe reso il gioco più convincente. Pensavo anche questa fossa l’occasione per migliorare il mio Inglese (una cosa che avevo sempre voluto fare). Perciò misi insieme tutto questo e lo consegnai la mattina dopo. Due giorni dopo vidi il ragazzo del commerciale e gli chiesi se avevano deciso. Mi rispose di no, perciò chiesi se gli sarebbe piaciuto sapere un piccolo segreto sulla mia storia. Mi rispose ovviamente di sì. Gli chiesi perciò non una, non due, ma tre volte di promettere di non dire nulla a nessuno. Dopo che ebbe promesso la terza volta, fui sicuro che ave raccontato tutto in giro, che era ciò che volevo quando gli avevo detto di giurare…

Yar scritto al contrario è RAY e Rassak al contrario è KASSAR. Ray Kassar era l’amministratore delegato in carica di Atari ed il capo lì dentro. Il ragazzo del commerciale mi chiese se Ray fosse a conoscenza della cosa ed io gli risposi assolutamente sì. Ecco perché la segretezza era così importante visto che io non volevo che questo influenzasse negativamente la decisione

A quel punto, io sapevo 2 cose:

1) che quel ragazzo avrebbe SICURAMENTE raccontato la cosa a tutti quelli del commerciale e che avrebbe bloccato il titolo per me, e

2) nessuno del commerciale avrebbe avuto le palle per raccontare la cosa a Ray.

Contavo sul secondo punto perché la verità era che Ray Kassar non avrebbe avuto nessuna informazione sulla cosa Il giorno seguente vidi il ragazzo del commerciale, che mi disse: “Hey Howard, sai cosa? Abbiamo deciso per 

Yar’s!!”

“Non lo hai detto a nessuno, vero?”

gli chiesi, cercando di tener lontano dalla mia faccia qualsiasi sorriso, e lui mi assicurò che non lo aveva fatto

CFG: Com’era il rapporto con Ray Kassar. Voglio dire, so che era il capo di Atari, ma fu una persona piacevole per lavorarci insieme oppure fu un seccatore? Ti sei mai scontrato con lui?

HSW: Personalmente reputo il rapporto con Ray buono. Non ci ho comunque realmente lavorato insieme. Era quel genere di persona che aspettava impazientemente qualcosa da me e che mostrava di essere interessato in ciò che dicevo.

Ho una bella storia su Ray. Con cadenza semi-regolare, i “parrucconi”, come noi li chiamavamo, vennero a fare una piccola visita. Per l’Esecutivo era l’equivalente di andare allo zoo a vedere gli animali. Ora devi sapere che Ray era sempre impeccabilmente vestito con una colonia molto distintiva, mentre io ero vestito come un cialtrone altolocato con una giacca in tweed a lisca di pesce e le toppe di pelle sui gomiti, jeans, una t-shirt e sandali arcobaleno in stile hawaiiano. Ray era di solito accompagnato nella visita dal suo entourage, circa 3-5 vice-presidenti al seguito. Un giorno vennero tutti nel mio ufficio per una dimostrazione di Raiders, che stavo sviluppando in quel periodo. Perciò misi su l’Overture 1812 e feci un bello spettacolo, poi parlai un pò con Ray di strategie di mercato. Insomma, eravamo tutti pigiati nel mio ufficio e Ray ed io stavano parlando tra noi con lui che mi stava facendo la paternale come si conviene. Ad un certo punto, Ray scherzosamente mi disse: “Bene, Howard, potremmo scambiarci i lavori per un giorno e vedere come va.” Non persi tempo e risposi con: “Ok Ray, facciamolo. Ecco il mio sistema di sviluppo, dammi solo il tuo profumo e vediamo che succede“.

I 4 vice-presidenti nel mio ufficio erano sbalorditi ma cercavano anche di combattere contro l’istinto di ridere. Le persone di solito non si rivolgevano a Ray in quel modo e non sapevano come la cosa sarebbe andata a finire. Avevano paura di scoppiare a ridere prima di vedere la reazione di Ray ma avevano anche grossi problemi a contenersi ed uno o due di loro iniziavano ad esplodere. Ray era congelato. Tutti stavano aspettando cosa sarebbe successo. Alla fine, dopo quella che pareva un’eternità, Ray finalmente ridacchiò un pochino e roteò i suoi occhi e fu allora che i vice-presidenti finalmente scoppiarono a ridere a crepapelle. Fu una scena molto toccante

CFG: Affrontiamo ora il grosso fiasco di E.T. So che un sacco di persone afferma che E.T. è stato il responsabile della caduta di Atari. Insomma, il gioco che ha fatto cadere un impero. Quali sono le tue sensazioni? E’ vero questo?

HSW: Dio, lo spero! Sarei lusingato nel pensare che con una sola mano sono stato in grado di tirari giù un’industria miliardaria Il punto è che E.T. fu una dura sfida tecnica molto dura che mi sento di aver affrontato bene. Creai quel gioco dal nulla in cinque settimane. Nessun altro si è mai avvicinato ad un tale risultato sulla VCS. Poteva essere senz’altro un gioco migliore ma non è così male per [averlo fatto in] cinque settimane. Detto questo, capisco che agli utenti non gli interessa (e non dovrebbe) il tempo di sviluppo. Tutto quello di cui gli interessa è l’esperienza di gioco. Io penso che

 E.T. sia un gioco completo e buono. Ad alcuni piace. Non è sicuramente il peggior gioco o il meno rifinito ma mi piace che abbia la caratteristica di essre il peggior gioco. Tra questo e Yar’s, ho il maggior intervallo su questa macchina rispetto a chiunque altro Per me la sfida di aver provato a farlo vuol dire tanto. Nessun altro lo avrebbe fatto. E, credetemi, l’ho chiesto a tutti Io sono stato l’unico coraggiocso/stupido abbastanza per provarci.

CFG: Ho incontrato un sacco di persone a cui è piaciuto il gioco E.T. e poche persone che lo hanno odiato. A me personalmente piacque, a parte le buche! Che ci dici delle buche? Perché era così difficile uscirne?

HSW: Non ho mai pensato che fosse *così* difficile uscirne, bastava prendere il pendio. Ma se dovessi modificare il gioco ora, la prima cosa che farei sarebbe modificare il gioco delle buche, sicuramente. Erano il maggior ostacolo del gioconever thought they were *that* tough to get out of, if you get the hang of it.  But if I were to modify the game now, the first thing I would do is modify the pit play, that’s for sure.  It was the main obstacle in the game. Ciò di cui sono veramente infastidito è il modo in cui è così facile rimanere accecati durante i cambi di scena. Questa è la prima cosa che cambierei. Ah, se solo avessi avuto sei settimane

CFG: Bene, supponiamo per un secondo, che nell’aprile del 1983 Atari chiuda il suo impianto di produzione di El Paso. Quattordici autorimorchi pieni di giochi invenduti come E.T.: The Extra Terrestrial e Pac-Man scaricano e seppelliscono il loro contenuto in una discarico di Alamorgordo, New Mexico. Hai già sentito questa storia prima. Cosa ne pensi?

HSW: Onestamente dubito di essa per un paio di motivi:

prima di tutto, Atari era un’azienda in crisi, all’epoca. Erano alla disperata ricerca di contante. Perché non riusare gli involucri di plastica ed un pò di quelle schede e ROM? Si poteva risparmiare un sacco di denaro cannibalizzando l’inventario e riusandolo. Perché un’azienda in crisi avrebbe speso dei soldi che non avevano nel tentativo di perdere altri soldi per buttare via delle risorse utilizzabili?

Un altro motivo è che ciò fosse accaduto, lo avrei saputo. Ero abbastanza attaccato alla vite Atari, ed ecco ciò che potrebbe essere successo: qualcuno avrebbe detto, “Hey Howard, stanno seppellendo un carico di E.T. fuori nel deserto“. Avrei assunto un fotografo (avevo un sacco di soldi all’epoca), sarei volato fino a quel posto ed avrei preso delle immagini di me in piedi in cima alla montagna di cartucce sepolte. Come non avrei potuto farlo?

Ma detto questo, voglio dire una cosa non romantica, mi dispiace ma non credo alle storie di cartucce sepolte.

CFG: Vorrei precisare che Atari non aveva nessun motivo per contattarti. Atari voleva tenere nascosta questa cosa per cui perché Atari avrebbe detto ai programmatori di E.T. e Pac-Man che stava seppellendo milioni di cartucce invendute di quei giochi. Perché Ray ti avrebbe dato questa informazione?

HSW: Ray magari no, ma non puoi tenere nascosta una cosa come questa. C’erano tante, TANTE più attività controverse e decisamente illegali più note sulla società. Dubito che un’azienda che non poteva tenere nascoste quelle cose avrebbe potuto tenere questo bocconcino lontano dai circoli del gossip

CFG: Ci sono altre storie. Alcuni di quelli più divertenti raccontano che tu ed E.T. siete stati entrambi rinchiusi in bunker separati sotto alla discarica di Atari per un periodo di tempo non precisato come punizione per il fiasco di E.T. fiasco. E’ in parte vero?

HSW: Sì, ero lì sotto a giocare a poker con Indiana Jones ed un paio di Qotiles imbellettati.

CFG: O.K. Se fosse vero, voglio dire, se fossi stato confinato in un bunker in quel periodo e se ti avessero dato un’Atari 2600 attaccata ad un monitor, se potevi scegliere due giochi Atari da giocare mentre stavi lì, quali sarebbero stati?

HSW: Una domanda migliore , ed anche una scelta difficile. Nonostante sarei tentato di prendere Yar’s , probabilmente sceglierei Ms. Pac-Man e Kaboom. Sono due giochi per VCS fatti molto bene e con una duratura giocabilità.

CFG: Scusa se scherziamo con te su questa cosa ma il mistero o la supposta fiction di ciò che è successo è così interessante come ciò che si suppone sia successo (ad esempio, nessuna discarica Atari). Puoi saperlo come no ma E.T.: The Extra Terrestrial è stato modificato in modo ironico da  Christian Samuel in E.T.: The Extra Testical. Anche Scott Stilphen ha modificato il gioco restringendo le buche. Che ne pensi di queste modifiche al gioco E.T.?

HSW: Mi piacciono. L’imitazione è la più alta forma di adorazione. Pensaci. Ho fatto quel gioco più di 20 anni fa. Nonostante sia il peggior gioco di tutti i tempi, le persone continuano a parlare di esso, ed anche a modificarlo! Se pensi ad un gioco come ad una porzione di media pensata per creare una reazione o un impatto, allora E.T. è uno dei giochi di maggior successo mai realizzato Hey, quanti giochi per VCS hai dimenticato? A parte questo, io conosco Scott Stilphen e so che è un bravo ragazzo, perciò tutto quello che vuol fare a qualsiasi dei miei giochi a me va bene. Sono onorato.

CFG: E che ne pensi del mio sito Atari 2600 Duds?

HSW: Ora *questa* è una bella domanda Ha un bel look retro ed è molto carino. Spero che lo aggiornerai dopo questa intervista. Alcuni punti chiave dovrebbero essere corretti. Jerome Domurat fu l’animatore del gioco, ci fu solo un programmatore di E.T. :) Furono solo 22 milioni di dollari (come contratto) e fu fatto in cinque settimane. Una parte molto importante della satira è stabilire correttamente il tuo obiettivo Nondimeno una cosa molto bella è la figura che mi assomiglia che sta nel bunker!!

CFG: Torniamo a giorni nostri, su che cosa ti stai impegnando?

HSW: Sto ancora facendo Once Upon ATARI, il mio documentario su come fosse *realmente* lavorare ad Atari per creare i giochi, e che è ora disponibile su www.onceuponatari.com. Sto lavorando sul mio prossimo documentario che sarà una nuova visione su un argomento *molto* controverso. Sarà simpatico, evocativo e molto erotico   Date un’occhiata a www.scottwestproductions.com  per gli ultimi aggiornamenti. Spero di poterlo portare ai festival cinematografici alla fine del 2004. Non riguarda i video giochi, sfortunatamente I miei libri sono anch’essi disponibili sul mio sito web per cui se alle persone piace il documentario possono acquistare anche i libri  

My books are also available on the website, so if people like the documentary they can check out the books too Lo so, è vergognoso, ma un artigiano anela a far conoscere il proprio lavoro.

CFG: Se tornassi nella programmazione dei videogiochi, ci sarebbe un gioco che ti piacerebbe progettare e programmare?

HSW: Sì. Le mie idee per Yars 2 sono ancora fattibili, e potrei ancora realizzarlo. Penso che sarebbe più divertente di Yar’s

CFG: So che questa non è stata un’intervista facile o per lo meno normale ma sicuramente è stata piacevole. Grazie ancora per il tuo tempo e spero di poter parlare con te ancora.

HSW: Grazie, Charles. E’ stato un piacere scrivere con te e ci sono state delle domande molto interessanti. Grazie ancora, HSW

La copia in inglese è raggiungibile da questa pagina.

Continua a leggere »]]> E’ disponibile la versione 1.2.0 della libreria swRTC che supporta l’uso del Real-Time Counter (RTC) presente su diverse MCU. Questo modulo permette di utilizzare il timer 2 in modalità asincrona con un quarzo esterno da 32.768 Hz. Impostando il timer con un prescaler a 128, si ha esattamente 1 overflow ogni secondo per cui è possibile incrementare l’orologio software in maniera più accurata.

Il modulo RTC è presente solo negli Atmega88/168/328, Atmega8, Atmega344/644/1284 e Atmega1280/256x.

La nuova libreria è scaricabile dalla seguente pagina.

Continua a leggere »]]>

Arduino DUE

Ho iniziato a scrivere una libreria che permette di utilizzare le periferiche integrate nel microcontrollore Atmel SAM3X8E dell’Arduino DUE che non sono ancora supportate dal core dell’IDE di Arduino.

Al momento la libreria, chiamata advancedFunctions, supporta l’orologio in tempo reale (Real Time Clock, RTC), che fornisce un orologio ed un datario nonché un allarme, ed il generatore di veri numeri casuali (True Random Number Generator, TRNG) che ha superato anche i test del NIST. Il supporto ad altro hardware verrà aggiunto in seguito.

Per usare la libreria, scaricate il pacchetto che trovate in fondo all’articolo e scompattatelo. Una volta estratta la cartella advancedFunctions, dovete copiarla all’interno della cartella /libraries che le ultimissime versioni dell’IDE 1.5.x di Arduino creano all’interno della cartella degli sketch. Questa cartella è cambiata rispetto a prima: adesso si chiama /Arduino e la sua posizione la potete conoscere cliccando sulla voce di menu dell’IDE “File/Preferenze”. Una volta fatto questo, siete pronti ad usare le funzionalità della libreria semplicemente includendola nel vostro sketch con la seguente istruzione:

#include "advancedFunctions.h"

Come detto, la libreria non supporta tutto l’hardware integrato nel microcontrollore che non è supportato dal core di Arduino. Essendo allo stato iniziale di sviluppo, al momento supporta solo le seguenti periferiche (altre funzionalità saranno aggiunte in seguito):

modulo RTC (Real Time Clock)

L’RTC interno al SAM3X8E è un orologio in tempo reale completo di orario e datario nonché di allarme per mese/giorno/ore/minuti/secondi (ancora da implementare). Le funzionalità sono accessibili mediante l’oggetto rtc. Le spiegazioni su come usarle sono contenute nel file RTC_MODULE.txt.

modulo TRNG (True Random Number Generator)

Il TRNG integrato è molto robusto ed ha passato i test NIST Special Publication 800-22 e Diehard. Esso è capace di generare 32 bit di entropia con elevata casualità (da qui il nome di “vero” generatore) ogni 84 cicli macchina. Le spiegazioni su come usare il generatore sono contenute nel file TRNG_MODULE.txt.

WDT – WatchDog Timer

Il WatchDog Timer è un contatore che può resettare il microcontrollore se il codice si infila in qualche vicolo cieco logico. L’utente può selezionare l’intervallo di reset fra 1 e 16000 ms.
IMPORTANTE: per usare questo modulo è necessario modificare un file del core originale (leggi il file /doc/WDT_MODULE.txt).

Licenza e garanzia

La libreria e gli esempi allegati sono rilasciati sotto licenza GNU General Public License 3.0. Il software è fornito così com’è, senza nessuna garanzia di funzionamento né di responsibilità per il suo utilizzo. Maggiori dettagli sono contenuti nel file README_FIRST.txt e nei file di documentazione contenuti nella cartella /doc.

Continua a leggere »]]> Atmel ha aggiornato la sua toolchain (la raccolta di eseguibili e librerie necessaria per compilare i firmware per i suoi microcontrollori) alla versione 3.4.2. Potete scaricare la nuova versione dal sito Atmel  (registrazione gratuita) in forma precompilata per Linux o Windows (al momento Atmel non distribuisce i binari precompilati per MacOS X). Una volta scaricato il pacchetto, bisogna sostituire la toolchain distribuita con l’IDE di Arduino e modificare alcuni file sia del core di Arduino sia del core Tiny, se lo avete eventualmente installato. Per fare ciò vi rimando a quest’altra mia guida.

Continua a leggere »]]>

LED clock

Vi presento il LED clock, un orologio a LED che visualizza l’orario usando la modalità decimale e dividendo i LED in colonne rappresentanti le decine/unità di ore, minuti e secondi. Rispetto agli orologi binari che si vedono in circolazione, la lettura è molto più immediata.

L’orologio utilizza un ATmega328P ed un PCF8563 come RTC esterno. Il pilotaggio avviene senza ricorrere al multiplexing per poter sfruttare tutta la luminosità dei LED, che sono da 10 mm per aumentarne la visibilità anche a distanza. Il circuito può modificare la luminosità dei LED in base alla luce ambientale della stanza in cui è posto.

Parte hardware

Il cuore del circuito è un ATmega328P alimentato a 5V con oscillatore interno a 8 MHz (ho tolto il quarzo esterno perché non mi serviva una frequenza operativa molto elevata, così ho risparmiato componenti). L’MCU pilota i LED usando 5 registri a scorrimento 74HC595 collegati a 5 array di Darlingthon ULN2803. In questo modo posso tenere i LED sempre accesi, evitando il multiplexing che, anche se di poco, riduce la luminosità della matrice. La corrente è fornita da un transistor PNP BDX54: pilotandolo in PWM posso anche modificare la luminosità dell’intera matrice, permettendo così al firmware di adattare la luminosità dell’orologio alla luce della stanza (riducendola di notte) in base alla lettura di una fotoresistenza.

L’alimentatore esterno deve fornire almeno 1 A di corrente, meglio se di più (io ho scelto un modello da 5 V/2,5 A). Tutti i LED accesi consumano sui 550 mA di corrente (~14 mA a LED), a cui va aggiunto il consumo degli altri componenti.

L’RTC scelto è il PCF8563, con una batteria di backup di tipo CR2032 che dovrebbe garantire una decina d’anni di funzionamento dell’RTC senza alimentazione principale. Grazie ai 2 diodi che separano la linea positiva della batteria da quella dell’alimentazione del circuito principale, la batteria alimenta l’RTC solo quando viene scollegato l’alimentatore esterno.

Parte software

Per compilare il firmware sono necessarie 3 librerie aggiuntive, scaricabili dai seguenti link:

PinChangeInt
Rtc_Pfc8563
leOS2

Il codice è stato scritto e testato su un Atmega328P (ma dovrebbe funzionare anche su un Atmega168P perché occupa poco meno di 9K di Flash e 445 byte di RAM [consumo statico]). Per impostare l’ATmega328P usate i seguenti fuse:

low fuses=0xE2
high fuses=0xDE
extended fuses=0×05

L’orologio funziona in questo modo. All’avvio, controlla se l’RTC sta girando oppure no, in caso negativo fa partire l’ora da 00:00:00. Per programmare l’orario basta premere il pulsante SET per più di 1,5 secondi. Il display fa un lampeggio accendendo tutti i led poi passa in modalità programmazione. Si programmano, in ordine: ore, minuti, secondi. Il principio è lo stesso per tutti: inizialmente viene visualizzato il valore corrente (attenzione al caso “0″ perché non vedete nessun led acceso), che potete aumentare o diminuire premendo i pulsanti INC e DEC. I led lampeggiano per farvi capire che siete in programmazione. Per confermare la scelta, premete SET. Dopo 10 secondi che l’utente non preme nessun tasto, il programma passa alla scelta seguente in automatico quindi dopo 30 secondi complessivi esce dalla programmazione da solo.
Alla fine della programmazione l’orario viene salvato localmente e sull’RTC (ricordo che dall’RTC l’orario viene prelevato solo 1 volta all’ora e che l’incremento dell’orario in locale viene fatta con un PCINT agganciato al pin CLK_OUT dell’RTC).

In modalità visualizzazione dell’ora, i pulsanti INC e DEC hanno 2 funzioni aggiuntive, che possono essere attivate premendoli per più di 1,5 secondi.
INC attiva/disattiva la funzione di variazione della luminosità dei led in base alla luminosità ambientale: massima durante il giorno o in piena luce, minima durante la notte o in ambiente buio. Questo per permettere di tenere l’orologio anche nella stanza in cui si dorme.
Il pulsante DEC attiva invece la “modalità notturna” (2 accensioni veloci di tutti i led conferma l’attivazione della modalità, 1 accensione di tutti i led conferma la disattivazione della modalità), ossia il display si spenge del tutto dalle 00:00:00 alle 05:59:59 per non disturbare durante le ore notturne.

Continua a leggere »]]> In un ritaglio di tempo ho scritto una nuova libreria che ho chiamato pRNG, acronimo di pretty Randon Number Generator, ossia Generatore di Numeri Casuali Carino.

La libreria fondamentalmente è un generatore di numeri pseudo casuali. Utilizza un interrupt sollevato dal WatchDog Timer per collezionare entropia usando un timer dell’Arduino (o del microcontrollore) ed un registro a scorrimento a retroazione lineare (in inglese LFSR, da Linear Feedback Shift Register) di Galois a 32 bit. I dati casuali sono prelevabili come singoli byte da un pool costantemente aggiornato. Il meccanismo permette di avere sequenze sempre diverse e mai ripetute (per lo meno non nel breve periodo).

Entriamo un pò nel dettaglio. Il WatchDog Timer è un circuito interno ai microcontrollori Atmel che principalmente viene usato (se attivato) per resettare il microcontrollore se questo si blocca nell’esecuzione di un codice senza uscita. Esso può però essere impostato anche per sollevare un interrupt, non solo per eseguire un reset (caratteristica che uso nella mia libreria leOS2). Sfruttando questa possibilità si può creare una ISR (Internet Service Routine) che periodicamente fa scorrere il registro: il registro restituisce in output un bit, bit che viene poi combinato tramite XOR con il bit meno significativo del contatore di un timer del microcontrollore ed il risultato che si ottiene viene inserito in un pool. Qui sotto potete vedere un registro a scorrimento a retroazione lineare: ingrandendo l’immagine verrà mostrata l’animazione in cui la retroazione è data da alcuni bit che sono reintrodotti nel registro quando un bit viene prelevato da esso.

Grazie a questo meccanismo la sequenza di bit generata appare semi casuale, ripetendosi solo dopo un elevato numero di estrazioni, e più è grande il registro maggiore è questo valore. L’uso del registro a scorrimento è il meccanismo usato che consente di avere sequenze molto complesse. Resta il problema della ripetibilità all’avvio. Ad esempio, la funzione random predefinita dell’Arduino in realtà di random non ha nulla dato che ad ogni avvio essa restituisce sempre la stessa sequenza numerica: pRNG, invece, ogni volta che viene avviato restituisce una sequenza diversa. Ciò è possibile perché il registro a scorrimento è usato in combinazione con un seme casuale sempre diverso per cui anche la sequenza che esso restituisce varia ogni volta.

Vediamo come viene estratto questo seme. Il WatchDog Timer riceve il clock da un oscillatore a 128 kHz mentre tutte le altre periferiche del microcontrollore, compresi i timer, ricevono il clock di lavoro dalla stessa fonte, che per le schede Arduino è il risuonatore ceramico esterno. Grazie alle tolleranze produttive, ogni componente viene realizzato diverso dagli altri con specifiche di funzionamento grosso modo uguali ma mai perfettamente identiche. Queste tolleranze sono responsabili della non perfetta precisione del segnale generato, che può subire delle oscillazioni rallentando oppure accelerando rispetto alla frequenza nominale. Sfruttando questo fatto, accade che quando viene chiamata la routine di interrupt del WatchDog ed andiamo a leggere il contatore del timer, può accadere che l’oscillatore del primo abbia avuto una leggera accelerazione rispetto al secondo o viceversa. Questa differenza permette ad ogni intervallo di leggere nel contatore del timer un valore leggermente differente. Questo è il meccanismo alla base della pRNG grazie al quale essa non genera mai la stessa sequenza di numeri casuali.

L’uso della libreria è molto semplice. Basta scaricare l’archivio e scompattarlo nella cartella /libraries contenuta nella propria cartella degli sketch. A questo punto basta includerla nel proprio sketch ed istanziarne una copia:

#include "pRNG.h"
pRNG prng;

Nel setup() va inizializzata prima dell’uso con il metodo begin():

void setup() {
prng.begin();
....


La libreria fornisce 3 metodi, getRndByte() per estrarre dal pool un byte casuale (0..255),  getRndInt() per estrarre un intero senza segno (0..65535), e getRndLong() per estrarre un intero lungo senza segno (0..4294967295):

byte valByte = prng.getRndByte();
unsigned int valInt = prng.getRndInt();
unsigned long valLong = prng.getRndLong();


Una nota a riguardo del pool di numeri. Esso ha una dimensione predefinita di 10 byte (modificabile nel file pRNG.cpp) e viene popolato bit per bit a partire da quello meno significativo del primo byte fino al bit più significativo dell’ultimo byte. Una volta raggiunta l’estremità del pool, l’algoritmo riparte dall’inizio. Quando si estrae un byte, viene prelevato il primo byte dal pool e tutti quelli successivi vengono spostati indietro di una posizione per occupare lo spazio vuoto che si è creato. Se nel pool non sono disponibili almeno 8 bit, verrà atteso finché non sarà pronto 1 byte di entropia. Questa cosa è da tenere a mente perché richieste continuative di numeri casuali saranno evase solo quando i dati saranno disponibili. Il WatchDog Timer è impostato con il minimo prescaler possibile, che genera un interrupt circa ogni 16 millisecondi, per cui per ottenere 1 byte di entropia sono necessari circa 8*16=96 ms.

La libreria è compatibile con tutti i microcontrollori Atmel ad accezione dell’ATmega8 perché il suo WatchDog Timer non è capace di sollevare un interrupt.

IMPORTANTE

la libreria NON deve essere utilizzata nel caso si richieda un VERO generatore di numeri casuali perché non è garantito che la pRNG non fornisca ad un certo punto una sequenza ripetibile di numeri. Nel caso si necessiti di più sicurezza, è bene rivolgersi a sistemi di generazione di numeri casuali diversi.

IMPORTANTE PER GLI UTENTI DELLA ARDUINO MEGA/MEGA2560
Il bootloader originale delle schede Arduino MEGA e MEGA2560 non disattiva il watchdog al riavvio del microcontrollore per cui si incorre in un reset infinito che blocca il chip. Per evitare questo problema, se si vuole usare la pRNG bisogna sostituire il bootloader con uno aggiornato che è esente da questo problema. Il bootloader è prelevabile da questa pagina.

Continua a leggere »]]> La gran varietà di schede Arduino può mettere in crisi il neofita che per primo si avvicina al mondo dell’elettronica e vuole farlo con uno di questi prodotti. Cerchiamo di capire come scegliere il prodotto migliore per le nostre esigenze, sia nel caso si cerchi una scheda per iniziare sia che se ne cerchi una più performante di quella che abbiamo già.

In questo articolo analizzeremo le caratteristiche principali di ogni scheda e vedremo quali sono i punti che possono influenzare la scelta finale.

Sfatiamo subito un mito: “più potente non vuol dire migliore”. Come ogni altro prodotto, anche una scheda Arduino va scelta in base al progetto da realizzare e non leggendo semplicemente le caratteristiche tecniche. Vediamo le schede principali dell’offerta di Arduino.

Arduino UNO

Questa è l’Arduino per antonomasia. La UNO, diretta erede della precedente Duemilanove, è una scheda compatta, facile da utilizzare e ben supportata sia a livello hardware che software.

Arduino UNO R3

La scheda è basata sull’ATmega328P di Atmel, un microcontrollore ad 8 bit che lavora a 16 MHz di clock. La connessione al PC è assicurata da una porta USB standard che, grazie al bootloader Optiboot installato sul chip, permette di fare l’upload dei programmi in modo molto semplice direttamente dall’ambiente di sviluppo. E’ presente sulla scheda anche un connettore jack japan per alimentare l’Arduino da una fonte esterna in caso di installazioni in progetti standalone. La scheda opera a 5 Volt ed è facilmente utilizzabile con una gran varietà di hardware perché il layout della scheda, con gli header montati in maniera asimmetrica, deriva dalla Duemilanove (a sua volta derivata dalla Diecimila), e questa retrocompatibilità permette di usare tutti gli shield in circolazione prodotti fino ad oggi. A livello software esistono tantissime librerie che permettono di utilizzare un sacco di componenti elettronici quali sensori, driver per matrici di led, shift register, chip di memoria, ecc…

Caratteristiche tecniche principali:

• MCU: Atmel ATmega328P a 16 MHz
• Memoria Flash (programma): 32 kB (512 byte sono riservati al bootloader)
• Memoria SRAM (per le variabili del programma):  2048 byte
• Memoria EEPROM (per salvataggio di impostazioni o altro): 1024 byte
• Pin di I/O: 20, di cui 14 I/O digitali e 6 usabili I/O digitali oppure come input analogici
• PWM: 6 pin
• ADC: 6 canali a 10 bit
• Tensione operativa: 5 V
• Comunicazione: 1 Seriale – 1 I2C – 1 SPI

Arduino MEGA2560

L’Arduino MEGA2560 è stata sviluppata per venire incontro alle esigenze degli utenti che necessitano di una scheda con più linee di I/O e più memoria per gli sketch.

Arduino MEGA2560

La MEGA2560 è basata sull’omonimo microcontrollore Atmel ATmega2560 ad 8 bit operante a 16 MHz, che offre 8 volte la memoria dell’ATmega328P della UNO e ben 70 pin, di cui 54 digitali e 16 ingressi analogici usabili anche come I/O digitali. Come la UNO utilizza un chip ATmega16U2 programmato per fungere da convertitore seriale/USB così da poter essere connessa direttamente al PC. La tensione di funzionamento è 5 V. Il layout riprende quello della UNO nella metà di sinistra, aggiungendo altri connettori nella parte destra per i pin in più. Essendo il chip della stessa famiglia AVR ad 8 bit di quello della UNO ed essendo il compilatore identico, i programmi generici scritti per la UNO girano senza modifiche anche sulla MEGA2560. Inoltre il team di sviluppo ha cercato di mantenere sui pin in comune con la UNO le stesse funzionalità base per cui il led integrato è sul pin 13 anche sulla MEGA, la seriale è sulla coppia D0/D1 e così via. Solo i programmi che utilizzano in maniera diretta l’hardware della UNO possono avere problemi di compilazione, così come i programmi scritti specificatamente per la MEGA2560 possono non funzionare sulla UNO.

Caratteristiche tecniche principali:

• MCU: Atmel ATmega2560 a 16 MHz
• Memoria Flash (programma): 256 kB (8 kB sono riservati al bootloader)
• Memoria SRAM (per le variabili del programma):  8 kB
• Memoria EEPROM (per salvataggio di impostazioni o altro): 4 kB
• Pin di I/O: 70, di cui 54 I/O digitali e 16 usabili I/O digitali oppure come input analogici
• PWM: 15 pin
• ADC: 16 canali a 10 bit
• Tensione operativa: 5 V
• Comunicazione: 4 Seriali – 1 I2C – 1 SPI

Arduino LEONARDO

La LEONARDO è una scheda recente basata sul microcontrollore ATmega32U4.

Arduino LEONARDO

Rispetto ai chip della UNO e della MEGA2560, questo integra il convertitore seriale/USB in hardware per cui può essere collegato direttamente al computer senza microcontrollori intermedi. Anzi, questa caratteristica permette alla scheda di essere riconosciuta dal sistema operativo come una periferica HID (Human Interface Device) tipo un mouse o una tastiera: la LEONARDO ha librerie specifiche che permettono di poter simulare appunto questi dispositivi in modo da poter spedire un tasto al sistema oppure muovere il puntatore del mouse o far leggere un click. A parte questa particolarità la LEONARDO è molto compatibile con la UNO: presenta lo stesso layout e la stessa disposizione dei pin. Le uniche differenze riguardano la gestione della seriale, che sulla LEONARDO è fatta, come detto, in maniera diretta per cui per accedere ai pin RX e TX è stata creata una classe Serial1, mentre la Serial classica indica al chip di comunicare col computer. Oltre a questo, il chip ha anche 12 ingressi analogici rispetto ai 6 della UNO: gli ingressi in più sono indicati sul retro della scheda con una didascalia aggiuntiva. Il chip è leggermente differente a livello hardware per cui bisogna prestare attenzione nell’uso di software che accede in maniera diretta all’hardware dell’ATmega328P perché esso potrebbe non girare sull’ATmega32U4. Altra differenza è la porta Micro-USB per la connessione al PC, che necessita dell’uso di un cavetto tipo quello dei cellulari più recenti.

Caratteristiche tecniche principali:

• MCU: Atmel ATmega32U4 a 16 MHz
• Memoria Flash (programma): 32 kB (4 kB sono riservati al bootloader)
• Memoria SRAM (per le variabili del programma):  2,5 kB
• Memoria EEPROM (per salvataggio di impostazioni o altro): 1 kB
• Pin di I/O: 20, di cui 8 I/O digitali e 12 usabili I/O digitali oppure come input analogici
• PWM: 7 pin
• ADC: 12 canali a 10 bit
• Tensione operativa: 5 V
• Comunicazione: 1Seriale  – 1 I2C – 1 SPI

Arduino ETHERNET

L’Arduino ETHERNET è una scheda pensata per chi necessita di un prodotto che integri le possibilità di programmazione di una Arduino con le potenzialità offerte dallo shield Ethernet per l’accesso ad internet. La scheda monta infatti sia l’ATmega328P che il controller ethernet Wiznet W5100, entrambi in formato SMD.

Arduino ETHERNET

Per essa esiste anche un modulo aggiuntivo denominato POE (Power Over Ethernet) che permette alla scheda di prendere l’alimentazione direttamente dal cavo ethernet. La scheda è offerta anche con il modulo POE già saldato. In cosa differisce la ETHERNET dalla UNO? Nel fatto che non c’è la porta USB per il collegamento al computer, sostituita dalla porta RJ45, per cui la programmazione può essere effettuata solo tramite il connettore laterale che va collegato ad un convertitore seriale/USB esterno. Altra differenza è la presenza dello slot per schede micro-SD, una scelta questa dettata dal fatto che la Ethernet viene spesso utilizzata per ospitare piccoli server e sulla schedina vengono memorizzate le pagine HTML da visualizzare sui browser. Per il resto, la ETHERNET è una UNO a tutti gli effetti, con l’unica limitazione che alcuni pin sono riservati a particolari funzioni: 4 sono utilizzati per la programmazione via SPI; altri 4 per la connessione con la micro-SD e 2 per la comunicazione con il controller W5100.

Caratteristiche tecniche principali:

• MCU: Atmel ATmega328P a 16 MHz
• Memoria Flash (programma): 32 kB (512 byte sono riservati al bootloader)
• Memoria SRAM (per le variabili del programma):  2048 byte
• Memoria EEPROM (per salvataggio di impostazioni o altro): 1024 byte
• Pin di I/O: 20, di cui 14 I/O digitali e 6 usabili I/O digitali oppure come input analogici
• PWM: 6 pin
• ADC: 6 canali a 10 bit
• Tensione operativa: 5 V
• Comunicazione: 1 Seriale – 1 I2C – 1 SPI

Arduino DUE

L’Arduino DUE è una scheda molto particolare. E’ un prodotto di fascia alta, destinata ad un’utenza esperta che ricerca prestazioni avanzate. E’ infatti basata sull’Atmel SAM3X8E, un microcontrollore a 32 bit che integra un core ARM Cortex-M3 ed opera a 84 MHz di clock.

Arduino DUE R3

Il SAM3X è una MCU che offre una grande varietà di periferiche integrate, a cominciare da un RTC hardware per finire a due DAC, alcune non supportate dalle librerie di sistema come l’Ethernet MAC 10/100. Altra differenza sostanziale è il fatto che essa opera a 3,3 V contro i 5 V delle altre schede. Questo fatto va tenuto a mente quando si collegano dispositivi esterni operanti a 5 V ma anche shield non recenti sviluppati per la UNO e la MEGA2560. Solo gli shield più recenti, sviluppati per il layour R3, possono essere montati sulla DUE senza correre il rischio di danneggiarla. Questo perché con il layout R3 è stato introdotto un pin denominato IOREF che serve ad informare lo shield della tensione a cui lavora la scheda sottostante.

Caratteristiche tecniche principali:

• MCU: Atmel SAM3X8E a 84 MHz
• Memoria Flash (programma): 512 kB
• Memoria SRAM (per le variabili del programma):  96 kB
• Pin di I/O: 66, di cui 54 I/O digitali e 12 usabili I/O digitali oppure come input analogici
• PWM: 12 pin
• ADC: 12 canali a 10 bit
• DAC: 2 a 12 bit
• Tensione operativa: 3,3 V
• Comunicazione: 4 Seriali – 2 I2C – 1 SPI – 1 CAN

La scheda è dotata di 2 porte Micro-USB, una stranezza presto spiegata: nonostante il chip SAM3X8E integri il convertitore USB, per la programmazione è raccomandato l’utilizzo della porta denominata “Programming Port” per via del fatto che il chip ATmega16U2 utilizzato per comunicare con il PC esegue un “hard reset” del SAM3X8E, una procedura che permette una programmazione più sicura rispetto a quella che si ottiene facendo l’upload dalla porta denominata “Native USB port”, che invece avvia la programmazione con un “soft reset”. Se poi il chip va in crash per qualche motivo, il “soft reset” potrebbe non funzionare, e l’uso dell’”hard reset” potrebbe essere l’unico modo valido per poter riprogrammare la scheda. La DUE presenta anche un pulsantino con l’etichetta “ERASE”, premendo il quale si cancella completamente il contenuto della Flash. Altra differenza rispetto alle altre schede è che il bootloader è residente in ROM ed è scritto direttamente da Atmel. Insomma, una scheda particolare destinata ad un’utenza particolare.

Arduino MICRO

Di tutte le schede secondarie prodotte col marchio Arduino (Mini, Pro, LilyPad, Nano ecc…) voglio citare l’Arduino MICRO, anch’essa arrivata di recente sul mercato.

Ardino MICRO

Progettata in collaborazione con Adafruit (come ricorda la scritta sul lato inferiore della scheda), questa MICRO tiene fede al proprio nome essendo una scheda veramente miniaturizzata: grazie all’uso dell’ATmega32U4, non serve un convertitore seriale/USB per collegarla al computer. Le sue dimensioni sono così di 4,8 x 1,77 cm. Tutte le linee di I/O del chip sono riportate sui connettori inferiori, risultando una LEONARDO a tutti gli effetti.

Caratteristiche tecniche principali:

• MCU: Atmel ATmega32U4 a 16 MHz
• Memoria Flash (programma): 32 kB (4 kB sono riservati al bootloader)
• Memoria SRAM (per le variabili del programma):  2,5 kB
• Memoria EEPROM (per salvataggio di impostazioni o altro): 1 kB
• Pin di I/O: 20, di cui 8 I/O digitali e 12 usabili I/O digitali oppure come input analogici
• PWM: 7 pin
• ADC: 12 canali a 10 bit
• Tensione operativa: 5 V
• Comunicazione: 1Seriale  – 1 I2C – 1 SPI

Un regolatore sulla scheda permette di alimentarla con un alimentatore esterno. La programmazione può essere fatta utilizzando anche il connettore ICSP integrato.

Quale fa per noi?

Alla fine dell’analisi, abbiamo più dati per scegliere la scheda correttamente:

1. stiamo iniziando ora? cerchiamo una scheda di uso generale, con un ricco parco librerie e la possibilità di accedere ad un numero consistente di shield di espansione? Allora la scelta giusta è la UNO. E’ facile usarla, è la scheda per la quale è stato scritto il maggior numero di guide inrete, gli shield permettono di aggiungere funzionalità extra senza ricorrere al saldatore, uno strumento che spesso è visto di cattivo occhio dal neofita. Inoltre il chip ATmega328P è in formato DIP28 (Dual In-line Package a 28 pin) e lo si può sostituire facilmente in caso lo si bruci per errore (può capitare). La possibilità di rimuovere il chip permette anche di creare versioni standalone dei propri progetti dove il microcontrollore programmato può essere estratto e montato su un circuito e sostituito sull’Arduino da un altro nuovo (con opportuno bootloader precaricato) in modo da riusare la schedina.
2. Vogliamo comandare il computer? cerchiamo un modo facile per spedire comandi al sistema tipo simulare la pressione di un tasto o il click di un mouse? Allora la scheda giusta è la LEONARDO. Grazie al fatto che il suo microcontrollore integra l’hardware necessario per comunicare via USB col sistema operativo, essa è vista da quest’ultimo come una periferica HID e può quindi essere utilizzata come periferica di input. La Arduino ESPLORA, una scheda che replica un gamepad, è basata proprio su un ATmega32U4. A parte questo, la LEONARDO è compatibile con la UNO per molti aspetti e molto del software e degli shield per la UNO girano anche su di essa.
3. Cerchiamo una scheda con un sacco di linee di I/O e con tanta memoria per il nostro programma? Allora la MEGA2560 è scheda da acquistare. La MEGA2560 ha 70 pin, divisi fra ingressi digitali e analogici, e può quindi risultare indispensabile in caso si realizzino progetti dove l’Arduino deve poter dialogare con dispositivi che richiedono diverse connessioni (esempio: display). La MEGA2560 offre inoltre 256 kB di Flash, 8 volte lo spazio offerto dalla UNO, permettendo quindi di scrivere programmi molto complessi e che usano molte librerie extra. La MEGA2560 può inoltre far girare molto del software scritto per la UNO, a meno che non siano usate periferiche specifiche dell’ATmega328P.
4. Stiamo cercando un microcontrollore molto potente e capace di eseguire una grosse mole di calcoli per unità di tempo? L’Arduino DUE è la risposta. La DUE è una scheda nata per venire incontro alle esigenze di un’utenza di tipo avanzato, che cercano un prodotto della famiglia Arduino ma che offra potenza maggiore. Il target della DUE è ad esempio l’utilizzo in sistemi di volo autonomo in progetti di quadricotteri oppure di interazione con l’ambiente per robot semoventi. La compatibilità con le altre schede è molto limitata, praticamente ridotta alle funzioni base del core: l’architettura a 32 bit e le periferiche integrate nel SAM3X8E ne fanno un prodotto del tutto diverso.
5. Non ho citato la ETHERNET e la MICRO. Sono schede particolari, richieste solo da una particolare utenza. La ETHERNET è in pratica una UNO con lo shield ETHERNET integrato, è comoda per risparmire dei soldi ma per contro si paga il fatto di dover usare un programmatore esterno. La MICRO è comodissima per progetti in cui la compattezza deve essere al primo posto dei punti da rispettare, da ricordare che è però basata su un ATmega32U4 e non sull’ATmega328P della UNO per cui particolari librerie potrebbero non funzionare.

Conclusioni

Se state per acquistare la vostra prima scheda, prendete la UNO: è fatta apposta per i principianti. E’ facile da usare, tollera i 5 V che è la tensione della logica TTL, si può sostituire il suo chip in caso di danneggiamento o per montarlo in standalone. Sempre se siete neofiti, non fatevi prendere dalla bramosia di comprare la DUE pensando che “più grande è meglio”: la DUE non è una scheda pensata per iniziare ma per chi ha già una buona base e sa cosa sta maneggiando. Già il fatto che la sua tensione operativa sia di 3,3 V causa non pochi problemi ai neofiti, a causa del fatto che molti dei prodotti in circolazione sono stati pensati per la UNO ed i suoi 5 V. Solo recentemente il team di sviluppo ha introdotto il layout R3 che, grazie al pin IOREF, permette allo shield compatibile di adeguare la tensione a quella della scheda. Ma per gli shield di vecchia concezione bisogna controllare in anticipo. Inoltre molte delle librerie in circolazione non funzionano con la DUE. Anche in questo caso bisogna controllare in anticipo.

Continua a leggere »]]> Millis() è una funzione del core di Arduino che restituisce il numero di millisecondi trascorsi dall’istante in cui si fornisce l’alimentazione alla scheda. Millis() si basa su di un contatore che viene aggiornato continuamente da un interrupt agganciato al timer 0, e per questo motivo il suo valore cresce costantemente, non essendo influenzato dal codice dell’utente.

Possiamo usare millis() per programmare l’esecuzione di alcune azioni, come se fosse un timer che dà la sveglia al nostro codice senza per questo bloccare l’esecuzione del medesimo in attesa che arrivi il momento giusto.

Iniziamo con un semplice test, il lampeggio di un LED. L’IDE di Arduino fornisce un esempio famosissimo, chiamato “Blink”. Quella che segue è la versione quasi originale:

const byte led = 13;
void setup() {
  pinMode(led, OUTPUT); // initialize the digital pin as an output.
}
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

Questo codice non fa altro che mettere su HIGH il pin del LED integrato, attendere 1000 ms (1 secondo), metterlo a LOW, attendere 1000 ms e poi ripartire dall’inizio.

Questo sketch funziona ma ha un grosso limite: durante l’attesa del delay(1000) il microcontrollore non può fare altro. Se modificate lo sketch inserendo un Serial.print dopo il secondo delay vedrete che la scritta compare sul monitor seriale dopo ben 2 secondi:

const byte led = 13;
void setup() {
  Serial.begin(19200);
  pinMode(led, OUTPUT); // initialize the digital pin as an output.
}
void loop() {
  digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
  delay(1000); // wait for a second
  digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
  delay(1000); // wait for a second
  Serial.println("Test...");
}

Un modo per aggirare il problema ci viene dall’esempio BlinkWithoutDelay sempre dell’IDE. La versione qui sotto l’ho rielaborata per renderla più compatta:

const int ledPin =  13;      // the number of the LED pin
int ledState = 0;             // ledState used to set the LED
unsigned long previousMillis = 0;        // will store last time LED was updated
unsigned long interval = 1000;           // interval at which to blink (milliseconds)
void setup() {
  pinMode(ledPin, OUTPUT); // set the digital pin as output:
}

void loop() {
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis; // save the last time you blinked the LED
    // if the LED is off turn it on and vice-versa:
    ledState ^= 1;
    digitalWrite(ledPin, ledState);
  }
}

Questo esempio fa il suo dovere senza bloccare il codice: ad ogni esecuzione del loop() controlla se la differenza fra il valore attuale di millis() e quello del precedente lampeggio è maggiore dell’intervallo impostato, nel caso cambia lo stato del LED. Se mettete il solito Serial.print alla fine del loop() vedrete che questa volta la seriale vi si riempirà di scritte senza fermarsi mai.

E se i compiti da svolgere solo più di 1? Possiamo usare due coppie di variabili per memorizzare il tempo di lampeggio. Una possibile è questa:

const byte ledPin =  13;      // the number of the LED pin
byte ledState = 0;             // ledState used to set the LED
unsigned long previousMillis1 = 0;        // will store last time LED was updated
unsigned long interval1 = 100;           // interval at which to blink (milliseconds)
unsigned long previousMillis2 = 0;
unsigned long interval2 = 1000;
unsigned int counter = 0;

void setup() {
  Serial.begin(19200);
  delay(2000);
  pinMode(ledPin, OUTPUT); // set the digital pin as output:
}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis1 > interval1) {
    previousMillis1 = currentMillis; // save the last time you blinked the LED
    // if the LED is off turn it on and vice-versa:
    ledState ^= 1;
    digitalWrite(ledPin, ledState);
  }
  currentMillis = millis();
  if (currentMillis - previousMillis2 > interval2) {
    previousMillis2 = currentMillis; // save the last time you blinked the LED
    // if the LED is off turn it on and vice-versa:
    Serial.println(++counter);
  }
}

Questo programma esegue 2 compiti: il primo è il lampeggio del LED integrato ogni 100 ms, il secondo è la stampa di un contatore sulla seriale ogni 1000 ms. Ogni compito viene eseguito correttamente perché il programma, non usando delay(), non si blocca in attesa che passi il tempo prefissato per l’esecuzione di ognuno dei 2 compiti.

Volendo migliorare la gestione dei compiti da svolgere, la soluzione è l’utilizzo di looper, una libreria che ho scritto per eseguire diversi compiti predefiniti dall’utente.

Continua a leggere »]]> Ho rilasciato la versione 1.0 del looper, il mio schedulatore che non usa gli interrupt per lanciare i job dell’utente:

• nuova sintassi dei metodi, per poter essere usato in abbinamento al leOS;
• ripulitura del codice grazie a cui gli sketch compilati sono più piccoli;
• nuovo metodo myDelay che sostituisce la funzione delay di Arduino e con la quale si può inserire un’attesa nel codice permettendo allo scheduler di continuare ad eseguire i job dell’utente.

La nuova versione è scaricabile da questa pagina.

Continua a leggere »]]> Se vogliamo accendere un LED collegato ad un pin dell’Arduino sappiamo che dobbiamo, nell’ordine:

1) impostare il pin come OUTPUT usando il comando pinMode;
2) “scrivere” su quel pin il valore HIGH usando il comando digitalWrite.

Sembra semplice ma se andiamo ad analizzare il codice del core di Arduino ci accorgiamo che non lo è. La semplicità dell’IDE di Arduino permette sì di fare quest’operazione con 2 istruzioni ma nel “retrobottega” le operazioni che vengono eseguite sono diverse, perché il core di Arduino deve effettuare una serie di calcoli per trasformare il numero di pin nel corrispondente piedino fisico e poi ancora controllare se quel pin è collegato ad un timer, nel caso disattivare l’eventuale segnale PWM che ci può essere collegato. Solo allora il pin viene impostato come si vuole.

Se non si ricerca una grande velocità tutti questi passaggi, che vengono eseguiti tutte le volte che invochiamo tali istruzioni, possono anche non disturbare, ma se vogliamo fare le cose in modo più rapido e diretto la soluzione è solo una: bisogna manipolare direttamente le porte logiche del microcontrollore.

Un microcontrollore è un dispositivo elettronico e come tale non esistono dei meccanismi che vengono azionati per impostare i piedini ma tutto è fatto a livello digitale. Esistono dei particolari registri mappati in memoria che contengono lo stato di ogni singola linea di input/output (I/O) del microcontrollore: “mappati in memoria” significa che questi registri sono accessibili tramite delle particolari locazioni di memoria poste in una zona di SRAM non utilizzata per il salvataggio dei dati del programma dell’utente. Ogni registro rappresenta lo stato di una porta logica: una porta logica è l’insieme dei bit collegati ad un gruppo di piedini fisici della MCU. Leggendo o scrivendo in questi registri si manipola in maniera diretta lo stato dei pin.

Le porte logiche degli Atmel della serie AVR ATtiny e ATmega sono ad 8 bit, per cui ogni porta logica contiene lo stato di 8 pin del microcontrollore. A lato vedete la piedinatura dell’ATmega328P montato sull’Arduino UNO: ogni pin è identificato da una sigla come PD0, PC1 o PB2. Ad esempio, PD0 identifica il pin 0 della porta logica “D”. L’ATmega328P ha 23 linee di I/O raggruppati in 3 porte logiche da 8 bit l’una denominate B, C e D.

Ogni porta è gestita da 3 registri. Prendendo come esempio la porta D, questi registri sono:

• DDRD
  questo registro è di lettura/scrittura e contiene la direzione dei pin ad esso collegati. Un bit a 0 rappresenta un pin impostato come INPUT; un bit ad 1 rappresenta un pin impostato come OUTPUT;
• PORTD
  questo registro è di lettura/scrittura e contiene lo stato dei pin. Questo stato cambia a seconda della direzione del pin:
  - se il pin è impostato come INPUT, un bit ad 1 attiva la resistenza di PULL-UP, mentre un bit a 0 la disattiva;
  - se il pin è impostato come OUTPUT, un bit ad 1 indica uno stato HIGH sul relativo pin, mentre un bit a 0 indica la presenza dello stato LOW sullo stesso pin.
• PIND
  questo registro è di sola lettura e contiene, nel caso di un pin impostato come INPUT, la lettura del segnale collegato al pin: 1 per un segnale alto (HIGH); 0 per un segnale basso (LOW).

Da ciò si capisce subito come per impostare un pin come OUTPUT con un livello HIGH basta impostare la direzione con il registro DDRx ed il suo stato con il registro PORTx. Non preoccupiamoci degli indirizzi di questi registri: sarà il compilatore avr-gcc che trasformerà le istruzioni su questi registri nelle giuste istruzioni in linguaggio macchina necessarie a scrivere in quelle locazioni di memoria.

Facciamo un esempio pratico. Vogliamo impostare il pin PD2 come OUTPUT con livello in uscita HIGH. L’immagine seguente rappresenta la coppia di registri che andremo a manipolare, con evidenziato il bit interessato, il bit n° 2 (3^a posizione):

Nel registro DDRD scriveremo “1″ nel bit DDR2 per impostare il pin PD2 come OUTPUT, mentre nel registro PORTD imposteremo ad “1″ il bit PORTD2 per attivare il segnale HIGH.

La soluzione che viene subito in mente è la seguente:

DDRD = 0b00000100;
PORTD = 0b00000100;

Sembra giusto, vero? Invece è sbagliato! In questo modo infatti modifico TUTTI i bit dei 2 registri, alterando tutte le linee di I/O della porta D, non solo quella che ci serve. Quindi come possiamo fare?

In nostro aiuto vengono le operazioni di algebra booleana OR ed AND. La prima è detta disgiunzione logica mentre la seconda congiunzione logica. Facciamo un veloce ripasso delle tabelle della verità di entrambe:

Analizziamo l’OR logico. Basta che uno dei due valori sia pari ad 1 affinché anche il risultato dell’operazione lo sia. L’unico caso in cui il risultato di un OR è uguale a 0 è quando entrambi i valori A e B sono pari a 0. Nell’AND logico, invece, la situazione è opposta: basta che uno solo dei due valori A e B sia pari a 0 che il risultato sarà anch’esso 0. L’unico modo per avere un risultato uguale ad 1 è quello in cui entrambi i valori A e B sono pari ad 1.

L’operatore OR è ciò che ci serve per “accendere” un bit, ossia impostarlo ad 1: basta infatti fare l’OR fra il valore del bit ed 1 per esser certi che il risultato sia 1. Per completare il nostro compito ci serve un altro operatore, quello di scorrimento <<. La sintassi di questo operatore binario (che opera cioè sui bit) è la seguente:

VALORE << SPOSTAMENTO

Esso cioè dice al compilatore: prendi “VALORE” e spostalo a sinistra di tanti posti (bit) quanti sono quelli indicati da “SPOSTAMENTO”. Alcuni esempi numerici:

1<< 2 = 100
101<<1 = 1010
1111<4 = 11110000

Adesso riprendiamo il nostro esempio: vogliamo impostare il pin PD2 come OUTPUT con livello HIGH. Per prima cosa dobbiamo impostare questo pin come OUTPUT ma, come detto, non vogliamo alterare il resto dei pin di quella porta:

DDRD = DDRD OR DDD2

DDD2 è il bit in posizione 2 del registro, per cui in codice C scriveremo così:

DDRD |= (1<<2)

Spieghiamo brevemente. Analizziamo prima la parte fra parentesi: diciamo al compilatore di prendere il bit 1 e di spostarlo in posizione 2 (2 spostamenti a sinistra). Poi diciamo al compilatore di prendere il valore di DDRD e di fare un OR logico con il risultato della precedente operazione e di rimettere il risultato in DDRD.

DDRD = DDRD | 0b00000100

In questo modo modificheremo solo il bit 2 lasciando inalterati i restanti bit. Analogamente, per mettere  il pin a livello logico HIGH faremo:

PORTD |= (1<<2)

che diventa

PORTD = PORTD | 0b00000100

Per “spengere” il bit, invece, usiamo l’operatore AND, perché basta fare un AND logico fra il valore 0 ed il bit che ci interessa per ottenere 0 come risultato dell’operazione. L’AND logico è però critico da usare perché può alterare facilmente gli altri bit visto che solo nel caso in cui entrambi i valori A e B sono pari ad 1 si ottiene come risultato ancora 1. In nostro aiuto viene il segno di inversione, ~. Questo operatore inverte il valore di un bit, o di tutti i bit di un byte.

Alcuni esempi:

~1 = 0
~0b0001000 = 0b11110111
~0b11001100 = 0b00110011


Riprendiamo l’esempio qui sopra e spengiamo il bit n° 2 della porta PORTD, ossia attiviamo un segnale logico LOW su PD2. Per fare ciò dobbiamo usare insieme l’operatore logico e l’operatore inverso.

PORTD = PORTD AND ~PD2

da cui si ottiene

PORTD &= ~(1<<2)

Cosa fa questo codice? Intanto iniziamo a svolgere l’operazione fra parentesi, che dà come risultato 0b00000100. Adesso entra in gioco l’operatore ~ che inverte il valore di tutti i bit di questo byte:

~0b00000100 = 0b11111011

Come ultima operazione si ha l’AND logico fra il valore del registro PORTD ed il byte 0b11111011. Siccome sappiamo che l’AND con 1 dà come risultato 1 nel caso il bit sia ad 1 e restituisce invece 0 nel caso il bit sia a 0, possiamo dire che l’unico bit che cambia di segno è proprio il nostro bit, dato che gli altri manterranno il loro valore originale. Ad esempio, se PORTD valesse 0b11001111, l’operazione sarebbe:

PORTD &= ~(1<<2)

da cui

PORTD = 0b11001111 & 0b11111011

con PORTD che assumerebbe il valore di

PORTD = 0b11001011

Tutti i bit manterranno il loro valore tranne il bit in posizione 2 (il 3°).