Siamo a venerdì, non ho aggiornato il blog durante questa settimana perchè  c’è stato tanto da fare e proprio non ce l’ho fatta. Sfortunatamente ho usato solo la macchina fotografica del cellulare per documentare il mio lavoro, quindi le immagini sono spesso di qualità bassa

Il concept  che alla fine  ho deciso di portare avanti è stato il n.5: BUTTAMI! .  Un oggetto da posizionare vicino alla porta di casa che ricordi a chi esce di casa  di controllare se c’è spazzatura da buttare. I progetti che volevo portare avanti erano diversi, ma questo era quello che più avrei voluto avere in casa, o che comunque sarebbe stato più utile.

Come prima cosa ho dovuto pensare a quale sensore usare. Ho optato per un sensore di movimento infrarossi che ho trovato dentro un sistema d’antifurto cinese. Una volta acceso con il telecomando si attivava il sensore che, una volta riscontrato movimento, faceva accendere una luce ed uno speaker con un suono molto fastidioso.

Parlo al passato perchè ho subito distrutto l’aggeggio per provare ad hackerare la scheda, ecco una prima foto.

Ho staccato un po’ i cavi che non mi servivano e spostato un’uscita pin sulla board. Non ho avuto problemi nell’immediato, ecco una foto di quei bei momenti

L’alta qualità dei prodotti elettronici cinesi però s’è subito fatta sentire. I cavi d’alimentazione non ne volevano proprio sapere di rimanere collegati, saldatura dopo saldatura ho perso sempre più la pazienza, finchè ad un certo punto la scheda ha smesso di funzionare. Ho provato ad aggiustarla ma non ce l’ho fatta, quindi ho provato ad usarne un’altra che mi è stata prestata da Simona ma che già aveva avuto le sue vicissitudini e niente, non c’era verso di farla funzionare.

Ecco i due cadaveri

Insomma, mi sono ritrovato a ieri mattina (giovedì) con un progetto che nella mia testa aveva una sua forma ma senza gli strumenti per realizzarlo. Parlando con il Prof. abbiamo deciso di semplificare un poco il progetto ed usare un semplice sensore di luce puntato sulla porta di casa, che potesse segnalare il passaggio di qualcuno in quel punto specifico. Il sistema, pensato così, non è perfetto. E’ infatti sensibile anche a cambiamenti di luce repentini generati da altri fattori (banalmente: l’accensione della luce all’ingresso della casa o nella camera di fianco), però questa era la soluzione più immediata. Mi sarebbe piaciuto aggiungere un altro sensore di luce, in questo modo avrei potuto evitare l’influenza della luce ambientale sul sistema. Infatti entrambi i sensori avrebbero registrato i cambiamenti dell’ingresso, però solo uno sarebbe stato puntato sulla porta, in modo che solo un cambiamento del suo stato avrebbe potuto generare il feedback a cui pensavo.

Scrivo in maniera contorta ma sono DAVVERO stanco. Insomma…ho parlato tanto di questo secondo sensore ma non sono stato in grado di programmarlo, quindi mi sono limitato al sensore singolo. Il programma da usare è estremamente semplice, non ho dovuto scrivere che pochissime righe di codice ( ovviamente con l’aiuto di Giorgio ) in aggiunta agli esempi già presenti nell’archivio di Arduino. Il mio sistema è fotosensibile ed attiva un bottone (che in realtà è il servomotore), dei led ed un piezo. Il sensore registra un certo numero di stati di luce consecutivi (15) e genera una media. Se la luce che arriva al sensore supera una certa soglia (sia aumentando che diminuendo) rispetto alla media a quel punto il sistema si attiva e dà un feedback.

Ecco il codice

</pre>
#include <Servo.h>
Servo myservo;
const int numReadings = 15;
int readings[numReadings];
int index = 0;
int total = 0;
int average = 0;
int inputPin = 0;
int soglia = 60;
int pos = 0;
int occhio = 3;
int occhio2 = 2;
int piezo = 5;
void setup()
{
Serial.begin(9600);
for (int thisReading = 0; thisReading < numReadings; thisReading++)
readings[thisReading] = 0;
myservo.attach(9);
pinMode (occhio, OUTPUT);
pinMode (occhio2, OUTPUT);
pinMode (piezo, OUTPUT);
}
void loop() {
total= total - readings[index];
readings[index] = analogRead(inputPin);
total= total + readings[index];
index = index + 1;
if (index >= numReadings)
index = 0;
average = total / numReadings;
int tempvalue1 = analogRead(inputPin);
int difference1 = average-tempvalue1 ;
int abs_difference1 = abs(difference1);
if(abs_difference1 >= soglia){
Serial.print("Diff: ");
Serial.println(abs_difference1, DEC);
myservo.write(1);
delay(250);
myservo.write(160);
delay(250);
myservo.write(1);
digitalWrite (occhio, HIGH);
digitalWrite (occhio2, HIGH);
digitalWrite (piezo, HIGH);
}
else {
myservo.write(100);
delay(450);
digitalWrite (occhio, LOW);
digitalWrite (occhio2, LOW);
digitalWrite (piezo, LOW);
}
}  

