chip -casi -"e il" -aggiunto

INTERFACCIA COMANDO LED PER PC
TRAMITE ARDUINO UNO
Descrizione scheda arduino uno.
La Arduino UNO è una scheda basata sul microcontrollore ATmega328.
La scheda Arduino UNO è dotata di 14 pin di input/output digitali (6 dei
quali possono essere usati come segnali PWM), 6 input analogici, un
quarzo a 16MHz, un connettore USB, un jack per l'alimentazione, un
connettore per la programmazione ICSP ed un pulsantino per il reset della
scheda. La scheda inoltre fornisce tutto ciò che è necessario per supportare il
funzionamento del microcontrollore.
Per cominciare ad utilizzare la Arduino UNO è semplicemente necessario
connettere la scheda ad un PC tramite un cavo USB oppure alimentare la
scheda tramite un adattatore AC-to-DC o tramite una semplice batteria.
La Arduino UNO differisce dalle precedenti schede per il fatto che non usa il
chip FTDI USB-to-serial; la scheda Arduino UNO R3 infatti implementa il chip
Atmega16U2 (che rimpiazza il chip Atmega8U2 delle precedenti revisioni)
programmato proprio per essere un convertitore USB-to-serial.
La Arduino UNO sarà una delle schede di riferimento delle future versioni
della Arduino. La UNO è l'ultima fra una serie di schede USB Arduino e
rappresenta un modello di riferimento per le piattaforme Arduino.
La Revisione 3 della scheda Arduino UNO ha le seguenti nuove
caratteristiche che la distinguono dalle precedenti revisioni della stessa
scheda:
 modifiche al 'pinout' della scheda:
o vicino al pin AREF, sono stati aggiunti due pin: SDA e SCL;
o vicino al pin RESET, sono stati aggiunti due nuovi pin. Uno di essi
è identificato con il nome IOREF e permette alle shield di adattare
la propria tensione di alimentazione a quella della scheda Arduino
UNO. L'altro pin non è stato connesso, è stato lasciato disponibile
per le prossime revisioni.
 un circuito di RESET più robusto.
 il chip Atmega16U2 ha rimpiazzato il chip Atmega8U2; con questo
