La piattaforma hardware e software Arduino: parte IV

Corso di autoapprendimento

Tempo previsto: 3 – 4 ore

Prof. Angelo Monfroglio

In questa quarta parte parleremo della programmazione di Arduino nel linguaggio Processing, basato su

Java. Ma prima di tutto, dell’interfacciamento con i display LCD.

Generalità sul display LCD (Hitachi con controller HD44780)

E’ fatto apposta per essere usato con un micro controller e costa circa 10 euro. Può visualizzare i normali

caratteri alfanumerici, lettere greche, segni di interpunzione, simboli matematici e caratteri creati

dall’utente, attraverso 3 memorie di cui dispone:

-DDRAM (RAM per i dati)

-CGRAM (RAM per generare caratteri personalizzati)

-CGROM (ROM che contiene il generatore di caratteri interno).

Il messaggio può essere spostato automaticamente a destra e sinistra, si può controllare la forma del

cursore, e, come opzione, è disponibile la retroilluminazione. I piedini sono14, più 2 per la

retroilluminazione a LED.

Funzione Pin Nome Valore Descrizione

Massa 1 VSS - 0V

Alimentazione 2 VDD - +5V

Contrasto

regolabile

3 VEE - Da 0 a VDD

Controllo 4 RS 0 o 1 0 = comando, 1

dato (pin D0 – D7)

Controllo 5 R/W 0 o 1 0 scrive, 1 legge

Controllo 6 E 0 o 1 o fronte di

discesa

0 accesso

disabilitato, 1

operativo, fronte =

trasferimento a

LCD

Dato o comando Da 7 a 14 D0..D7 0 o 1 Dato o comando

Lo schermo visualizza 2 righe di 16 caratteri con matrice di 5x8 pixel (oppure 5x11). E’ anche possibile

regolare il contrasto: solitamente va regolato al massimo.

La memoria DDRAM è usata per memorizzare i caratteri da visualizzare: 80. Di questi 32 sono visibili

direttamente sul display. Si può configurare la DDRAM in modo che avvenga uno scorrimento automatico a

destra e deve essere fissato il primo indirizzo, ad esempio 00h. Ecco la mappa.

00h 27h

40h 4F 67h

Visibile Non

vis.

La memoria CGROM, non volatile, contiene il set di base dei caratteri visualizzabili, sotto forma di matrici di

puntini (nel nostro caso 5 x 8). Gli indirizzi corrispondono in pratica ai caratteri ASCII. Occorre controllare

l’indirizzo effettivo di ogni simbolo sulla mappa.

Oltre ai simboli standard, l’utente può crearne di propri con la memoria CGRAM di 64 bytes. La matrice di

punti è 5 x 8 che significa 8 righe di 5 colonne:

*

*

*

* significa acceso

Gli indirizzi vanno da 00 a 3F e ovviamente ciascuna locazione usa solo 5 bit degli 8 perché ogni riga ha 5

colonne.

00

…

3K.

Il modulo LCD può essere interfacciato con il microcontrollore usando 8 bit di dati o 4 per volta. Il vantaggio

del primo modo è la facilità di gestione e la velocità, del secondo modo il risparmio di piedini usati per le

porte del microcontrollore. Se si usa un PIC da 28 piedini quest’ultima soluzione può essere preferibile. Si

può anche risparmiare un piedino mettendo a massa R/W e rinunciando a leggere da LCD, ma è

sconsigliabile. Ogni comando dura circa 2 milli secondi per essere eseguito. Quando il circuito è alimentato

LCD è azzerato., dopo 15 milli secondi, e posto nella condizione di default:

DL = 1 comunicazione a 8 bit

N = 0 il dato su una linea

F = 0 il formato della griglia è 5 x 8

D = 0 display off

U = 0 cursor off

B = 0 lampeggio off

I/D = 0 gli indirizzi sono incrementati ogni volta automaticamente di 1

S = 0 display shift off.

I comandi

Il valore sui pin D0-D7 può essere un comando o un dato. Se RS = 0 viene considerato un comando.

Comando RS R/W D7 D6 D5 D4 D3 D2 D1 D0 Tempo

Clear 0 0 0 0 0 0 0 0 0 1 1.64

mS

Home 0 0 0 0 0 0 0 0 1 X 1.64

Mode 0 0 0 0 0 0 0 1 I/D S 40

Display

ON/OFF

0 0 0 0 0 0 1 D U B 40

Shift 0 0 0 0 0 1 D/C R/L X X 40

Function 0 0 0 0 1 DL N F X X 40

Indirizzo

CGRAM

0 0 0 1 Addr Addr Addr Addr Addr Addr 40

Indirizzo

DDRAM

0 0 1 ADDr Addr Addr Addr Addr Addr Addr 40

Legge 0 1 BF Addr Addr Addr Addr Addr Addr Addr 40

flag busy

Scrive in

CGRAM o

in

DDRAM

1 0 D7 D6 D5 D4 D3 D2 D1 D0 40

Legge 1 1 D7 D6 D5 D4 D3 D2 D1 D0 40

Con i significati:

I/D = 1 incremento di 1, = 0 decremento

S = 1 shift del display on, 0 off

D = 1 display on, 0 off

U = 1 cursor on, 0 cursor off

B = 1 lampeggio, 0 non lampeggio

R/L = 1 sposta a destra, 0 a sinistra

DL = 1 interfaccia a 8 bit, 0 a 4 bit

N = 1 display su 2 linee, 0 su una linea

F = 1 matrice dei caratteri 5 x 10, = 0 5 x 7

D/C = 1 spostamento sul display, = 0 spostamento del cursore.

Se siete spaventati da tutti questi comandi, buone notizie: con Arduino è tutto più facile.

Il seguente esempio visualizza un messaggio sul display LCD e il tempo in secondi dall’ultimo resetdella scheda Arduino. Nella prima parte del nostro corso abbiamo detto che con Arduino non hasenso scrivere Hello sul video come primo esempio. Ha senso invece farlo su un display esternoLCD, anzi è molto istruttivo.

LiquidCrystal Library semplifica il commando del display. Non è necessario imparare leistruzioni a basso livello. Il modulo LCD Hitachi si può controllore in due modi: con 4 o 8 bit. Ilmodo a 4 bit richiede 7 piedini di Arduino; il modo a 8 bit 11. Il primo modo è sufficiente nellamaggior parte dei casi. L’esempio che segue riguarda il modo a 4 bit e la visualizzazione su 2 linneeognuna con 16 caratteri.

Hardware richiesto

Arduino BoardLCD Screen (compatibile con Hitachi HD44780 driver)10k Potenziometrobreadboardcavetti

Circuito

Collegare così il display ad Arduino:

LCD RS pin al digital pin 12LCD Enable pin al digital pin 11LCD D4 pin al digital pin 5LCD D5 pin al digital pin 4LCD D6 pin al digital pin 3LCD D7 pin al digital pin 2Inoltre, collegare il potenziometro da 10K pot a +5V e GND col il wiper (output) a LCD VO

pin (pin3).

Codice

/*LiquidCrystal Library - Hello World

Demonstrates the use a 16x2 LCD display. The LiquidCrystallibrary works with all LCD displays that are compatible with theHitachi HD44780 driver. There are many of them out there, and youcan usually tell them by the 16-pin interface.

This sketch prints "Hello World!" to the LCDand shows the time.

The circuit:* LCD RS pin to digital pin 12* LCD Enable pin to digital pin 11* LCD D4 pin to digital pin 5* LCD D5 pin to digital pin 4

* LCD D6 pin to digital pin 3* LCD D7 pin to digital pin 2* LCD R/W pin to ground* 10K resistor:* ends to +5V and ground* wiper to LCD VO pin (pin 3)

Library originally added 18 Apr 2008by David A. Mellislibrary modified 5 Jul 2009by Limor Fried (http://www.ladyada.net)example added 9 Jul 2009by Tom Igoemodified 22 Nov 2010by Tom Igoe

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/LiquidCrystal*/

// include the library code:#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pinsLiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {// set up the LCD's number of columns and rows:lcd.begin(16, 2);// Print a message to the LCD.lcd.print("hello, world!");

}

void loop() {// set the cursor to column 0, line 1// (note: line 1 is the second row, since counting begins with

0):lcd.setCursor(0, 1);// print the number of seconds since reset:lcd.print(millis()/1000);

}

Vedi anche:

lcd.begin()lcd.print()lcd.setCursor()

Liquid Crystal LibraryBlink: control of the block-style cursor.Cursor: control of the underscore-style cursor.Display: quickly blank the display without losing what's on it.TextDirection: control which way text flows from the cursor.Scroll: scroll text left and right.

Serial input: accepts serial input, displays it.SetCursor: set the cursor position.Autoscroll: shift text right

Display grafico LCD (Arduino shield)

Display grafico LCD per Arduino

Un programma esemplificativo

#ifndef LCD4884_h

#define LCD4884_h

#ifdef PD1

#define LCD_RST PD6

#define SPI_CS PD5

#define SPI_MOSI PD3

#define SPI_SCK PD2

#define LCD_DC PD4

#define LCD_BL PD7

#else

#define LCD_RST PORTD6

#define SPI_CS PORTD5

#define SPI_MOSI PORTD3

#define SPI_SCK PORTD2

#define LCD_DC PORTD4

#define LCD_BL PORTD7

#endif

//display mode -- normal / highlight

#define MENU_NORMAL 0

#define MENU_HIGHLIGHT 1

class LCD4884

{

public:

LCD4884();

void LCD_init(void);

void LCD_backlight(unsigned char dat);

void LCD_write_byte(unsigned char dat, unsigned char dat_type);

void LCD_draw_bmp_pixel(unsigned char X,unsigned char Y,unsigned char *map,unsigned charPix_x,unsigned char Pix_y);

void LCD_write_string(unsigned char X,unsigned char Y,char *s, char mode);

void LCD_write_chinese(unsigned char X, unsigned char Y,unsigned char *c,unsigned charch_with,unsigned char num,unsigned char line,unsigned char row);

void LCD_write_string_big ( unsigned char X,unsigned char Y, char *string, char mode );

void LCD_write_char_big (unsigned char X,unsigned char Y, unsigned char ch, char mode);

void LCD_write_char(unsigned char c, char mode);

void LCD_set_XY(unsigned char X, unsigned char Y);

void LCD_clear(void);

};

extern LCD4884 lcd;

#endif //#include "LCD4884.h"

#include "font_6x8.h"

#include "font_big.h"

extern "C"

{

#include <avr/pgmspace.h>

#include <avr/io.h>

#include "WConstants.h"

}

LCD4884::LCD4884()

{};

LCD4884 lcd = LCD4884();

void LCD4884::LCD_backlight(unsigned char dat)

{

if(dat==1)PORTD |= (1<<LCD_BL); // turn on backlight

else PORTD &= ~(1<<LCD_BL);

}

void LCD4884::LCD_init(void)

{

// LCD_RST = 0;

DDRD |=(1<<SPI_CS)|(1<<LCD_DC)|(1<<LCD_RST)|(1<<SPI_MOSI)|(1<<SPI_SCK)|(1<<LCD_BL);

PORTD &= ~(1<<LCD_RST);

delayMicroseconds(1);

PORTD |= (1<<LCD_RST);

PORTD &= ~(1<<SPI_CS);

delayMicroseconds(1);

PORTD |= (1<<SPI_CS);

delayMicroseconds(1);

PORTD |= (1<<LCD_BL); // turn on backlight

LCD_write_byte(0x21, 0);

LCD_write_byte(0xc0, 0);

LCD_write_byte(0x06, 0);

LCD_write_byte(0x13, 0);

LCD_write_byte(0x20, 0);

LCD_clear();

LCD_write_byte(0x0c, 0);

PORTD &= ~(1<<SPI_CS);

}

void LCD4884::LCD_write_byte(unsigned char dat, unsigned char dat_type)

{

unsigned int i;

PORTD &= ~(1<<SPI_CS);

if (dat_type == 0)

PORTD &= ~(1<<LCD_DC);

else

PORTD |= (1<<LCD_DC);

for(i=0;i<8;i++)

{

if(dat&0x80)

{

PORTD |= (1<<SPI_MOSI); //SDIN = 1;

}

else

{

PORTD &= ~(1<<SPI_MOSI); //SDIN = 0;

}

PORTD &= ~(1<<SPI_SCK); //SCLK = 0;

dat = dat << 1;

PORTD |= (1<<SPI_SCK); //SCLK = 1;

}

PORTD |= (1<<SPI_CS);

}

void LCD4884::LCD_draw_bmp_pixel(unsigned char X,unsigned char Y,unsigned char *map,

unsigned char Pix_x,unsigned char Pix_y)

{

unsigned int i,n;

unsigned char row;

if (Pix_y%8==0) row=Pix_y/8;

else

row=Pix_y/8+1;

for (n=0;n<row;n++)

{

LCD_set_XY(X,Y);

for(i=0; i<Pix_x; i++)

{

LCD_write_byte(map[i+n*Pix_x], 1);

}

Y++;

}

}

void LCD4884::LCD_write_string(unsigned char X,unsigned char Y,char *s, char mode)

{

LCD_set_XY(X,Y);

while (*s)

{

LCD_write_char(*s, mode);

s++;

}

}

void LCD4884::LCD_write_chinese(unsigned char X, unsigned char Y,unsigned char *c,unsignedchar ch_with,unsigned char num,unsigned char line,unsigned char row)

{

unsigned char i,n;

LCD_set_XY(X,Y);

for (i=0;i<num;)

{

for (n=0; n<ch_with*2; n++)

{

if (n==ch_with)

{

if (i==0) LCD_set_XY(X,Y+1);

else

{

LCD_set_XY((X+(ch_with+row)*i),Y+1);

}

}

LCD_write_byte(c[(i*ch_with*2)+n],1);

}

i++;

LCD_set_XY((X+(ch_with+row)*i),Y);

}

}

void LCD4884::LCD_write_string_big ( unsigned char X,unsigned char Y, char *string, char mode)

{

while ( *string ){

LCD_write_char_big( X, Y, *string , mode );

if(*string++ == '.')

X += 5;

else

X += 12;

}

}

/* write char in big font */

void LCD4884::LCD_write_char_big (unsigned char X,unsigned char Y, unsigned char ch, charmode)

{

unsigned char i, j;

unsigned char *pFont;

unsigned char ch_dat;

pFont = (unsigned char *) big_number;

if(ch == '.')

ch = 10;

else if (ch == '+')

ch = 11;

else if (ch == '-')

ch = 12;

else

ch = ch & 0x0f;

for(i=0;i<3;i++)

{

LCD_set_XY ( X, Y+i);

for(j=0; j<16; j++){

ch_dat = pgm_read_byte(pFont+ch*48 + i*16 +j);

LCD_write_byte( (mode == MENU_NORMAL)? ch_dat : (ch_dat^0xff), 1);

}

}

}

void LCD4884::LCD_write_char(unsigned char c, char mode)

{

unsigned char line;

unsigned char *pFont;

byte ch;

pFont = (unsigned char *)font6_8;

c -= 32;

for (line=0; line<6; line++){

ch = pgm_read_byte(pFont+c*6+line);

LCD_write_byte( (mode==MENU_NORMAL)? ch: (ch^ 0xff) , 1);

}

}

void LCD4884::LCD_set_XY(unsigned char X, unsigned char Y)

{

LCD_write_byte(0x40 | Y, 0); // column

LCD_write_byte(0x80 | X, 0); // row

}

void LCD4884::LCD_clear(void)

{

unsigned int i;

LCD_write_byte(0x0c, 0);

LCD_write_byte(0x80, 0);

for (i=0; i<504; i++)

LCD_write_byte(0, 1);

}// big font

#include <avr/pgmspace.h>

//******* VERY LARGE FONTS **********

//used here for displaying temperature

unsigned char big_number[13][3][16] PROGMEM = {

0,128,192,224,224,96,224,224, //'0'

192,128,0,0,0,0,0,0

,

112,255,255,1,0,0,0,0,

255,255,254,0,0,0,0,0

,

0,15,31,60,56,48,56,56,

31,15,3,0,0,0,0,0

,

0,0,0,0,128,224,224,0, //'1'

0,0,0,0,0,0,0,0

,

0,0,3,3,3,255,255,0,

0,0,0,0,0,0,0,0

,

0,0,56,56,56,63,63,56,

56,56,0,0,0,0,0,0

,

0,192,192,224,96,96,224,224, //'2'

192,128,0,0,0,0,0,0

,

0,1,0,0,128,192,224,249,

63,31,0,0,0,0,0,0

,

0,60,62,63,63,59,57,56,

56,56,56,0,0,0,0,0

,

0,192,224,224,96,96,224,224, //'3'

192,192,0,0,0,0,0,0

,

0,1,0,0,48,48,56,125,

239,207,0,0,0,0,0,0

,

0,28,56,56,48,48,56,60,

31,15,1,0,0,0,0,0

,

0,0,0,0,0,128,192,224, //'4'

224,0,0,0,0,0,0,0

,

224,240,248,222,207,199,193,255,

255,192,192,0,0,0,0,0

,

0,0,0,0,0,0,0,63,

63,0,0,0,0,0,0,0

,

0,224,224,224,224,224,224,224, //'5'

224,224,224,0,0,0,0,0

,

0,63,63,63,56,56,48,112,

240,224,0,0,0,0,0,0

,

0,28,56,56,48,48,56,60,

31,15,1,0,0,0,0,0

,

0,0,128,192,192,224,96,96, //'6'

224,224,0,0,0,0,0,0

,

224,254,255,55,57,24,24,56,

240,240,192,0,0,0,0,0

,

0,15,31,28,56,48,48,56,

31,15,7,0,0,0,0,0

,

0,224,224,224,224,224,224,224, //'7'

224,224,224,0,0,0,0,0

,

0,0,0,0,128,224,248,126,

31,7,1,0,0,0,0,0

,

0,0,56,62,31,7,1,0,

0,0,0,0,0,0,0,0

,

0,128,192,224,224,96,96,224, //'8'

192,192,0,0,0,0,0,0

,

0,207,255,127,56,48,112,112,

255,239,199,0,0,0,0,0

,

3,15,31,60,56,48,48,56,

31,31,15,0,0,0,0,0

,

0,128,192,224,224,96,224,224, //'9'

192,128,0,0,0,0,0,0

,

12,63,127,241,224,192,192,225,

255,255,254,0,0,0,0,0

,

0,0,56,48,48,56,56,30,

15,7,0,0,0,0,0,0

,

0,0,0,0,0,0,0,0, //'.'

0,0,0,0,0,0,0,0

,

0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0

,

60,60,60,0,0,0,0,0,

0,0,0,0,0,0,0,0

,

0,0,0,0,0,0,0,0, //'+'

0,0,0,0,0,0,0,0

,

0,0,64,64,64,64,64,254,

254,64,64,64,64,64,0,0

,

0,0,0,0,0,0,0,15,

15,0,0,0,0,0,0,0

,

0,0,0,0,0,0,0,0, //'-'

0,0,0,0,0,0,0,0

,

0,64,64,64,64,64,64,0,

0,0,0,0,0,0,0,0

,

0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0

};// 6 x 8 font

// 1 pixel space at left and bottom

// index = ASCII - 32

#include <avr/pgmspace.h>

unsigned char font6_8[][6] PROGMEM =

{

{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // sp

{ 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00 }, // !

{ 0x00, 0x00, 0x07, 0x00, 0x07, 0x00 }, // "

{ 0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14 }, // #

{ 0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, // $

{ 0x00, 0x62, 0x64, 0x08, 0x13, 0x23 }, // %

{ 0x00, 0x36, 0x49, 0x55, 0x22, 0x50 }, // &

{ 0x00, 0x00, 0x05, 0x03, 0x00, 0x00 }, // '

{ 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00 }, // (

{ 0x00, 0x00, 0x41, 0x22, 0x1c, 0x00 }, // )

{ 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14 }, // *

{ 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08 }, // +

{ 0x00, 0x00, 0x00, 0xA0, 0x60, 0x00 }, // ,

{ 0x00, 0x08, 0x08, 0x08, 0x08, 0x08 }, // -

{ 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 }, // .

{ 0x00, 0x20, 0x10, 0x08, 0x04, 0x02 }, // /

{ 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E }, // 0

{ 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00 }, // 1

{ 0x00, 0x42, 0x61, 0x51, 0x49, 0x46 }, // 2

{ 0x00, 0x21, 0x41, 0x45, 0x4B, 0x31 }, // 3

{ 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10 }, // 4

{ 0x00, 0x27, 0x45, 0x45, 0x45, 0x39 }, // 5

{ 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30 }, // 6

{ 0x00, 0x01, 0x71, 0x09, 0x05, 0x03 }, // 7

{ 0x00, 0x36, 0x49, 0x49, 0x49, 0x36 }, // 8

{ 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E }, // 9

{ 0x00, 0x00, 0x36, 0x36, 0x00, 0x00 }, // :

{ 0x00, 0x00, 0x56, 0x36, 0x00, 0x00 }, // ;

{ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 }, // <

{ 0x00, 0x14, 0x14, 0x14, 0x14, 0x14 }, // =

{ 0x00, 0x00, 0x41, 0x22, 0x14, 0x08 }, // >

{ 0x00, 0x02, 0x01, 0x51, 0x09, 0x06 }, // ?

{ 0x00, 0x32, 0x49, 0x59, 0x51, 0x3E }, // @

{ 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C }, // A

{ 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 }, // B

{ 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 }, // C

{ 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C }, // D

{ 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 }, // E

{ 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 }, // F

{ 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A }, // G

{ 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F }, // H

{ 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 }, // I

{ 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 }, // J

{ 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 }, // K

{ 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 }, // L

{ 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F }, // M

{ 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F }, // N

{ 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E }, // O

{ 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 }, // P

{ 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E }, // Q

{ 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 }, // R

{ 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 }, // S

{ 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 }, // T

{ 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F }, // U

{ 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F }, // V

{ 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F }, // W

{ 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 }, // X

{ 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 }, // Y

{ 0x00, 0x61, 0x51, 0x49, 0x45, 0x43 }, // Z

{ 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 }, // [

{ 0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55 }, // 55

{ 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00 }, // ]

{ 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 }, // ^

{ 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 }, // _

{ 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 }, // '

{ 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 }, // a

{ 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 }, // b

{ 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 }, // c

{ 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F }, // d

{ 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 }, // e

{ 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 }, // f

{ 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C }, // g

{ 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 }, // h

{ 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 }, // i

{ 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00 }, // j

{ 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 }, // k

{ 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 }, // l

{ 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 }, // m

{ 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 }, // n

{ 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 }, // o

{ 0x00, 0xFC, 0x24, 0x24, 0x24, 0x18 }, // p

{ 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC }, // q

{ 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 }, // r

{ 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 }, // s

{ 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 }, // t

{ 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C }, // u

{ 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C }, // v

{ 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C }, // w

{ 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 }, // x

{ 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C }, // y

{ 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 }, // z

{ 0x00,0x00, 0x06, 0x09, 0x09, 0x06 } // horiz lines

};

Il linguaggio Processing

Il linguaggio Processing è basato su Java. L’ambiente di sviluppo di Arduino è scritto in Processing.

Processing deve essere installato dopo averlo scaricato dal sito di Arduino. La programmazione è più

semplice del linguaggio Java usuale. E’ particolarmente adatto per programmi di grafica ed è stato usato

anche in ambiente artistico. Per familiarizzarsi conviene caricare un esempio già pronto. Caricare dagli

esempi, sezione Motion, Bounce. Premere Run. Avrete sperimentato un’applet Java.

L'ambiente di programmazione PROCESSING in generale

Processing è un ambiente di programmazione sviluppato al Media Lab del MIT, il cuiscopo è di permettere ad artisti, designer ed in generale a persone con scarse cognizionidi informatica ma attratte dalle possibilità di applicazione dell'informatica all'arte e aldesign di poter scrivere dei programmi, più o meno sofisticati, in breve tempo, utilizzandouno strumento facile da usare ma sufficientemente potente per fare delle sperimentazioninel settore della "computer art" e dell' "interaction design".Processing è un prodotto open source disponibile per le piattaforme Windows, Macintoshe Linux; lo si può scaricare dal sito ufficiale..Processing è molto semplice da usare: si scrive il testo di un programma e lo si esegue(con il comando "run" o premendo il pulsante "Play" all'estrema sinistra della finestradell'applicazione). I programmi scritti possono ovviamente essere salvati esuccessivamente modificati. Il tutto si fa in modo semplice e intuitivo, così che anche unutente inesperto possa imparare in pochi minuti ad usarlo.Java è un linguaggio relativamente recente ed è considerato il linguaggio più adatto per leapplicazioni distribuite e per Internet. E’ scaricabile gratuitamente. Consente unaprogrammazione procedurale classica, con sintassi simile al linguaggio C. E’ anche unlinguaggio orientato agli oggetti, con sintassi simile al C++. La programmazione per oggettinon è semplicissima per chi non è abituato. Arduino con Processing rende le cose un po’più facili.

Ecco un esempio di programmazione procedurale per disegnare figure:

void setup() {size (256,256);backgrond(0);

}void draw() {

stroke(255);strokeWeight(1);ellipseMode(CORNER);ellipse(72,100,110,130);triangle(88,100,168,100,128,50);stroke(140);beginShape(TRIANGLES);vertex(114,180);vertex(mouseX,mouseY);

vertex(140,180);endShape();strokeWeight(4);line(96,150,112,150);line(150,150,166,150);line(120,200,136,200);

}

E ora un esempio di programmazione orientata agli oggetti:

Puppet pinocchio;void setup() {

size(256,256);background(0);color tempcolor = color(255,0,0);pinocchio = new Puppet(tempcolor);

}void draw() {

background(0);pinocchio.draw();

}class Puppet {

color colore;colore = c_;}void draw () {stroke(255);strokeWight(1);ellipseMode(CORNER);ellipse(72,100,110,130);stroke(colore);beginShape(TRIANGLES);vertex(114,180);vertex(mouseX,mouseY);vertex(140,180);endShape();strokeWeight(4);line(96,150,112,150),line(150,150,166,150);}

}

Tipi di dati

Variabili: se si riferiscono a tipi primitivi B = A provoca la copia di a in b. Se i dati sonooggetti e array, viene creato un puntatore.

Scope: è l’ambito in cui si può accedere ad una variabile. Global scope significa che lavariabile è visibile ovunque ed è dichiarata fuori da setup(). Local scope significa che èdefinita all’interno di un blocco di programma ed visibile solo al suo interno.

Funzioni: come in C e C++ sono lo strumento principalee consentono unaprogrammazione modulare.

Classi e Oggetti

Una classe è un insieme di dati e funzioni. Un oggetto è un’istanza di una classe.

Processing su Arduino

Le strutture di controllo di un linguaggio di programmazione sono dei costrutti (frasi) dellinguaggio che controllano l’ordine di esecuzione delle istruzioni di un programma.

Sequenza: le istruzioni sono eseguite in sequenza una dopo l’altra. Selezione: scelta dell’istruzione da eseguire tra più alternative. Iterazione: ripetizione (un certo numero di volte) di un gruppo di istruzioni.

Sequenza

Sequenza : giustapposizione di istruzioni separate da “;” (punto e virgola)Una o più istruzioni possono essere raggruppate tra parentesi graffe{I1; …; In;}

per formare una singola istruzione. Le istruzioni sono eseguite nell’ordine in cui appaiono:I1, … , InEsempioIl primo esempio di programma Processing disegna cinque rette oblique tra loro parallele.

l'istruzione size(200, 200) crea una finestra di 200 per 200 pixel entro cui avviene ildisegno,l'istruzione background(0) sceglie il nero come colore dello sfondo,l'istruzione stroke(255) sceglie il bianco come colore per il disegno delle linee,l'istruzione strokeWeight(5) imposta lo spessore delle linee a 5 pixel,

l'istruzione smooth()arrotonda l'estremità delle linee.Ciascuna delle 5 linee di codice che seguono disegna una linea, ad es. l'istruzioneline(10, 80, 30, 40)disegna una linea con estremi nei punti di coordinate (10, 80) e (30,40).Il sistema di coordinate di Processing pone l'origine degli assi nell'angolo superiore sinistrodella finestra di disegno, per cui spostandosi verso destra aumenta il valore della primacoordinata di un punto, mentre spostandosi verso il basso aumenta il valore della secondacoordinata.

Si noti che l'immagine appare in bianco e nero, poiché è stato scelto di disegnare conimmagini a livelli di grigio, scelti tra 256 tonalità diverse: 0 per il nero e 255 per il bianco.Ogni istruzione del programma è seguita da un commento, un testo inserito comedocumentazione del programma, che non viene considerato come codice, ma vienescartato durante l'esecuzione del programma. I commenti usati in questo programma sonomonoriga, ovvero iniziano dopo i simboli "//" e terminano in fondo alla riga.Uso delle variabiliSe si osserva attentamente il programma precedente, le cinque righe parallele sonodisegnate incrementando di 10 unità la prima componente dei punti estremi di ogni retta.Il prossimo esempio differisce dal precedente per l'introduzione di una variabile intera dinome x a cui si assegna inizialmente il valore 0 con la dichiarazioneint x = 0

e dopo il disegno di ogni linea è incrementata di 10 unità con il comando di assegnamentox=x+10 .

Una dichiarazione ha il compito di creare una variabile stabilendo il nome e l'insieme deivalori che la variabile può assumere (ovvero il tipo della variabile, in questo caso di tipo intche denota i numeri interi), nonché di riservare nella memoria del calcolatore lo spazionecessario per memorizzare il valore corrente della variabile.In Processing come in Java e tanti altri linguaggi, una variabile non può essere usata senon è prima dichiarata. Invece in JavaScript la dichiarazione di una variabile non ènecessaria.L'effetto finale del programma è sempre lo stesso, ma, a differenza del programmaprecedente, il codice mette bene in evidenza la relazione tra le coordinate delle 5 linee.

I terazione

I costrutti di iterazione eseguono un certo numero di volte un'istruzione, detta corpo. Uncostrutto di iterazione è anche detto istruzione di ciclo, o semplicemente ciclo.Noi esamineremo due tipi di costrutti di iterazione:comando whilewhile (<espressione logica> ) I

L'esecuzione di un comando while causa l'esecuzione dell'istruzione (il corpo del while) sel’espressione logica (il test di while) è vera, poi si valuta di nuovo l’espressione logica: se èvera si esegue di nuovo l’istruzione, e così via finché l’espressione logica diventa falsa.

Esempio di uso del comando while

Osservando il codice degli esempi precedenti, le cinque righe parallele sono disegnateincrementando di 10 unità la prima componente dei punti estremi di ogni retta.Si ha quindi una ripetizione (5 volte) dell'esecuzione del comando di tracciatura delle linee.La tracciatura delle linee può avvenire senza scrivere 5 volte lo stesso comando, usando ilcomando while.

Il corpo del ciclo while disegna una linea ed incrementa il valore della variabile intera x di10 unità.Pertanto, la variabile x assume i valori 0, 10, 20, 30, 40, in corrispondenza dei quali unalinea viene disegnata. Quando assume il valore 50, la guardia del ciclo while diventa falsae l'esecuzione del ciclo termina.La figura seguente mostra come il ciclo while possa essere usato per calcolare i numeritriangolari, ovvero i numeri interi positivi ottenuti come somma dei numeri interi compresitra 1 e un intero positivo n.

Il programma funziona in modo analogo.

comando for

for (I1 ; E ; I2 ) I3

I1 è l’istruzione di inizializzazione;E è il test del for ;I2 è l’istruzione di incremento o aggiornamento;I3 è il corpo del for ;l'esecuzione di un comando for avviene come segue: innanzi tutto è eseguita l'istruzione I1di inizializzazione (che di solito assegna un valore ad una variabile, detta variabile dicontrollo del ciclo for); se la guardia è vera si esegue il corpo I3 e l’aggiornamento I2 , poi sivaluta di nuovo la guardia: se è vera si esegue di nuovo il corpo e l’aggiornamento, finchéla guardia diventa falsa.

Esempio di uso del comando for

Questo esempio è una riscrittura del programma precedente usando il ciclo for. Si noti chel'istruzione che assegna 0 alla variabile x è l'istruzione di inizializzazione del ciclo for,mentre l'istruzione che incrementa di 10 unità il valore di x è l'istruzione di aggiornamentodel ciclo for. Il corpo del for è costituito dalla sola istruzione di tracciatura di una linea eviene ripetuto 5 volte.

Attenzione: le istruzioni di ciclo non sono solo dei semplici sostituti del comando disequenzializzazione che permettono di abbreviare i programmi, ma permettono di faremolto di più. Se non usiamo i cicli e vogliamo disegnare 10 righe anziché 5, dobbiamomodificare il programma, aggiungendo 5 nuovi comandi di disegno.Il prossimo esempio mostra come con le istruzioni di iterazione sia possibile disegnare unnumero di linee che dipende dal numero di secondi del tempo in cui si lancia l'esecuzionedel programma: non è pertanto stabilire a priori quante linee si devono disegnare e un taleprogramma non si può realizzare con la sola sequenzializzazione di comandi.

Alla variabile intera s è assegnato il numero dei secondi letti dall'orologio del calcolatore.Nell'immagine precedente il testo che appare nella finestra del terminale indica che ilvalore assegnato ad s è 4. Il programma disegnerà pertanto quattro righe, come mostratonella figura seguente:

Il corpo

line(5*x+10, 40, 5*x+10, 80);

del comando for successivo che esegue la tracciatura di una linea verticale è eseguito unnumero di volte pari al valore della variabile s: infatti, la variabile x di conteggio del for èinizializzata a 0 e fintanto che il suo valore è minore di quello di s, si traccia una linea e siincrementa il valore di x.In generale, se s è una variabile intera con un valore definito, l'esecuzione del ciclofor(int x = 0; x<s; x=x+1){

/* corpo del for */};

provoca l'esecuzione ripetuta s volte del corpo del for.Con le istruzioni di ciclo, si può incappare nel cosidetto "fencepost error" (errore dellosteccato e dei pali), che consiste nell'eseguire il corpo del ciclo una volta in più o in menodel numero corretto di iterazioni. Per essere sicuri che il programma funzionicorrettamente, provate ad assegnare dei valori piccoli alla variabile s, ad es. 0 o 1 evedete cosa succede: se le prove hanno successo, allora il programma dovrebbe esserecorretto.Per concludere l'analisi di quest'esempio, si noti il commento multiriga in fondo al codice.Si tratta di un tipo di commento che inizia con i simboli "/*" , termina con i simboli "*/" e puòoccupare un numero arbitrario di righe di testo.

Selezione

I costrutti di selezione scelgono di eseguire un'istruzione piuttosto che un'altra in base alvalore di un'espressione logica ( espressione che assume solo due valori, vero o falso, epertanto una tale espressione è anche detta espressione booleana, da George Boole,matematico e logico del diciannovesimo secolo).Noi esamineremo due tipi di costrutti di selezione:comando ifif (<espressione logica> ) I1L'esecuzione di tale comando causa l'esecuzione dell'istruzione I1 se l’espressione logica(detta guardia) è vera

Esempio di uso del comando if

Il seguente programma disegna 5 righe parallele di colore grigio se, al momentodell'esecuzione del programma, l'orologio del calcolatore indica un'orario in cui il valore deisecondi è inferiore a 30; in caso contrario, le righe sono di colore bianco. La decisione diquale colore applicare è fatta con il costrutto if.

Il colore delle linee da tracciare viene preimpostato con la terza riga di codicestroke(255)

che sceglie il colore bianco. Il successivo comando ifif (s<30){

stroke(128); // Set line value to gray};

imposta con l'istruzione stroke(128)il colore grigio come colore di tracciatura se il numerodei secondi, contenenuto nella variabiles è minore di 30.comando if-elseif (<espressione logica> ) I1else I2

L'esecuzione di tale comando causa l'esecuzione dell'istruzione I1 se l’espressione logicaè vera; dell'istruzione I2 in caso contrario.

Esempio di uso del comando if-else

Il seguente programma disegna 5 righe parallele di colore grigio se, al momentodell'esecuzione del programma, l'orologio del calcolatore indica un'orario in cui il valore deisecondi è inferiore a 30; in caso contrario, le righe sono di colore bianco. La decisione diquale colore applicare è fatta con il costrutto if-else

A differenza dell'esempio precedente, il colore delle linee da tracciare non vienepreimpostato, ma viene determinato dal comando if-elseif (s<30){

stroke(128); // Set line value to gray}else {

stroke(255); // Set line value to white};

che imposta con l'istruzione stroke(128)il colore grigio come colore di tracciatura se ilnumero dei secondi, contenenuto nella variabiles è minore di 30, mentre in caso contrarioil colore di tracciatura è impostato al colore bianco con l'istruzionestroke(255).

Primo esempio di grafica 2D

Il prossimo semplicissimo programma mostra come disegnare semplici figuregeometriche. Per un approfondimento, si veda il link GRAFICA 2D e per informazionisull'uso delle primitive grafiche 2D (istruzioni per il disegno di figure geometriche

bidimensionali, si consulti l'elenco denominato "2D Primitives" alla pagina del manuale diriferimento di Processing .

Il programma è quasi autoesplicativo. Gli unici commenti riguardano i comandistroke() e fill(), che

stabiliscono il colore di disegno dei contorni e rispettivamente dell'area interna di una figura. I tre

numeri interi che costituiscono gli argomenti di queste istruzioni rappresentano un colore in

formato RGB (Red, Green, Blue) . Al contrario, i metodi noStroke() e noFill() inibiscono il disegno

del contorno o dell'interno di una figura, fino all'esecuzione di un nuovo comando stroke() o fill().Il

comando bezier() disegna una curva di Beziér, definita da quattro punti: i punti estremi e due punti

di controllo che ne determinano la curvatura.

Per comprendere meglio le curve di Beziér, segui questo link.

Per determinare il codice RGB di un colore o viceversa per determinare il colore di una

tripla RGB di numeri interi, si può usare nel menu "Tools" di Processing l'opzione "Color

selector".

Il risultato dell'esecuzione del programma è il seguente

Note sull 'esecuzione dei programmi

Come abbiamo visto, Processing dà la possibilità di scrivere ed eseguire programmi inmodo immediato. Il codice dei programmi scritti è memorizzato in un file con estensione".pde" (sigla di Processing Development Environment).Al momento della sua esecuzione, tale file viene tradotto in un codice detto bytecode,contenuto insieme ad altri file all'interno di un file con estensione ".jar" (sigla di JavaARchive).Il bytecode all'interno del file jar viene eseguito dall'interprete Java, detto anche JRE (sigladi Java Run-time Environment) o JVM (sigla di Java Virtual Machine).Le fasi di traduzione (detta comunemente compilazione) del codice sorgente (il file pde) edi esecuzione del bytecode avvengono in modo trasparente per l'utente. Tutti i file prodottimantengono lo stesso nome, cambiando solo l'estensione.In realtà, il bytecode prodotto da Processing è un programma di tipo speciale, detto applet,che può essere inserito all'interno di una pagina web con un'apposito marcatore <applet>.

In questo modo, il programma una volta compilato è inserito all'interno di una pagina webe, al momento della visualizzazione della pagina, l'applet è eseguito. L'unica cosanecessaria per la visualizzazione degli applet è che sul calcolatore sia installato l'interpreteJava, (JRE o JVM).Attenzione, Processing crea l'applet solo se si esegue il comando "export".In tal caso, esso genera il bytecode dell'applet ed una semplice pagina web di nomeindex.html contenente un riferimento all'applet mediante il marcatore omonimo.Di seguito sono elencati i collegamenti alle pagine web contenenti gli esempi visti finora,più alcuni esempi supplementari.Processing può anche creare un'applicazione se si esegue il comando "exportapplication".In tal caso, esso genera oltre al bytecode dell'applet un file eseguibile che avvia a suavolta l'esecuzione dell'applet. L'applicazione può essere generata per i sistemi Windows,Mac e Linux.

Esempi vari

Ecco il programma Rimbalza (bounce)

/**

* Bounce.

*

* When the shape hits the edge of the window, it reverses its direction.

*

* Updated 1 September 2002

*/

import processing.serial.*;

String portname = "/dev/tty.usbserial-A4001qa8";

Serial port; // Create object from Serial class

int size = 60; // Width of the shape

float xpos, ypos; // Starting position of shape

float xspeed = 3.9; // Speed of the shape

float yspeed = 3.1; // Speed of the shape

int xdirection = 1; // Left or Right

int ydirection = 1; // Top to Bottom

void setup()

{

size(400, 400);

colorMode(HSB, 255);

noStroke();

frameRate(30);

ellipseMode(CENTER); // draw from center out

smooth();

// Set the starting position of the shape

xpos = width/2;

ypos = height/2;

// Open the port that the board is connected to and use the same speed (19200 bps)

port = new Serial(this, portname, 19200);

}

void draw()

{

if (port.available() > 0) { // If data is available,

size = port.read(); // read it and store it as the new size

}

background(102);

// Update the position of the shape

xpos = xpos + ( xspeed * xdirection );

ypos = ypos + ( yspeed * ydirection );

// Test to see if the shape exceeds the boundaries of the screen

// If it does, reverse its direction by multiplying by -1

int halfsize = size/2; // because we're drawing from the circle's center

if (xpos + halfsize > width || xpos - halfsize < 0) {

xdirection *= -1;

}

if (ypos + halfsize > height || ypos - halfsize < 0) {

ydirection *= -1;

}

// Draw the shape

fill(size,255,255); // we're in HSB mode, so first value is color

ellipse(xpos, ypos, size, size);

}

Ora un gioco (Pong)

/**

*

* When the shape hits the edge of the window, it reverses its direction.

*

* Updated 1 September 2002

*/

import processing.serial.*;

String portname = "/dev/tty.usbserial-A4001qa8";

Serial port; // Create object from Serial class

int size = 60; // Width of the shape

float xpos, ypos; // Starting position of shape

float xspeed = 3.9; // Speed of the shape

float yspeed = 3.1; // Speed of the shape

int xdirection = 1; // Left or Right

int ydirection = 1; // Top to Bottom

void setup()

{

size(400, 400);

colorMode(HSB, 255);

noStroke();

frameRate(30);

ellipseMode(CENTER); // draw from center out

smooth();

// Set the starting position of the shape

xpos = width/2;

ypos = height/2;

// Open the port that the board is connected to and use the same speed (19200 bps)

port = new Serial(this, portname, 19200);

}

void draw()

{

if (port.available() > 0) { // If data is available,

size = port.read(); // read it and store it as the new size

}

background(102);

// Update the position of the shape

xpos = xpos + ( xspeed * xdirection );

ypos = ypos + ( yspeed * ydirection );

// Test to see if the shape exceeds the boundaries of the screen

// If it does, reverse its direction by multiplying by -1

int halfsize = size/2; // because we're drawing from the circle's center

if (xpos + halfsize > width || xpos - halfsize < 0) {

xdirection *= -1;

}

if (ypos + halfsize > height || ypos - halfsize < 0) {

ydirection *= -1;

}

// Draw the shape

fill(size,255,255); // we're in HSB mode, so first value is color

ellipse(xpos, ypos, size, size);

}

Ecco un altro esempio

* Simple Read** Read data from the serial port and change the color of a rectangle* when a switch connected to a Wiring or Arduino board is pressed and

released.* This example works with the Wiring / Arduino program that follows below.*/

import processing.serial.*;

String portname = "/dev/tty.usbserial-A4001qa8"; // or "COM8"Serial port; // Create object from Serial class

int val=100; // Data received from the serial port, with an initial value

void setup(){

size(400, 400);

colorMode(HSB, 255);ellipseMode(CENTER); // draw from center outnoStroke();frameRate(30);smooth();

// Open the port the board is connected toport = new Serial(this, portname, 19200);

}

void draw()

{if (port.available() > 0) { // If data is available,val = port.read(); // read it and store it in val

}background(99);// Draw the shapefill(val,255,255); // we're in HSB mode, so first value is colorellipse(width/2, height/2, 250,250);

}

Ora Arduino suona!

* Arduino Sounds** Play WAV or MP3 files when piezo knocks from an Arduino running the* "PiezoKnock" sketch or when a computer keyboard key is pressed.** Taken from the Minim "trigger" sketch:** This sketch demonstrates how to use the <code>trigger</code> method of an

<code>AudioSample</code>. <br />* <code>AudioSample</code>s can only be triggered, not cue'd and looped* or anything else you might do with an <code>Playable</code> object. The

advantage, however, is that* an <code>AudioSample</code> can be retriggered while it is still playing,

which will cause the sample to* overlap with itself .*/

import ddf.minim.*;import processing.serial.*;

String portname = "/dev/tty.usbserial-A4001qa8"; // or "COM8"Serial port; // Create object from Serial class

AudioSample sounds[];String sound_names[] ={

"cat.wav","fx.mp3","electric_wrench.wav","wehoa.mp3","oriental_gong_2.wav","yipee.wav","car_brake.wav"// find more wav or mp3 files and put them in the "data" directory

};

void setup(){

size(400, 400);background(0);stroke(255);// always start Minim before you do anything with itMinim.start(this);Minim.debugOn();

sounds = new AudioSample[sound_names.length];for( int i=0; i< sound_names.length; i++ ) {sounds[i] = Minim.loadSample(sound_names[i], 512);

}

// Open the port that the board is connected to and use the same speed(19200 bps)

port = new Serial(this, portname, 19200);

}

void draw(){

// do the drawing on events}

void soundball() {int r = int(random(sounds.length));println("picked sound #"+r);sounds[r].trigger(); // play a random sound

int x = int(random(0,300));int y = int(random(0,300));fill(240,0,0);ellipse(x,y, 40,40);fill(30,0,0);ellipse(x,y, 8,8);

}

void serialEvent(Serial p) {char inByte = port.readChar();println("received char: "+ inByte);if( inByte == '!' ) { // '!' is end of "knock!"soundball();

}}

void keyPressed() {if(key == ' ') {background(40,40,40); // erase screen

}soundball();

}

void stop(){

// always close Minim audio classes when you are done with themfor( int i=0; i<sounds.length; i++ ) {sounds[i].close();

}super.stop();

}

Bibliografia

-M. Banzi, Getting started with Arduino, O’Reilly, Cabridge,Beijing, 2009

-Tod E. Kurt, Bionic Arduino, MachineProject, 2007

-S. Monk, 30 Arduino Projects, McGrawHill, New York,2010

-M. Schmidt, Arduino, A Quick-Start Giude, The Pragmatic Programmers, 2011

-C. Reas and Ben Fry, Getting Started with Processing, O’Reilly, 2010

-www.arduino.cc

-www.webalice.it

-www.shiffman.net/itp

Grazie per l’attenzione. Buon apprendimento.