Ecco una foto del circuito “nudo” e con un solo led.

In questa foto è presente il secondo sensore di luce, però, come ho già spiegato, non sono riuscito a programmarlo in modo da farlo lavorare in collaborazione con l’altro. Una volta risolti questi problemi ho solo dovuto costruire una scatola “antropomorfa”, per questo concept. Avevo diverse idee, qualcosa legato alla famiglia Addams ed alla mano (che avrebbe dovuto avere una busta di spazzatura, ovviamente), o magari un cucù spazzaturoso. Alla fine ho optato per un personaggio più o meno noto: Rorshack, presente nel fumetto (e nel film) Watchmen, di Alan Moore e Dave Gibbons.

Cito la scheda su Wikipedia:

Rorschach è un personaggio dei fumetti, tra i protagonisti del fumetto Watchmen scritto da Alan Moore. È un giustiziere mascherato violento e solitario, quasi autistico, che si copre il volto con una maschera raffigurante le celeberrime macchie del test da cui prende il nome.
Perchè la scelta è caduta su questo personaggio? Perchè è un buono “atipico”, non bada alle buone maniere, cerca solo di raggiungere il suo nobile scopo senza preoccuparsi dei mezzi utilizzati, a patto che a perderci siano solo dei delinquenti. Insomma, visto che il mio oggetto era pensato per la mia casa a Siena ed i miei coinquilini volevo un messaggio forte e chiaro. Il mio piccolo Rorshack non fa sconti a nessuno (me compreso), chiunque passi davanti alla porta si deve ricordare di controllare se c’è della spazzatura da buttare, con ogni mezzo.

I mezzi, passando al lato tecnico, sono piuttosto semplici. Il personaggio che ho costruito (prendendo il modello da qui) doveva avere un braccio mobile (tramite servo motore), con un sacco di spazzatura, in modo da attirare l’attenzione. In più, per aumentare il “fastidio”,  la “punizione”, ho aggiunto dei led molto potenti ed un Piezo fisso fastidiosissimo. Insomma, una volta che il sensore di luce riceve un dato diverso da quello della media che ha calcolato, il braccio inizia ad andare su e giù, gli occhi si illuminano ed il Piezo rumoreggia furiosamente.

Ecco un video

Alcune foto del packaging ancora da montare, del tavolo da lavoro un po’ incasinato, della base dell’oggetto ed infine di Rorshack completato

Ecco, alla fine di tutto, il video finale del mio progetto La qualità non è altissima, lo ripeto, però fra mezz’ora esco di casa e non avrò la possibilità di lavorare ad un computer per qualche giorno, quindi al momento va più che bene. Ho già chiesto in giro i video e le foto ad alta qualità del mio progetto, a metà settimana caricherò anche quelli.

E’ tutto, più o meno. Queste sono state due settimane strane, sempre passate a lavorare duro E con qualcos’altro all’orizzonte (banalissime vacanze di Natale prima, eccitantissima esperienza danese ora), spero siano state utili, ne sono praticamente sicuro, a dir la verità. Arduino ha già trovato il suo posto in valigia (però ho dovuto distruggere Rorshack per recuperare il servo   ) , penso che posterò i miei futuri lavori di Phisical Computing su questo blog, che rappresenterà un po’ il mio percorso.

1 – Non ti scottare! Una mano che sta a fianco alla doccia, un sensore di temperatura che sta sotto l’acqua. A casa mia qui a Siena ci vogliono 2 ore perchè la temperatura salga e poi però o la si ha bollente oppure fredda. Insomma, una mano collegata al sensore che cambi di colore a seconda della temperatura dell’acqua. Quando si raggiunge la temperatura predefinita la mano diventa rossa ma non troppo.

2 – Copriti! – Sono ossessionato dal freddo? Un termometro fuori dall’appartamento, una scala di led (diciamo 10) all’interno. Si passa dal blu al rosso, gradualmente, a seconda della temperatura. Utile per quando si deve decidere come vestirsi.

3 – Maledetto rompipalle! Il mio coinquilino spesso dorme fuori ma dimentica la sua rumorosissima radiosveglia accesa ed attiva, così che mi devo svegliare malamente e pure con canzoni che odio! Lui dorme con la tapparella abbassata e la porta chiusa. Un sensore di luce più un infrarosso fra la porta ed il muro, se entrambi hanno l’input giusto (luce in camera + porta aperta) significa che lui non c’è. Un ditone posto sopra l’off della sveglia la spegnerà dopo un minuto.

4 – Anticazzeggio - Un timer anticazzeggio. Una manona con braccio metallico sul muro. Se decido di attivare l’anticazzeggio schiaccio un pulsante e mi siedo a rilassarmi. Però devo stare attento, dopo 15 minuti la mano inizierà a darmi delle fastidiosissime pacche sulla spalla finchè non mi alzo, la disattivo e riprendo a lavorare seriamente.

5 – Buttami! – In casa mettiamo la spazzatura fuori in terrazzo. Un bel sensore di prossimità messo davanti alla porta d’ingresso che scatta quando qualcuno ci passa sotto (ci si passa solo per uscire di casa) e magari una bella scrittona led sulla porta che dice “BUTTAMI”

6 – Sono commestibile? Un timer da collegare ad un barattolo d’alimenti di qualunque tipo. Ci dice da quanto tempo sono aperte le cose, in modo da evitare magari di mangiare pesto all’aria da mesi. (Tremendamente da studente fuori sede, lo so).

7 – Am I ringin’? – Odio suonerie e vibrazioni del cellulare, spesso lo tengo sul letto mentre sto al pc però comunque vorrei rispondere se mi chiamano. Un sensore di luce vicino allo schermo da l’input ad un led di fianco a me, così mi accorgo se qualcuno mi chiama.

8 – Drunk clock – Certe mattine, dopo nottate di stravizi, è davvero dura capire che ore sono. Non ho un orologio ne una sveglia (se non quelli del cellulare), però è davvero troppo traumatico andare a cercarlo, accenderlo e così via. Un semplice orologio che si attiva solo dopo una certa ora e semplicemente con i led. Ha solo la lancetta delle ore ed una dei minuti che si limita a 4 posizioni (00, 15, 30, 45). La mattina basta aprire gli occhi per avere un minimo idea di che ore siano, e nel caso ributtarsi con la faccia nel cuscino e tanta voglia di aver bevuto meno la sera prima.

9 – Light metronome – Un metronomo luminoso e silenzioso per non disturbare chi ci sta intorno mentre magari suoniamo uno strumento in cuffia.

10 – Bilancia a-traumatica – Ci sono dei led, sappiamo solo se siamo calati (verde), se siamo stabili (blu) o se siamo ingrassati (rosso). Uno vede la luce ed ha idea di quello che lo aspetta. Può decidere di non rimuovere il pannellino e accontentarsi di avere un dato indicativo oppure controlla il suo peso preciso.

11 – Lostometro – Si accende solo la mattina in cui è disponibile il torrent con l’episodio appena trasmesso negli Usa. Un occhio illuminato farà da reminder (ogni puntata inizia con il primo piano su un occhio che si apre, o almeno quasi sempre), due mani invece dovranno dire che punteggio la puntata ha ottenuto su www.tvguide.com, in modo da avere idea, appena sveglio, di quello che mi aspetta.

12 – The door is open -Sensore ad infrarossi fra porta del bagno e muro davanti. Il mio coinquilino si chiude dentro con il telefono e ci passa un’ora e mezzo dentro. Io esco da camera mia, vedo che è occupato e rientro. Però se ho la musica accesa non posso sentire quando la porta si apre. Il sensore può dare l’input ad un simulacro (per la forma ci si può sbizzarrire, parlando di corpi umani) che si accende quando la porta viene aperta.

13 – High five! – Gioco spesso ad Nba 2k10, una simulazione di basket per pc. Mi stufo ad andare nel menù giocatore per vedere quanti punti ho fatto o quanti rimbalzi ho preso. Molto meglio avere due mani a fianco al pc a cui poter battere il cinque nel caso di un canestro o di un rimbalzo (ogni mano ha una funzione diversa). In questo modo ho una rappresentazione grafica davanti a me di come sto giocando, senza dover uscire dal gioco ogni 2 minuti.

14 – Warm bed – Un piede collegato ad un sensore di temperatura nel letto. Ho uno scaldapiedi imetec, quando questo raggiunge la temperatura desiderata il piede fuori dal letto diventa rosso e so che potrò entrare nel letto senza ghiacciarmi.

15 – I miei occhi! – Un sensore di peso sulla poltrona (che uso solo quando sto al pc) ed uno nella custodia degli occhiali. Se mi siedo nella poltrona e gli occhiali sono al loro posto suona un buzzo finchè non li indosso.

16  – Si può bere? – Una lingua con sensore di temperatura che mi avverte quando il The è alla temperatura che preferisco

17 – Maledetti vizi – dei sensori di prossimità nelle dita ed un altro che li attiva vicino alla mia bocca. Se provo a mangiarmi le unghie squillano dei buzzo beater.

18 – I’m hot! – Siena è una città umida, è difficile far asciugare i panni stesi senza l’aiuto dei termosifoni. Un sensore di temperatura abbinato a dei led mi ricorda quando il riscaldamento in casa si accende ed è il caso di mettere sui termosifoni degli abiti umidi, oppure di fare il cambio con quelli che già si sono asciugati.

19 – Garbage pet – Simile al 5, però stavolta è un piccolo cane che ti ricorda di controllare la spazzatura mentre esci di casa

20 – Anti – mal di schiena – Sensore di peso a tempo sulla poltrona. E’ sempre meglio alzarsi e sgranchirsi le gambe ogni mezz’ora, questo sensore te lo ricorda (una siluhette a forma di schiena formata da led diventa rossa)

21 – Casinometro – In genere metto in pila cd e libri in attesa di avere voglia di sistemarli decentemente. Un sensore ad infrarossi in opposizione ad un altro stanno nella libreria dove accumulo le cose. Quando l’altezza del casino inizia ad essere troppa manca il contatto infrarossi fra i due ed il casinometro rumoreggia finchè non mi decido a sistemare qualcosa

22 – Che ore sono? – Variazione del drunk-clock. L’orologio si attiva solo se apro un cassetto a fianco al letto all’interno del quale sta un occhio. Questo vede la luce minima della stanza, reagisce e fa accendere un’orologio sul muro.

23 – Anti – flood – Troppo spesso metto nella borsa delle bottiglie d’acqua (una volta di rum ) un poco aperte che fanno un macello, ovviamente. Sul fondo della borsa posso mettere un circuito collegato da alcune spugne che fanno suonare un buzzo solo se bagnate e quindi conduttrici.

24 – The champion! – Il canestro segnapunti con una modifica che aiuta l’autostima. Oltre a far accendere dei led da un segnale a 3 buzzo beater che fanno suoni da partita di baseball americana.

25 – Abbassami! – Odio la serranda mezzo aperta, però a volte mi capita di dimenticarla. Un pulsante sta sotto la serranda e viene schiacciato solo se questa è perfettamente abbassata. In questo caso non c’è feedback. Se invece la serranda è leggermente alzata si accende un led rosso dentro un finto occhio. Rappresenta il colore dei miei occhi se la luce dovesse svegliarmi alle 6 del mattino dopo.

26 – Certe canzoni mi fanno stare bene, magari anche solo dei frammenti da 5-10 secondi. Registrare la melodia e riprodurla tramite buzzo-beater è fattibile. A quel punto posso creare un UMOROMETRO con diversi pulsanti (a forma di pancia, di testa, di bocca, di orecchie,, a seconda del tipo di canzone di cui ho bisogno) che fanno partire il frammento di canzone che voglio sentire.

27 – Careless virtual pet – Non amo gli animali. I tamagotchi sono stupidaggini e comunque troppo impegnativi. Certo che però avere un animale che rumoreggia contento quando entri in casa deve essere rassicurante. Lo fa ogni volta, ti basta dargli una carezza per farlo smettere ed a quel punto si disattiva finchè non tornerai a casa un’altra volta. Un virtual pet che non va curato.

28 -Buzzo citofono – Ha delle melodie preimpostate su alcuni miei umori. Se aspetto ospiti per cena il citofono farà dei suoni allegri, se non voglio seccature il citofono farà qualche suono rilassante per evitare d’incazzarmi…o magari un bel suono fastidioso per accogliere bruscamente il malcapitato

29 – Quante birre ci sono in dispensa? – Una mano illuminata che fa il countdown delle birre, quando si dice che uno strumento ti da una mano…

30 – Non ti alcolizzare! – Variazione del primo, solo che invece di fare un countdown conta le birre bevute in un dato periodo di tempo. Prendere coscienza è importante.

31 Terremoto! – Sono spaventato ma affascinato dai terremoti, di cui non ho mai avuto esperienza. L’unica volta che c’è stato stavo in una scrivania a studiare ma nonostante questo non mi sono accorto di niente, e dire che tutti in casa l’hanno sentito! Insomma, un accelerometro sulla scrivania fa accendere dei led in caso di movimenti sospetti e mi avvisa che forse devo stare attento.

32 – Live festival – I programmi dei festival musicali sono ben fatti e precisi, ma c’è sempre qualcosa che va storto o qualcosa che ci si dimentica. Invece di avere una semplice brochure si potrebbe avere un vero e proprio programma interattivo, con dei led che stanno accesi quando un concerto si sta svolgendo, in modo da non rischiare di perdere niente, oppure per poter stare ancora 5 minuti sotto un palco perchè tanto il concerto dall’altra parte del parco non è ancora iniziato.

33 – La droga fa male – Degli occhiali foderati di led che si accendono a ritmo con la musica in camera (preferibilmente psichedelica), in modo da fare un viaggio senza conseguenze neuronali.

34 – What’s my mood? – Se si tagga la musica nel proprio lettore per umore poi lo si può collegare ad un led sullo zaino . Mentre si cammina per strada il led mostrerà a tutti il mood della musica che ascoltiamo (o almeno come la vediamo noi)

35 – memolibretto – E’ sempre difficile ricordarsi di portare il proprio libretto universitario agli esami. Un libretto interattivo collegato al calendario degli esami potrebbe rumoreggiare la mattina dell’appello, in modo che non lo si dimentichi

36 – Vinyl light – La forza cinetica di un giradischi fa accendere dei led a ritmo con la musica che stiamo ascoltando

37 – LOST clock. Un timer solo per chi guarda Lost E passa troppo tempo seduto. Un timer che fa un conto alla rovescia di 108 minuti, alla fine del countdown inizierà a rumoreggiare e fare luci varie. Solo alzandosi e schiacciando un qualche pulsante smetterà. In questa maniera si ha la certezza di alzarsi dalla sedia e sgranchirsi le gambe ogni tanto.

A meno che non si parli di libri\dischi oppure qualcosa che ci ha a che fare

Non ho voluto scegliere ne un libro ne un disco però, da mettere qui, per non fare un torto a nessun’altro (anche i miei cofanetti di lost erano una grossa tentazione). Diciamo che mi limito a due cose che uso tantissimo (quando posso) ed a cui davvero tengo tanto.

Ripeto, disegnare non fa per me. Però manco esprimere apertamente certe cose che ho dentro, o anche riuscire a razionalizzarle.

In genere mi viene molto più facile usare qualcos’altro, avere un tramite fra me e quello che voglio dire agli altri. Per questo ogni tanto faccio delle compilation alla mia ragazza, per questo a volte le faccio anche per altre persone a cui voglio far sentire certe canzoni. Probabilmente è il mio modo di condividere le mie emozioni con qualcun’altro.

Insomma, ecco uno schema estremamente semplice (e schematico, appunto) in cui alle cose che faccio associo un disco che ascolterei volentieri mentre le vivo. Il titolo è una citazione rivisitata dei Silver Mt. Zion, che a loro volta citavano non ricordo bene cosa. Le lune sono 16 per un semplice calcolo di 24 ore al giorno meno 8 di sonno.

Inizio con la mappa delle mie relazioni sociali. E’ piuttosto semplice perchè semplici sono i dati da mettere dentro. Pensando a come farla ho notato che i miei gruppi di amici\conoscenze sono DAVVERO divisi per aree geografiche. Non ci sono grosse unioni fra uno spicchio e l’altro (anche se ovviamente quelli più vicini a me sono pure più vicini tra loro, in un modo o nell’altro).

Disegnare non è mai stato il mio punto forte, se non s’era capito.

a poi con il resto

Here some pictures from the keyboard

inside

and on work

As I said I just copied one of the first codes I used (three blinking ligths).

I made every led blink at a really high intensity so that it is basically always on. Now I just had to put every contact on a keybord, in a way that created the contact only when pushing a key. I built it with some carton and some balls of Happy mais but unfortunately it does not really well. The carton was to soft and not flexible enough, sometimes I had to move it a little, and some contacts were too close, so that when pushing one key more led were turning on. Apart from that everything was fine, it has been quite satisfactory to work on it the whole morning and part of the evening and finally make it work.

A video

And the code

int redpin =  12;    // LED connected to digital pin 12
int greenpin = 11; //led connected to digital pin 11
int yellowpin =10; //led connected to digital pin 10
int whitepin = 9; //etc etc
int redpin2 = 8;
int greenpin2 = 4;
int yellowpin2 = 3;
// The setup() method runs once, when the sketch starts
void setup()   {
 // initialize the digital pin as an output:
 pinMode(redpin, OUTPUT);
 pinMode(yellowpin, OUTPUT);
 pinMode(greenpin, OUTPUT);
 pinMode(redpin2,OUTPUT);
 pinMode(greenpin2, OUTPUT);
 pinMode(whitepin,OUTPUT);
 pinMode (yellowpin2,OUTPUT);
}
// the loop() method runs over and over again,
// as long as the Arduino has power
void loop()
{
 digitalWrite(redpin, HIGH);   // set the LED on
 delay(5);                  // blinking every 5 miliseconds
 digitalWrite(redpin, LOW);    // set the LED off
 delay(5);                  // blinking every 5 miliseconds
digitalWrite(greenpin,HIGH); //set the greenled on
delay(5);
digitalWrite(greenpin,LOW); //set the green led off
delay(5);
digitalWrite(yellowpin,HIGH);
delay(5);
digitalWrite(yellowpin,LOW);
delay(5);
digitalWrite(redpin2, HIGH);
 delay(5);
 digitalWrite(redpin2, LOW);
 delay(5);
digitalWrite(greenpin2,HIGH);
delay(5);
digitalWrite(greenpin2,LOW);
delay(5);
digitalWrite(yellowpin2,HIGH);
delay(5);
digitalWrite(whitepin,LOW);
delay(5);
digitalWrite(yellowpin2,HIGH);
delay(5);
digitalWrite(whitepin,LOW);
delay(5);
}

And that’s it for the coding part, we didn’t work much on it today.

We had another task, by the way: draw a representation of Arduino in something like infographics. Making an image that could represent it and its functionalities, mine is really bad cause drawning is definetely not my thing. I imagined Arduino as a garden where some kids go during their school break. Sorry but I didn’t think about the blog, is all in italian, but I’m pretty sure no one is gonna need it..

I will build a simple keybord (only 7 keys) with pistachios instead of keys!

Basically i will just recycle one of the first circuit we made, with some led, maybe I’ll also add a button. When the keybord will be on every led will be setted to be turn on, but the circuit will be created (with some cartoon) so that only when I’ll push one pistachio the contacts will actually be touching, so that the light will turn on. A prototype of a photo-keybord then, that I’ll finish soon, I hope.

we tried some new simple interactions this morning.

First of all we used this code

int value = 0;
void setup() {
Serial.begin(9600);
<pre>}</pre>
//sets a signal on arduino's serial port?
void loop () {
value += 1; //values constantly plus one
Serial.println(value, DEC); // graphic visualization of the function
delay (5); //function delay, a number every 5 millisecond
}

Using the serial number and giving the command “println” is useful. The program records its outputs and clicking on the export button on the arduino program we’ll have a window with a numeric representation of every output. You can use it to check your program and to see if everything is going how is supposed to be.

After that we worked again on some basics with the leds.

//in order to get a simulation of an analogic output
//i must use a pwm pin
int ledPin =  3;    // LED connected to digital pin 3
int ledVal = 5;  //defines brightness
// The setup() method runs once, when the sketch starts
void setup()   {
 // initialize the digital pin as an output:
 pinMode(ledPin, OUTPUT);
}
void loop()  {
for  (int x=0; x<255; x++) { //defines x,fix a limit and establish that is gonna grow up
 analogWrite(ledPin, x); // pin brightness is gonna grow up
 delay(5); //imposta ritmo //with this rithm
}
for (int x=255; x>0; x--) { //same as before but descendent
 analogWrite(ledPin,x);
 delay(5);
}
}

In this case we got a led which light grows up and diminish slowly in a loop. The code is quite clear. The only important thing is to be connected to a pwm pin cause it’s simulates an analogic output, so it can have a modulation instead of a 0/1 output (digital output). In Arduino 2009 the pwm pins are 3,5,6,9,10,11.

We actually started from a simpler example with only light growing up, the code is basically the same

int ledPin =  3;    // LED connected to digital pin 3
int ledVal = 5;  //defines brightness
// The setup() method runs once, when the sketch starts
void setup()   {
 // initialize the digital pin as an output:
 pinMode(ledPin, OUTPUT);
}
void loop()  {
for  (int x=0; x<255; x++) { //defines x,fix a limit and establish that is gonna grow up
 analogWrite(ledPin, x); // pin brightness is gonna grow up
 delay(5); //imposta ritmo //with this rithm
}
}

Another variation of the code, with the same effect, is

//use a pwm pin
int ledPin =  3;    // LED connected to digital pin 3
int ledVal = 5;  //brigthness
int direction = 1 ; //variable, defines flow direction
// The setup() method runs once, when the sketch starts
void setup()   {
 // initialize the digital pin as an output:
 pinMode(ledPin, OUTPUT);
}
void loop()  {
for  (int x=0; x<255; x++) { //defines x with a limit and a growing up
 if(direction==1) { //when direction is +1
 analogWrite(ledPin,x);//then light will have a growing x value from 0 to 255
}
if(direction==-1) { // if direction is -1
 analogWrite(ledPin, 255-x); //light will diminish
}
delay(5); //general delay
}
direction *=-1; //every time direction (1) gets moltipled for -1. When is +1 it becomes -1, at the next cycle -1 will become again+1
}

After that we worked with a potentiometer

Basically is just an analogic switch, so that we don’t have only an on/off output but also every output between those two (the scale goes from 0 to 1023).
It must be connected to the 5 volt pin, to the grund and to a 10k resistor (as you can see it has 3 plugs). Here is the code

int sensorPin=2;  //output sensor
int sensorValue=0;
void setup () {
Serial.begin(9600);} //recall Arduino serial port
void loop (){
sensorValue = analogRead (sensorPin); //defines sensorvalue
int ledFadeValue = map(sensorValue, 0, 1023, 0, 255); //defines that the 0-1023 transistor range will be now converted in 0-255
analogWrite (11, ledFadeValue); //turns on the led
Serial.println(sensorValue, DEC); //digital output
delay(20); //rithm
}

So in here we just have a potentiometer that regulates a led. Now a variation

int sensorPin=2;
int sensorValue=0;
void setup(){
Serial.begin(9600); //recall Arduino serial
}
void loop (){
sensorValue = analogRead (sensorPin);
int ledFadeValue = map(sensorValue, 0, 1023, 0, 255); // 0-1023 is used as 0-255
analogWrite (11, ledFadeValue); // pin will turn on and off
int ledFadeValue2 = map(sensorValue, 0, 1023, 255, 0); // in here we do the opposite, potentiomter 0
//corresponds to led 255 and so on
analogWrite (10, ledFadeValue2); // pin will turn off and on
Serial.println(sensorValue, DEC); //digital output visual
delay(20);
}

So we learned that with the <em>map</em> option we can translate a range of values to another one. If we would have liked only to pass from a medium brigthness to a high one (not maximum still) the command would have been
[code]int ledFadeValue = map(sensorValue, 0, 1023, 123, 200);

I took a video of this

We were done with the potentometer then and we started using a simple push-button.

int buttonPin =2;  //button input
int ledPin=13; //output
int buttonState = 0;
void setup() {
 pinMode(ledPin,OUTPUT);
 pinMode(buttonPin,INPUT);  //button will be an input
}
void loop(){
 buttonState=digitalRead(buttonPin); //button state
 if(buttonState==HIGH){ //if the state is HIGH (pressed)
  digitalWrite(ledPin,HIGH); //turn LED on:
 } else{
 digitalWrite(ledPin,LOW);
<pre>
<pre> // turn LED off:</pre>
</pre>
}

<img class="alignnone" title="pulsante con buzzo" src="http://img138.imageshack.us/img138/8623/pulsanteconbuzzo.jpg" alt="" width="448" height="335" />

I think that looks simple. If you keep the button pushed it will turn on the led (a buzz in this case). Now a little variation
[code]int buttonPin =2; //button input
int ledPin=13; //pin output
int buttonState = 0;
int redpin =5; //second pin output
void setup() {
 pinMode(ledPin,OUTPUT);
 pinMode (redpin,OUTPUT);
 pinMode(buttonPin,INPUT);
}
void loop(){
 buttonState=digitalRead(buttonPin); //defines button state
 if(buttonState==HIGH){ //if is pressed
 digitalWrite(ledPin,HIGH);//turn LED on
digitalWrite(redpin,LOW); //and the other one off
 }
 else{
 digitalWrite(ledPin,LOW);// turn LED off
digitalWrite(redpin,HIGH); //and the other one on
 }
}

Se there is a led always on and when you push the button it will turn off with a new one that will be turn off as long as you keep pushed. Another step further

int old_val=0; //this variable stores the previous value of "val"
int state=0;
void setup(){
 pinMode(LED,OUTPUT); // tell arduino LED is on output
 pinMode(BUTTON, INPUT); //and Button is on input
}
void loop() {
 val=digitalRead(BUTTON); //read input value and store it
 if ((val==HIGH)&&(old_val==LOW)){ //check if there was a transition
 state=1-state; //changes state's value
 delay(10);
 }
 old_val=val; //val is now old,let's store it
 if (state==1){
 digitalWrite (LED,HIGH); //turn led on
 }else{
 digitalWrite(LED,LOW);
 }
}

So that every time you push the button the led will change its state without having to keep pushed. One push it turns on, another one and goes off again.

That's pretty much all the code we wrote. We tried some soldering (unfortunately I don't have a video of my first try). I guess I'm not really good ad it but
that's not the part that goes "public", i hope it won't be a huge problem. I took some pics but I didn't have a good camera, I hope I'll post a good one for the end of the week