nuovo chip si potrà ottenere un rate maggiore nel trasferimento dei dati
e soprattutto una quantità maggiore di memoria nel trasferimento dei
dati.
La scheda Arduino UNO R3 viene fornita
CON il microcontrollore ATmega328.
Specifiche
•Microcontrollore: Atmel ATmega328
•Tensione operativa: 5V
•Input Voltage: (consigliata) 7-12V
•Input Voltage: (limiti) 6-20V
•Pin di I/O Digitali: 14 (6 dei quali forniscono in uscita segnali PWM)
•Pin di Input Analogici: 6
•DC Current per I/O Pin: 40 mA
•DC Current per Pin alimentati a 3.3V: 50mA
•Flash Memory: 32KB (di cui 0.5KB utilizzati dal bootloader)
•SRAM: 2KB
•EEPROM: 1KB
•Frequenza di Clock: 16MHz
Schema elettrico scheda (shield) con 10 LED
LATO COMPONENTI
PROGRAMMA UTILIZZATO PER IL PILOTAGGIO DEI LED CON TRAMITE
USB
/* Programma per comandare l'accenzione
dei Led della scheda preparata per
tesina sistema con comunicazione tra microcontrollore e PC tramite USB */
// In un vettore di 10 elementi inserisco i pin dove sono collegati i LED
const int LedPin[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
void setup() {
// in questa parte di programma metto
// l'impostazione dei pin dell'arduino con i LED come OUTPUT
// questa parte del programma viene eseguita una sola volta
int i;
for (i=0 ; i<=9 ; i++) {
pinMode(LedPin[i], OUTPUT);
}
// inizializzo la seriale alla velocità di 9600 bps
Serial.begin(9600);
}
void loop() {
// qui inserisco la parte di codice del
// programma che viene ripetuta continuamente
int LedRS232[10]; // memorizzo lo stato dei led in un vettore di 10 interi
int NumByte=0; // in questa variabile memorizzo il numero di byte inviati
presenti sulla seriale
int i;
// aspetto fino a che il numero totale di byte presenti sulla seriale non è
pari a 10
while (NumByte < 10) {
NumByte=Serial.available();
seriale
//
leggo
il
numero
di
byte
presenti
sulla
}
// se esco dal ciclo while, vuol dire che ho ricevuto la configurazione dei 10
LED
for (i=0; i<NumByte; i++) {
LedRS232[i]=Serial.read(); // per ogni byte letto imposto il valore del
vettore con lo stato dei LED
}
for (i=0; i<10; i++) {
Serial.print("LED"); // risposta sulla seriale con i byte letti
Serial.print(i+1);
Serial.print(' ');
Serial.println(char(LedRS232[i]));
if (LedRS232[i]==49){ // 49 è il codice ASCII del carattere "1"
digitalWrite(LedPin[i], HIGH); // accendo il LED corrispondente all'indice
i
}
if (LedRS232[i]==48){ // 48 è il codice ASCII del carattere "0"
digitalWrite(LedPin[i], LOW); // spengo il LED corrispondente all'indice i
}
}
}
// FINE
SPIEGAZIONE DEL PROGRAMMA
Come in tutte le applicazioni dove è necessario usare dei microcontrollori, è
bene tener presente la parte schematica di collegamento tra la scheda
sviluppata e l’HW Arduino.
Dallo schema realizzato si vede che i LED presenti sulla scheda sono stati
collegati ai pin di output digitale a partire da D2 fino a D11, i primi due pin D1
e D2 non sono collegati ai LED perché sono utilizzati dal convertitore USBSeriale presente sulla scheda.
Nella prima parte del programma, la parte che viene eseguita una sola volta,
che inizia con la parola chiave:
void setup() {
indicheremo quali pin usare come input e quali come output. Nel nostro caso
utilizzeremo i pin dal 2 al 11 come pin di output. L’istruzione che consente di
fare tale impostazione è:
pinMode(LedPin[i], OUTPUT);
Il vettore LedPin[i], contiene i pin ai quali sono collegati i LED.
Nel programma si utilizza la comunicazione seriale tramite l’interfaccia USB
per pilotare i LED. L’istruzione che permette di leggere il numero di Byte
presenti nel Buffer seriale è la seguente:
NumByte=Serial.available();
Quando l’istruzione viene eseguita carica nella variabile NumByte la quantità
di byte presente all’ingresso della seriale. Quando questa quantità di byte è
pari a 10, vuol dire che ho ricevuto tutti i byte necessari a definire quali LED
devono essere accesi e quali spenti.
Per leggere i 10 byte presenti in ingresso alla seriale devo andare a leggere i
Byte. L’istruzione che esegue la lettura è la seguente:
LedRS232[i]=Serial.read();
In particolare sulla seriale saranno presenti i caratteri inseriti tramite la
console di monitoraggio seriale. I caratteri saranno letti come Byte con il loro
codice ASCII. Il codice ASCII dei caratteri 0 = 48 del carattere 1 = 49.
L’accensione dei LED è fatto impostando uno stato alto (HIGH) sul
corrispondente pin della scheda Arduino, per spegnere il led si imposta uno
stato basso sul corrispondente pin della scheda arduino. Le istruzioni che
eseguono tale azione sono le seguenti:
if (LedRS232[i]==49){ // 49 è il codice ASCII del carattere "1"
digitalWrite(LedPin[i], HIGH); // accendo il LED corrispondente all'indice
i
}
if (LedRS232[i]==48){ // 48 è il codice ASCII del carattere "0"
digitalWrite(LedPin[i], LOW); // spengo il LED corrispondente all'indice i
}
L’istruzione digitalWrite(LedPin[i], HIGH) accende il LED
L’istruzione digitalWrite(LedPin[i], LOW) spegne il LED.