In questo nuovo articolo affronteremo la prima interazione Arduino-uomo, usando un pulsante che, quando premuto, invia un segnale ad Arduino. Il software che caricheremo, quando riceverà questo segnale, deciderà di accendere il led rosso.
Il pulsante (o pushbutton) è un componente che, quando premuto, connette due punti del circuito. Ci sono 5 pushbutton nel KIT Workshop che abbiamo acquistato all’inizio di questo viaggio alla scoperta di Arduino e ognuno di questi ha il seguente schema costruttivo:
In pratica i piedini A e C sono sempre connessi fra loro, così come i piedini B e D, mentre se il pulsante viene premuto, sono connessi tra loro tutti i piedini. Come possiamo utilizzare il pushbutton con Arduino? Basta seguire un tutorial, sul sito ufficiale, chiamato appunto Button e che permette di accendere un led quando viene premuto il pulsante. Ecco come si realizza.
Come si realizza questo circuito con pulsante? Colleghiamo il piedino A direttamente a terra (ad esempio uno dei pin etichettati con Gnd nella fila di pin chiamata POWER) e il piedino B prima ad una resistenza da 2.2 KOhm (ecco come è fatta) e poi all’alimentazione da 5 V. Come mostrato nello schema seguente, dobbiamo connettere il piedino B anche con il pin 2 che sarà quello che riceverà il messaggio “pulsante premuto”:
Il tutorial originale spiega che la resistenza da 2.2 KOhm ha una funzione cosiddetta di pull-up che serve ad evitare che il segnare sul pin 2 fluttui quando il pin viene disconnesso dal circuito. Durante le mie prove non ho però riscontrato fluttuazioni ma piuttosto, quando ho eliminato la resistenza sostituendola con un collegamento normale, un assorbimento eccessivo di energia che ha fatto decidere al Mac di disattivare momentaneamente la porta USB a cui Arduino era collegato (con conseguente riavvio del dispositivo). Osservando il funzionamento del circuito, che illustrerò qui di seguito, ho idea che la resistenza di pull-up serva sostanzialmente a forzare un livello logico (come il nostro HIGH) quando il circuito è aperto permettendo di andare su LOW non appena si chiude il circuito. Ma vediamo in dettaglio il circuito e di seguito ne illustrerò il funzionamento e il software da utilizzare:
Come funziona esattamente il circuito? Quando il pushbutton è aperto (ovvero, come abbiamo visto prima, non è premuto) non c’è nessuna connessione fra i due piedini che abbiamo usato, il piedino A e il B. In tale situazione (anche se attraverso la resistenza di pull-up) il pin 2 è connesso all’alimentazione da 5 V e quindi Arduino legge il pin ad un livello HIGH. Quando invece il pushbutton è premuto il circuito è chiuso e fra il piedino A e il B si crea una connessione, quindi il pin 2 si trova allo stesso potenziale della terra e Arduino leggerà quindi il valore LOW (ovviamente il pin 2 è ancora connesso con l’alimentazione a 5 V, ma la resistenza interposta fa sì che tale pin sia più vicino alla terra).
Viene a stabilirsi quindi la seguente corrispondenza:
Pulsante non premuto -> pin 2 a livello HIGH
Pulsante premuto -> pin 2 a livello LOW
A questo punto manca solo il codice da inviare ad Arduino, che non farà altro che ricevere il segnale dal pin 2 e reagire con una istruzione, nel nostro a caso al pin 13:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int ledPin =13;
int inPin =2;
int val =0;
void setup(){
pinMode(ledPin, OUTPUT);
pinMode(inPin, INPUT);
}void loop(){
val = digitalRead(inPin);
if(val == HIGH){
digitalWrite(ledPin, LOW);
}else{
digitalWrite(ledPin, HIGH);
}}
Più in dettaglio, le prime tre righe di codice dichiarano le variabili che impostano il pin 13 come collegamento al led rosso, il pin 2 come pin di entrata del segnale del pulsante, e che infine (con val) impostano il valore iniziale dello status del pin 2 (ovvero del pushbutton).
All’interno del blocco setup() avviene qualcosa di importante, ovvero viene impostato il led 13 come OUTPUT e, per la prima volta, il pin 2 come INPUT.
A questo punto, nel blocco loop(), la prima istruzione, in riga 11, non fa altro che leggere il valore di input, ovvero lo status del pulsante, tramite la funzione digitalRead().
Successivamente il blocco if controlla se il valore di input val è stato letto come HIGH e quindi accende il led rosso (riga 13), altrimenti, lo spegne.
Se volessimo invertire il funzionamento del pushbutton basterebbe scambiare LOW e HIGH nelle righe 13 e 15 del software (senza dover toccare il circuito).
Ma la caratteristica più importante di questo circuito e del software annesso è che le istruzioni di accensione e spegnimento del led sono solamente un esempio e quindi, una volta ricevuto l’input dal dito della persona che ha premuto il pulsante, Arduino può reagire virtualmente in qualsiasi modo. Il limite è il nostro ingegno.
In che senso? Mentre infatti è in esecuzione la funzione delay() (ad esempio per 1000 millisecondi), non possono essere eseguite altre istruzioni e, se il nostro obiettivo è quello di far interagire Arduino col mondo esterno, non avrebbe molto senso un blocco del dispositivo dal momento che, probabilmente, il mondo esterno non aspetterà pazientemente la fine dell’esecuzione della funzione delay()…
La soluzione è allora tenere traccia dell’istante in cui si è fatto accendere o spegnere il nostro led rosso e, ogni volta che il loop() viene eseguito, è sufficiente controllare se un intervallo di tempo minimo è passato. Se sì, il led va spento, o riacceso.
Vediamo come. Innanzitutto bisogna introdurre una nuova funzione denominata millis() che restituisce il numero di millisecondi trascorsi dall’inizio dell’esecuzione del programma (e si riazzera una volta ogni 50 giorni circa… sempre che teniate Arduino acceso per così tanto tempo).
int ledPin =13;
int value = LOW;
long previousMillis =0;
long interval =1000;
void setup(){
pinMode(ledPin, OUTPUT);
}void loop(){if(millis()- previousMillis > interval){
previousMillis = millis();
if(value == LOW)
value = HIGH;
else
value = LOW;
digitalWrite(ledPin, value);
}}
Le prime quattro righe dichiarano 4 variabili. Le prime due sono interi che stabiliscono il numero del pin a cui è connessa la zampa lunga del nostro led rosso (l’altra è sempre connessa al GND) e il valore iniziale di corrente al pin (LOW è come dire 0 Volt). Le seconde due variabili sono di tipo long (ovvero hanno la possibilità di immagazzinare valori numerici interi con molte più cifre del tipo int) e servono per memorizzare il valore in millisecondi restituito da millis() e l’attesa fra un’accensione e uno spegnimento del led rosso. Il fatto che anche interval sia una variabile long (pur avendo solo 4 cifre) è per permettere di eseguire correttamente la sottrazione in riga 13 fra tipi uguali di variabili.
In riga 8 settiamo il pin 13 come OUTPUT e poi entriamo nel blocco loop(). A questo punto, ad ogni esecuzione del ciclo, viene controllato se millis() - previousMillis è maggiore di interval, ovvero se è passato un tempo uguale o superiore a quello impostato come intervallo fra un’accensione e uno spegnimento. Se sì, in riga 14 viene subito impostato l’attuale valore di millis() come nuovo valore di previousMillis, pronto per la successiva esecuzione del loop().
Nelle righe dalla 16 alla 19 non viene fatto altro che controllare lo stato precedente del pin 13 e, in pratica, se il led è spento viene deciso di accenderlo, se è acceso viene deciso di spegnerlo. Nella riga 21 viene data esecuzione al comando digitalWrite() che, in base al valore della variabile value, agisce direttamente sui livelli del pin 13.
Fra la riga 22 e la 23 (quindi fuori dal primo costrutto if (iniziato in riga 13 e ancora dentro il loop()) possiamo inserire un numero qualsiasi di istruzioni che verranno eseguite immediatamente, senza attendere che siano passati i 1000 millisecondi impostati con interval.
Il prossimo tutorial introdurrà un primo esempio di interazione Arduino-essere umano. Come sempre se avete domande lasciate un messaggio, ehm, un commento.
L’espansione di cui ci occuperemo oggi è esclusivamente di tipo hardware, dal momento che il software da utilizzare (salvo una piccola modifica) è quello del primo Hello, Blink!. Ma per espandere l’hardware faremo uso di una breadboard, già presente nel KIT Workshop di cui abbiamo parlato nell’articolo introduttivo.
In poche parole, la breadboard (letteralmente tavola di pane) è una basetta provvista di numerosi fori connessi fra loro secondo uno schema a righe o colonne, ovvero:
A questo punto possiamo utilizzare la breadboard per costruire un circuito elettrico da collegare al nostro Arduino.
Innanzitutto immaginiamo di voler far lampeggiare un led rosso che sia connesso ad un pin diverso dal numero 13. Potremmo piegare le zampette del led per adattarle alla distanza da coprire ma questo, oltre ad essere antiestico, è certamente una soluzione che rischia di rovinare le zampette stesse e limita fortemente l’espansione futura, non permettendo la possibilità di inserire ulteriori componenti. L’idea è quindi quella di utilizzare la breadboard per realizzare delle connessioni elettriche (con dei cavi o con i ponticelli in dotazione con il KIT Workshop) in modo da scegliere facilmente da quale pin far alimentare il nostro caro led rosso.
Ecco come realizzarlo:
In pratica si due collegamenti verdi sono connessi con le due zampette del led rosso e le connettono con le prime due colonne della breadboard, le quali, a loro volta, sono connesse tramite i ponticelli rossi ai pin GND e 10 di Arduino.
In questo modo il programma Hello, Blink! può essere scritto nella seguente maniera
ovvero modificando in riga 1 il numero corrispondente al pin da alimentare. Ovviamente, se non si usa il pin 13, il led L incorporato in Arduino non lampeggerà .
Tre led lampeggianti alternativamente. A questo punto è facilmente implementabile una fila di led (nell’esempio 3, ma al massimo 14) che accendono e si spengono in sequenza. Innanzitutto bisogna collegare tutte e tre le zampe corte al GND e ognuna delle tre zampe lunghe a un differente pin, ad esempio il 2, 3 e 4.
Il codice che ho utilizzato per far illuminare alternativamente i tre led è il seguente:
int ledPinStart =2;
int numberOfPin =3;
int interval =500;
int i, j;
void setup(){for(j =0; j < numberOfPin; j++){
pinMode(ledPinStart + j, OUTPUT);
}}void loop(){for(i =0; i < numberOfPin; i++){for(j =0; j < numberOfPin; j++){
digitalWrite(ledPinStart + j, LOW);
}
digitalWrite(ledPinStart + i, HIGH);
delay(interval);
}}
Come si interpreta il codice? Il primo il costrutto for dentro la funzione setup() serve per settare tutti i pin come OUTPUT. Nel blocco loop() il primo costrutto for ne include un secondo allo scopo di abbassare il livello di tutti i pin a LOW (zero Volt) per poi, fuori dal for nidificato, alzare a HIGH (5 Volt) il livello di un solo pin, sequenzialmente corrispondente ai tre led rossi. Le variabili ledPinStart e numberOfPin permettono di impostare rispettivamente il numero più basso della fila di pin e il numero di led usati.
Nel precedente tutorial abbiamo analizzato riga per riga il primo esempio di programmazione per Arduino, ovvero Hello, Blink!. Oggi presenterò qualche semplice e piccola modifica ed espansione, sia software che hardware allo scopo di prendere dimestichezza con il linguaggio utilizzato, ma anche con il dispositivo stesso.
Ricordando che al funzione delay() non è altro che una pausa, espressa in millisecondi imposta ad Arduino prima di eseguire l’istruzione successiva, possiamo ovviamente giocare a modificarne il valore tra parentesi (ovvero l’argomento della funzione), aumentandolo o diminuendolo a piacere.
Provate ad esempio a scrivere nelle corrispondenti righe:
11
delay(2000);
e
13
delay(500);
Effettuando queste modifiche e inviando il programma ad Arduino, tramite il comando Command+U, avremo, dopo il solito scintillio di led L, TX e RX, un lampeggiare del led L che rimarrà acceso per 2 secondi e resterà spento per mezzo secondo.
Senza nemmeno dover piegare le zampe, inseriamo quella più corta nel pin contrassegnato con l’etichetta GND e quella più lunga nel famoso pin 13. Se non avete scollegato Arduino dall’alimentazione (o dalla porta USB), vedrete immediatamente il led illuminarsi secondo il ritmo stabilito dal programma.
Cosa abbiamo fatto? Semplicemente, siccome tutte le zampe corte dei led vanno messe a terra (da cui GND, ground in inglese vuol dire appunto terra) e siccome il pin 13 è, come abbiamo visto nel precedente tutorial, regolato sui 5 volt a intervalli regolari, il led rosso che abbiamo aggiunto viene alimentato esattamente come il piccolo e verde led L, e i due dovrebbero quindi lampeggiare all’unisono.
Ora qualcosa di divertente. Come prima cosa modifichiamo il programma in modo da creare una nuova variabile che chiameremo interval e assegniamole il valore di 1000. Dopo di che inseriamo tale variabile come argomento delle due funzioni delay(). Il nuovo listato del programma sarà quindi:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int ledPin =13;
int interval =1000;
void setup(){
pinMode(ledPin, OUTPUT);
}void loop(){
digitalWrite(ledPin, HIGH);
delay(interval);
digitalWrite(ledPin, LOW);
delay(interval);
}
A questo punto possiamo modificare solo il valore assegnato alla variabile interval in riga 2 per modificare automaticamente gli argomenti delle due funzioni delay(). La cosa divertente accade quando proviamo ad assegnare ad interval valori sempre più piccoli. Proviamo ad esempio a scrivere interval = 100. Cosa accade? Ovviamente il nostro led rosso comincia a lampeggiare come una luce natalizia.
Una breve digressione sul funzionamento del sistema visivo occhio-cervello ci fa capire la ragione di questo strano comportamento (non nascondo che appena provato ho istintivamente pensato ad un malfunzionamento o una limitazione di Arduino…). La persistenza della visione è un fenomeno che ci permette di credere che la sequenza di fotogrammi di un cartone animato sia una azione continua e non una serie di disegni statici (idem per i fotogrammi di un film). Alla stessa maniera anche la luce delle lampadine collegate ad una rete domestica a corrente alternata ci appare come stabile ma in realtà è un alternanza, appunto, di luce e buio, così rapida da non essere percettibile. Un tempo si pensava che questo fenomeno coinvolgesse la retina, ma ora è chiaro che è tutto un processo a livello della corteccia cerebrale, ovvero in poche parole, mentre la guardiamo, una immagine ci mette alcuni centesimi di secondi prima di perdere la sua luminosità originale e, se nel frattempo, è già pronta un’altra immagine, noi non siamo in grado di percepire il momento del cambiamento di immagine.
Nel caso del nostro led, se impostiamo un valore di interval di 20 ms vediamo chiaramente un lampeggiare (seppur frenetico) della luce, ma se interval è 18 ( o 16, 14, fino 11 ms) riusciamo a percepire solo un sempre più lieve tremolio. Quando interval = 10 il nostro cervello non ha fatto in tempo a cancellare, e neppure ad attenuare, l’immagine del led acceso che, dopo la pausa in cui il led rimane spento, è già ora di riaccenderlo.
In termini matematici, siccome la sequenza si compone di due delay() ognuno da 10 ms, questo significa che l’intera sequenza dura 20 ms, e quindi l’alternanza di accensioni e spegnimenti avviene 50 volte al secondo (50 x 20 ms = 1000 ms = 1 secondo), ovvero 50 Hz. Tenendo conto, però, che un lieve sfarfallio seppur invisibile può comunque essere fastidioso per l’occhio, la corrente alternata della rete domestica, cioè quella che fa funzionare le nostre lampadine, è sì fissata ad una frequenza di 50 Hz ma (dal momento che la corrente è alternata secondo un onda sinusoidale e rimane accesa sia a 220 V che a -220 V) la frequenza dell’intensità luminosa è doppia, ovvero di 100 Hz.
Ok, ma io non ci credo. Se siete arrivati a questo punto, con interval impostato a 10 ms, Arduino e il suo led apparentemente immobili, e la spiegazione che avete letto vi sembra plausibile ma non una dimostrazione che vi convinca in modo incontrovertibile… beh allora sappiate che avete una mentalità scientifica e tutta la mia stima.
A conti fatti, ci sono 4 immagini di led interi più 2 mezzi led alle due estremità della scia intermittente. Infatti, con interval = 10, se in un secondo ci sono 50 lampeggiamenti, in un decimo di secondo (la durata dello scatto) ce ne saranno 5.
Nel prossimo articolo realizzeremo un’altra espansione hardware. Nel frattempo, se avete domande, critiche o richieste, scrivete pure nei commenti.
Eccoci al secondo appuntamento con Arduino. Dopo aver semplicemente accesso il nostro amico, ora, seguendo i tutorial del sito web di Arduino, ci imbattiamo come primo programma d’esempio in Blink. Nella descrizione annessa a tale esempio viene spiegato come sia uso comune, in quasi tutti i linguaggi di programmazione, introdurre la sintassi e le prime funzioni con un software che mostri sullo schermo la classica frase Hello, World!. Ma dal momento che Arduino non ha uno schermo, faremo lampeggiare un led… in segno di saluto.
Come abbiamo notato nel precedente articolo introduttivo, sono installati su Arduino almeno due led: il primo è arancione ed è contrassegnato dall’etichetta PWR (che sta per power) e segnala se c’è alimentazione, mentre il secondo è verde ed ha l’etichetta L e per quel che sappiamo, per ora, il suo unico scopo e quello di essere un led, appunto.
Questo secondo led chiamato L è connesso al pin 13, quindi: inviare corrente al pin 13 significa accendere il led L. Ricordiamocelo.
Apriamo il software Arduino e copiamo il seguente codice (in alternativa lo si può prelevare dal menu File>Sketchbook>Examples>Digital>Blink)
prima di inviarlo ad Arduino, vediamo in dettaglio come si legge questo codice (che è scritto in linguaggio C) e cosa ordina di fare al dispositivo.
La riga 1 del codice recita int ledPin = 13; e non fa altro che impostare una variabile chiamata ledPin (ma la si può chiamare come si vuole) al valore 13. Ricordatevi sempre il punto e virgola alla fine di una istruzione, comprese quelle all’interno dei blocchi definiti dalle parentesi graffe.
La riga 3 apre, con il comando void setup(), una sezione entro la quale si possono settare alcuni parametri iniziali di Arduino. In questo caso, in riga 5, il comando pinMode(ledPin, OUTPUT); non fa l’altro che imporre ad Arduino uno specifico uso per il pin 13, cioè come output. In parole povere con questo comando stiamo dicendo che il pin 13 non dev’essere usato per raccogliere informazioni (input) ma per mostrare informazioni (output).
Il gruppo successivo di istruzioni, introdotto dal comando void loop(), descrive la sequenza di istruzioni che Arduino deve eseguire continuamente. Loop infatti sta per ciclo, e tutto ciò che si trova tra le rige 10 e 13 viene ripetuto all’infinito.
La riga successiva, la 11, ordina ad Arduino di attendere per un secondo esatto e lo fa tramite il comando delay(1000); il cui valore tra parentesi è espresso in millisecondi.
La riga 12 imposta il valore del pin 13 su LOW, lo zero digitale, zero anche in Volt.
L’ultima riga del blocco è identica alla riga 11, e serve ad attendere un altro secondo prima di ripetere l’intero ciclo.
Ok, abbiamo parlato di pin, e il led che doveva lampeggiare? E’ sufficiente ricordarsi che il led L e il pin 13 sono connessi nella scheda Arduino modello Duemilanove. E quindi i valori di potenziale HIGH e LOW di cui abbiamo parlato vengono automaticamente visti dal led L che comincerà immediatamente a lampeggiare, con il ritmo di una accensione od uno spegnimento al secondo.
Ok, come si carica il programma su Arduino per farglielo eseguire? Prima di tutto è sempre buona norma controllare che il codice scritto sia conforme alle specifiche della scheda Arduino utilizzata. Per questo, premendo Command+R (su Mac) o andando sul menu Sketch>Verify/Compile, possiamo chiedere alla piattaforma di programmazione di controllare la correttezza del codice.
Sotto a Done compiling appare anche una riga che ci dice quanta memoria occuperebbe questo programma una volta caricato su Arduino:
Binary sketch size: 1124 bytes (of a 14336 byte maximum)
Arduino è dotato di una memoria flash da 16 Kbyte, di cui circa 2 KB utilizzati dal bootloader (il sistema che consente ad Arduino di ricevere correttamente i programmi dal computer).
Ok, carichiamo il programma su Arduino? Sì, è sufficiente premere Command+U, oppure andare su File>Upload to I/O Board e il programma, in pochi secondi, viene caricato e mandato in esecuzione.
Durante la fase di caricamento vedrete alcuni led lampeggiare anche molto velocemente. Si tratta del già conosciuto led L ed anche dei due nuovi led RX e TX (si tratta di indicatori di lettura e scrittura sulla memoria di Arduino). Finito il vortice di lampeggii, il led L comincia a comportarsi esattamente come definito nel programma, alternando accensioni e spegnimenti al ritmo di una al secondo.
Complimenti, il vostro primo Blink funziona egregiamente!
Per interrompere il programma bisogna spegnere Arduino staccando il cavo USB, ma ricordate che il programma è memorizzato e, appena ricollegate Arduino (alla porta USB, ad un alimentatore per iPod, ad un trasformatore a corrente continua tra 7 e 12 Volt o ad una batteria) il programma ripartirà immediatamente.
Nel prossimo articolo vedremo come personalizzare questo primo programma per esplorare la logica con cui è scritto e nuovi modi per espandere Arduino.
Arduino è una “piattaforma di prototipazione elettronica open-source” (ne accennai un anno fa).
E’ cioè? In poche parole è un fantastico aggeggio made in Italy che può caricare in memoria un software, registrare stimoli dall’esterno e inviare comandi a una serie infinita di motori, luci ed attuatori di ogni genere. Apparecchiatura dal grande successo internazionale, è stata progettata per artisti, designer, hobbisti e chiunque sia interessato a create oggetti o ambienti interattivi. Arduino, in sostanza, è uno strumento che permette di costruire computer in grado di interagire con l’ambiente in cui si trovano.
E quindi? Con questo primo articolo introduttivo iniziamo (io e Andrea Giansanti, la mente creativa del progetto) lo studio di questa piccola ma potente apparecchiatura elettronica allo scopo di esplorarne le potenzialità e di vedere… dove ci porta.
L’avventura è iniziata mercoledì mattina quando abbiamo fatto l’ordine per il KIT Workshop - Livello base (che comprende l’ultima versione di Arduino, chiamata Duemilanove) sullo shop online di Smart Projects (Arduino è reperibile anche singolarmente, ed anche su Robot Italy). Con una spesa di soli 50 euro ci siamo portati a casa la seguente attrezzatura:
Nonostante lo shop on-line avesse specificato un tempo di consegna di 48-72 ore, Arduino e tutto il kit sono arrivati in sole 24 ore.
Ho deciso di pubblicare una serie di articoli per creare un resoconto dello studio di Arduino Duemilanove in italiano, sia come riferimento futuro per noi stessi, ma anche per rendere meno ampia la mancanza di materiale on-line su questo specifico modello di Arduino e in particolar modo in italiano. Essendo alle prime armi e non avendo una conoscenza dei precedenti modelli, ci concentreremo quindi solo su questo modello.
Ok, come si installa? Acquistato l’hardware, anche se è possibile autocostruirselo (qui lo schema costruttivo, ricordate che è open-source!), è stato necessario installare sia la piattaforma di programmazione, ovvero il software Arduino, disponibile per Mac OS X, Linux e Windows, sia il giusto driver USB (allegato al software, anche se la versione più aggiornata è scaricabile sul sito della FTDI).
Installato tutto? Bene, lanciate il software Arduino, collegate Arduino Duemilanove al computer tramite il cavo USB in dotazione, selezionate (se necessario) la corretta Serial Port (su Mac è quella che contiene la dicitura tty.usbserial) nel menu Tools e… se il led etichettato PWR è acceso e arancione (vedi figura in basso) allora il vostro Arduino è correttamente alimentato!
Il led etichettato L dovrebbe lampeggiare con una luce verde, in seguito vedremo come utilizzata tale led.
Nel prossimo articolo vedremo come caricare il primo programma d’esempio, per insegnare i primi passi al vostro Arduino. Per qualsiasi domanda, richiesta o segnalazione d’errore, lasciate un commento.
Come saprete, un metodo molto semplice per raccogliere indirizzi e-mail, al fine di organizzare truffe informatiche o inviare spam su prodotti farmaceutici venduti illegalmente, è quello di avviare una catena di sant’Antonio. Non voglio sostituirmi al lavoro di Paolo Attivissimo, ma una catena in particolare mi ha colpito per la sua straordinaria stupidità . Ecco l’inizio del testo:
Mi hanno mandato questa e-mail…non è molto bella all’inizio ma di certo dopo aiuta a riflettere. Leggetela con attenzione. Sto inviando questa lettera per il significato che ha, fa pensare, e per ciò che dice.. Che tu ci creda o no, il destino esiste.. Ma anche se i casi che troverete qui sotto non sono positivi. . noi siamo capaci di fare della nostra vita ciò che vogliamo.. Basta desiderarlo..
Leggi da solo….specialmente l’ultima parte..
CASO 1:
Kelly Sedey aveva un desiderio: che il suo ragazzo, ormai da tre anni, David Marsden, le chiedesse di sposarla. Così, un giorno, quando lei era a cena con lui, David le chiese di sposarlo!!! Lei accettò, ma poi dovette andarsene, a causa di un appuntamento di li a 20 minuti.
Quando arrivò in ufficio, notò che sul suo computer c’erano nuove e-mail. Le controllò: le solite lettere da parte del suo amico… Ma poi ne vide una che non aveva mai visto prima. Era questa lettera. Lei la cancellò senza neanche leggerla tutta.
Stop. Ma come caspita si fa a scrivere un testo in cui un personaggio cestina una lettera in cui si parla di lei che cestina la lettera stessa. Un groviglio logico da cui non si può uscire, un controsenso, un nodo alla catena stessa.
A parte il fatto che, considerando le sventure che capitarono alla povera Kelly (in due parole il promesso sposo muore) indicano chiaramente che la premessa “noi siamo capaci di fare della nostra vita ciò che vogliamo.. Basta desiderarlo..” è sbagliata, visto che per ottenere qualcosa non dobbiamo solo desiderarlo, ma anche leggere fino in fondo tutte le e-mail, soprattutto di spam, che ci arrivano… altrimenti lui muore.
Supercomputer grandi quanto due campi da tennis che richiedono chilometri di cablature in rame per collegare i propri “cervelli” informatici potranno un giorno entrare in un semplice computer
portatile. Mentre i supercomputer odierni possono arrivare a consumare una quantità di energia pari al fabbisogno di centinaia di case, questi piccoli supercomputer su chip del futuro non consumeranno più dell’ equivalente energetico di una semplice lampadina.
Questo è il risultato che, a detta di IBM, si potrà avere anche grazie alla scoperta dei alcuni loro ricercatori.
In un articolo pubblicato nella rivista specializzata “Optic Express”, i ricercatori IBM hanno illustrato l’importantissima scoperta che permetterà di inviare su un chip le informazioni tra i “core” (i “cervelli”) multipli di un chip utilizzando pulsazioni di luce attraverso il silicio al posto dei tradizionali segnali elettrici nei cavi.
La scoperta * nota nel settore come modulatore elettro-ottico al silicio Mach-Zender * è un modulatore da 100 a 1000 volte più piccolo rispetto ai tradizionali modulatori della stessa categoria.
Questo favorirà la nascita di molti altri dispositivi del genere che permetteranno un giorno di integrare le reti ottiche di interconnessione in un singolo chip, riducendo drasticamente i costi, i consumi energetici e il calore generato ma allo stesso tempo consentendo un aumento della larghezza di banda per le comunicazioni tra i vari nuclei di più di cento volte rispetto ai chip cablati.
Si sta, in sostanza, lavorando per poter arrivare ad inserire il maggior numero possibile di core in un singolo chip-. Oggi, un dei chip avanzato come il processore Cell - cuore della Playstation 3 * contiene già nove core in un singolo chip. La nuova tecnologia mira alla di un metodo a bassi consumi che permetta l’interconnnessione di centinaia di migliaia di core su di un chip minuscolo, attraverso l’eliminazione di tutto il cablaggio normalmente necessario in questo tipo di funzione. Utilizzare la luce al posto dei fili per inviare tra core può aumentare la velocità di trasmissione di 100 volte e ridurre l’energia consumata di 10 volte.
…
Venga tu dall’inferno o dal cielo, che importa,
Bellezza, mostro immane, mostro candido e fosco,
se il tuo piede, il tuo sguardo, il tuo riso la porta
m’aprono a un Infinito che amo e non conosco?
Arcangelo o Sirena, da Satana o da Dio,
che importa, se tu, o fata dagli occhi di velluto,
luce profumo, musica, unico bene mio,
rendi più dolce il mondo, meno triste il minuto?
Charles Baudelaire (I fiori del male) - tradotto da Gesualdo Bufalino (Mondadori, 1983)
…
Che tu venga dal cielo o dall’inferno, che importa,
Oh Bellezza! mostro enorme, spaventoso, ingenuo!
Se il tuo occhio, il tuo sorriso, il tuo piede, mi aprono la porta
Di un Infinito che amo e che non ho mai conosciuto?
Da Satana o da Dio, che importa? Angelo o Sirena,
Che importa, se tu rendi - fata dagli occhi di velluto,
ritmo, profumo, luce, oh mia unica regina! -
L’universo meno orribile e gli istanti meno pesanti?
Gerablog è il neonato blog di Simone Gerardiello, nel quale sono apparsi già alcuni interessantissimi articoli di fotografia, elaborazione grafica e post-produzione con Photoshop (ma non solo). Lo stile è proprio il mio preferito, appassionato e meticoloso: proprio l’ideale per farsi venire voglia di provarci per conto proprio ma anche l’ideale per riuscirci, dal momento che le spiegazioni sono molto dettagliate. Ecco cosa troverete nel Gerablog:
