ho letto che è possibile usare i pin analogici come se fossero digitali...qualcuno mi sa spiegare come si fa, please?
A0 diventa digitale 14
.....
A5 diventa digitale 19
Quindi li inizializzi come gli altri con
pinMode(14, INPUT);
pinMode(15,OUTPUT);
Arduino uno...giusto?
La regola vale per tutti i modelli, solo per la mega il pin A0 diventa il pin 56 ad aumentare.
Certo che se arrivi ad usare gli analogici come digitali sulla mega credo dovresti rivedere il circuito 
ok, grazie mille, mi hai salvato, cosi nn devo fare circuiti esterni ed è tutto più compatto....grazie mille alla prossima XD
Comunque, questa cosa di rinominare i pin (cosa che ho suggerito anche io), mi sono accorto che è una grande scemenza.
Nel core di Arduino, i pin A0, A1 ecc ecc, sia sulla UNO, che sulla MEGA, sulla DUE e sulla Leonardo, sono definiti già con i corrispondenti valori numerici; quindi scrivere
pinMode(A3, OUTPUT);
digitalWrite(A3, HIGH);
o (ed esempio, sulla MEGA)
pinMode(57, OUTPUT);
digitalWrite(55, HIGH);
è perfettamente equivalente.
Una precisazione : il primo caso è portabile tra i vari Arduino, il pin A3 esiste sia nella UNO che nella MEGA, il secondo caso non è portabile in quanto il pin 57 non esiste sulla UNO; consiglio quindi di identificare i pin con le "sigle" inserite nel core, se possibile. Tanto funziona ugualmente.
anche questa è una grande scemenza, però la fanno tutti 
int buttonPin = 2; // the number of the pushbutton pin
int ledPin = 13; // the number of the LED pin
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}
void loop(){
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
}
Non intendevo dire di non usare variabili di supporto per il codice, ci mancherebbe.
Ma che si può tranquillamente scrivere
int buttonPin = A2; // the number of the pushbutton pin
int ledPin = 13; // the number of the LED pin
void setup() {
....
invece di
int buttonPin = 16; // the number of the pushbutton pin
int ledPin = 13; // the number of the LED pin
void setup() {
Scrivendo A2, inoltre, si identifica meglio il pin sulla board di Arduino grazie alle serigrafie.
non contestavo la tua osservazione su A0 o 14, ma l'arduino reference poco aggiornanto e pieno di errori ed esempi poco pratici 
ciao
Dai dai, entriamo in modalità pignoleria 
A dirla tutta si dovrebbero inizializzare i pin come costanti dato che non cambiano e seconda cosa usare byte al posto di integer.
Questa cosa non è frequente, è un MUST
pelletta:
Dai dai, entriamo in modalità pignoleria
A dirla tutta gli utenti scaricano l'ide, provano gli esempi contenuti nella cartella e metà o non compilano o non funzionano, giustamente poi si rivolgono al forum ...sono pronto a dimostrare cio' che dico altrimenti non lo scriverei, bisognerebbe dare una sistematina anche a quelli che sono rimasti alla 0018 
Pablos, tu non parli mai a vanvera e quindi non metto in dubbio ciò che affermi, però devo testimoniare che io, partendo dalla 0022, non ho mai "beccato" uno sketch esempio che non funzionasse, è anche vero che non ne ho usati molti, ma quei pochi andavano come previsto; se invece ti riferisci espressamente alla v.0018 mi pare che forse quegli utenti potrebbero aggiornarsi almeno alla 0022/23 che sicuramente sono migliori.
pelletta:
Dai dai, entriamo in modalità pignoleria
A dirla tutta si dovrebbero inizializzare i pin come costanti dato che non cambiano e seconda cosa usare byte al posto di integer.
Per dirla tutta è un vero e proprio errore usare una variabile per definire un pin, è un byte di preziosa ram sprecato per nulla, i pin vanno definiti con le define, oltretutto il codice risulta più compatto, e veloce, perché non viene usato un indirizzamento indiretto.
#define ledPin 10
#define buttonPin 11
void setup()
{
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}
void loop() ;
Ricordatevi che il compilatore è "intelligente" e sostituisce le #define come anche i tipi const byte con valori salvati direttamente in Flash. Quindi a livello di occupazione di RAM non cambia nulla. Avevo fatto dei test ed i risultati confermavano quanto detto:
leo72:
Ricordatevi che il compilatore è "intelligente" e sostituisce le #define come anche i tipi const byte con valori salvati direttamente in Flash.
Le define non vengono salvate in flash, semplicemente viene sostituito il loro valore, non importa se numerico o un alias, durante la fase di compilazione.
Il mio appunto era relativo all'uso di una variabile, int o byte che sia senza l'uso di const, per definire un pin.
Aspe, ho scritto che i "valori" dei #define e delle const vengono salvati in flash direttamente. Se si disassembla il firmware compilato con #define oppure con const byte si vedrà che c'è il caricamento diretto del valore specificato nel registro che viene usato per eseguire l'istruzione.
Per il resto si tratta di differenze fra l'uso di un sistema di definizione di una costante (#define o const) e l'uso di una variabile "normale". In questo secondo caso si va ad occupare RAM inutilmente.
leo72:
n questo secondo caso si va ad occupare RAM inutilmente.
Non solo occupi ram inutilmente, ma pure il linguaggio macchina derivante è più complesso e più lento perché i dati devono essere recuperati da una zona della memoria invece di essere disponibili subito, ovvero più istruzioni assembly e più cicli macchina per nulla.
Ho visto alcuni sketch dove invece di
#define pinled 13
scrivevano
#define pinled (byte)13
Però non ho notato variazioni di dimensioni nel file compilato.
PaoloP:
Ho visto alcuni sketch dove invece di#define pinled 13scrivevano
#define pinled (byte)13Però non ho notato variazioni di dimensioni nel file compilato.
leo72:
Se si disassembla il firmware compilato con #define oppure con const byte si vedrà che c'è il caricamento diretto del valore specificato nel registro che viene usato per eseguire l'istruzione.
Non che non mi fidassi, ma @Leo ha ragione, il compilatore è così intelligente che la const non viene memorizzata e poi letta ma caricata direttamente nei registri come se fosse un valore numerico immediato. ( assembly: ldi r24,lo8(13) identico !!!)
Però tra const e #define c'e' una differenza piccola ma forse può influire sul codice macchina generato. Nella const siamo costretti a dichiararne il tipo mentre con la define no.
Credo che fare la define con cast come @paolop ha riportato, può aiutare il compilatore.
Certo che a voler essere pignoli anche dichiarare:
const int PINxx=13;
invece di byte è una piccola cavolata. Sembra che il compilatore usi un valore a 16 invece che a 8 bit (non ottimizza)
L'uso delle #define è una eredità del C. Nel C++ le #define ho notato che tendono ad eliminarle in favore delle costanti dichiarate con "const". Così scrive anche Stroustrup (l'autore del C++) nella sua guida.
Personalmente non ho una preferenza per l'uno o l'altro sistema, però per usare un metodo unico sto iniziando anch'io ad usare "const" per definire valori fissi. In questo modo posso specificare anche il tipo, evitando quindi dubbi al compilatore che poi potrebbe risolvere come gli pare a lui