That one is a buzzo beater, is an i/o device whichs makes a quite disturbing noise if on. We tried it with almost every function i mentioned before just to see how it responses.
After that the day was practically over, we just went home with "some" homework to do, works that I'll post later.

I’m doing it cause I have too   I will put notes about the progress I’m gonna make during a Phsical Computing course at my university, in Siena. We’re gonna learn how to use Arduino, or at least we’ll try to!

We were asked to make a blog to update every new step we do. Due to the open source nature of Arduino project we’ll pubblish all of our works with some explenations and all the code written during our workshops.

The blog’s layout is just a beta (will I ever change it?) and it’s liberally inspired to Monkey island, one of the best videogames ever. There are two main reasons:

-there is a new MI game but I can’t use it cause my laptop is still broken and I’m using an older one right now

-MI nature (expecially in the first two chapters of the game) is in a way similar to the work we’re gonna do. You had to mix different things, learn by doing, try all kinds of connections before finding the right one, getting more and more involved in the project you were in and so on…

So, in this first day we just did some basics. I’m probably gonna use many wrong terms, I hope I’ll improve day by day.

In the first picture (bottom of the page) here you can see how I just connected the external areas of the board in order to make a anode\cathode circuit (I think…)

After that i connected it to Arduino wiring the 13th digital pin slot to one circuit in  the board and the GND slot to the other circuit. Arduino signal was then arriving to the board (where I put a led respectin the anode\cathode corrispondence) and I opened an example of code from file\examples\digital\blink, from the Arduino software.

There was my first blinking!

After that we found out that it is possible to add some more leds to the same circuit, but that might overload the processor, you need 220r resistor in circuit with every led in order to avoid an overload.

So..we had to connect every resistor on the board with Arduino (in the 10-11-12 slots) on one side and on the same circuit of the led anode on the other side. Then we connected the leds cathode’s circuits with the GND slot and re-wrote the example code mentioned before.

We had to add a new element for every led we wanted to connect and the work was done, there were 3 blinking lights (in my case with different rithm) on the board!

Here is the code…I don’t know if is the shortest way to get to the result but it almost worked. I say almost cause the rithm i wanted for every light wasn’t respected. Every led had a long off moment and a short blink on. I might have made some mistake in the code but it was too late and I couldn’t figure out what happened nor asking to the prof. I will tomorrow, I guess.

int redpin =  12;    // LED connected to digital pin 12
int greenpin = 11; //led connected to digital pin 11
int yellowpin=10; //led connected to digital pin 10

void setup()   { // initialize the digital pin as an output:
pinMode(redpin, OUTPUT);
pinMode(yellowpin, OUTPUT);
pinMode(greenpin, OUTPUT);

}

// the loop() method runs over and over again,
// as long as the Arduino has power

void loop()
{
digitalWrite(redpin, HIGH);   // set the LED on
delay(1000);                  // wait for a second
digitalWrite(redpin, LOW);    // set the LED off
delay(1000);                  // wait for a second
digitalWrite(greenpin,HIGH); //set the greenled on
delay(400); //set the rithm
digitalWrite(greenpin,LOW); //set the green led off
delay(400); //set the rithm
digitalWrite(yellowpin,HIGH);
delay(500);

digitalWrite(yellowpin,LOW);

delay(500);

}

Finally here is a picture of the circuit(on the right)

That’s it for this first day, I hope I’ll post something more intersting  (for who wasn’t there) tomorrow!