Programmare cubo led 4x4x4 con due 74HC595

Ho creato un cubo led 4x4x4, pilotato da arduino tramite due 74hc595.
Ogni colonna ha gli anodi in comune, ciascuna connessa ad un uscita del 74hc595
mentre i catodi sono comuni su i 4a livelli e ogni livello è connesso ad un transistor npn per essere attivato/diasstivato.
Lo sketch che ho scritto è questo

/* Sketch cubo LED 4x4x4 per l'esame
creato da: Salvatore Marcellini */

//Definisco le variabili 
int latch= 8; //pin del latch degli 74HC595
int clock= 12; //pin del clock degli 74HC595
int data= 11; //pin dove gli 74HC595 ricevono l'input
int npn[4]= {4, 5, 6, 7}; // array con i pin dei transistor 
int i; //contatore

// Setto tutti i  pin su OUTPUT
void setup ()
{
    pinMode(latch, OUTPUT);
    pinMode(clock, OUTPUT);
    pinMode(data, OUTPUT);
    for(i=0;i<4;i++)
    {
        pinMode(npn[i], OUTPUT);
    }
}

//inizio del programma
void loop ()
{
  for(i=0;i<4;i++)
 {
  digitalWrite(npn[i], HIGH); //attivo il livello corrispondente al contatore
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b10000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(400); //pausa

  digitalWrite(npn[i], LOW); //disattivo il livello corrispondente al contatore
 }
             
}

Dovrebbe accendermi il primo led di ogni livello, ma invece mi accende vari led e non mi accende il primo livello.
sapete dirmi qual'è l'errore?
grazie

Non so se é questo il problema ma un numero binari si scrive cosí B00110010 e non 0b00110010.

Ciao Uwe

in realtà io lo inviavo con 0b quando facevo le prove su bredboard e andava con 8 bit :\

uwefed:
Non so se é questo il problema ma un numero binari si scrive cosí B00110010 e non 0b00110010.

Mmm ... dovrebbe andare bene anche la forma 0bxxxxxxxx come puoi verificare qui : Binary constants (Using the GNU Compiler Collection (GCC)) (... documentazione gcc gnu) :wink:

Quindi, probabilmente, l'errore è altrove ...

Guglielmo

@Uwe:
La forma Bxxxxxxxx è propria di Arduino, nel core c'è il file "binary.h" che altro non è se non una lunga sfilza di #define tipo questo:

#define B00000100 4

La forma "C-puro" è invece proprio 0bxxxxxxxx.

@Toti:

toti94:
in realtà io lo inviavo con 0b quando facevo le prove su bredboard e andava con 8 bit :\

Quindi su breadboard ti funzionava ed ora che hai saldato no?
Non è che allora hai fatto qualche errore?

Usando uno sketch che mi illumina tutti i led uno alla volta, va tutto bene

/* Sketch cubo LED 4x4x4 per l'esame
creato da: Salvatore Marcellini */

//Definisco le variabili 
int latch= 8; //pin del latch degli 74HC595
int clock= 12; //pin del clock degli 74HC595
int data= 11; //pin dove gli 74HC595 ricevono l'input
int npn[4]= {5, 6, 7, 9}; // array con i pin dei transistor 
int i; //contatore
int pausa= 100;

// Setto tutti i  pin su OUTPUT
void setup ()
{
    pinMode(latch, OUTPUT);
    pinMode(clock, OUTPUT);
    pinMode(data, OUTPUT);
    for(i=0;i<4;i++)
    {
        pinMode(npn[i], OUTPUT);
    }
}

//inizio del programma
void loop ()
{
  for(i=0;i<4;i++)
 {
  digitalWrite(npn[i], HIGH); //attivo il livello corrispondente al contatore
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b10000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b01000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00100000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00010000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00001000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000100); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000010); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000001); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b10000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b01000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00100000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00010000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00001000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000100); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000010); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000001); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
      
      digitalWrite(npn[i], LOW);
 
 }
             
}

Quindi credo che i collegamenti vadano bene no?

Però se voglio accendere una colonna si e una no, come qui

/* Sketch cubo LED 4x4x4 per l'esame
creato da: Salvatore Marcellini */

//Definisco le variabili 
int latch= 8; //pin del latch degli 74HC595
int clock= 12; //pin del clock degli 74HC595
int data= 11; //pin dove gli 74HC595 ricevono l'input
int npn[4]= {5, 6, 7, 9}; // array con i pin dei transistor 
int i; //contatore
int pausa= 1000;

// Setto tutti i  pin su OUTPUT
void setup ()
{
    pinMode(latch, OUTPUT);
    pinMode(clock, OUTPUT);
    pinMode(data, OUTPUT);
    for(i=0;i<4;i++)
    {
        pinMode(npn[i], OUTPUT);
    }
}

//inizio del programma
void loop ()
{
  for(i=0;i<4;i++)
 {
  digitalWrite(npn[i], HIGH); //attivo il livello corrispondente al contatore
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b10101010); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b10101010); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
 digitalWrite(npn[i], LOW);
 }
             
}

Non mi accende una colonna si e una no, ma me le accende quasi tutte tranne 3.
Quindi direi che sono io a non aver capito come programmare in modo giusto mi sa xD

Ma come li hai collegati?
Hai considerato un intero piano come una semplice fila di 16 led, ognuno agganciato ad un pin di uno dei 2 shift register?

Perché da come descrivevi il cubo all'inizio potevi usare 1 solo shift register: 4 pin per le righe del cubo e gli altri 4 pin per le colonne. Cioè ogni piano 4x4.
Tu però pare che abbia fatto un piano come 16x1.

si le 16 uscite degli shift register sono collegate alle 16 colonne di led
quindi tenendo conto di un solo piano, ogni led è collegato ad un'uscita degli shift register

mi chiedevo inoltre se c'è un modo per accendere un singolo led senza scrivere la combinazione di bit.
Mi spiego
se ad esempio volessi accendere solo un led non c'è un modo per accendere direttamente il led 34 senza scrivere la serie di bit?
non si posso creare delle variabili? xD
sarebbe utile anche in un ciclo, dove a seconda del contatore decido se accendere o meno quel led, in questo caso la combinazione di bit deve cambiare ogni volta e non posso usare il ciclo

Scusa ma accendendo 1 piano e mandando 2 byte composti da 0b11111111 si accendono tutti i led di quel piano oppure no?
Perché se non si accendono tutti i led, c'è qualcosa di sbagliato nei collegamenti.

Per la seconda domanda, lavorare con i bit è il modo migliore per snellire il codice. Per accendere il 4° led basta fare bitSet(byte, 4). Guarda le funzioni sui bit nel Reference del sito.

Sisi ho provato con tutti e 4 i piani e si accendono tutti i led

Il reference per quanot riguarda bitset(x, n) l'ho visto ma non è che c'ho capito molto :expressionless:

toti94:
Sisi ho provato con tutti e 4 i piani e si accendono tutti i led

Beh, allora c'è qualcosa che non funziona...
Se li accendi tutti funziona, se li accendi alternati no. Ed accendendoli in sequenza 1 ad uno?

toti94:
Il reference per quanot riguarda bitset(x, n) l'ho visto ma non è che c'ho capito molto :expressionless:

Lavora su singoli bit, imposti il bit in posizione "n" del byte x.
I bit vanno di posizione da 0 a 7, da destra verso sinistra (il bit meno significativo a sta destra):
7.6.5.4.3.2.1.0

Beh, allora c'è qualcosa che non funziona...
Se li accendi tutti funziona, se li accendi alternati no. Ed accendendoli in sequenza 1 ad uno?

Sisi ho usato lo sketch che me li accende uno ad uno in sequenza (lo sketch sta su)
e funziona bene

Lavora su singoli bit, imposti il bit in posizione "n" del byte x.
I bit vanno di posizione da 0 a 7, da destra verso sinistra (il bit meno significativo a sta destra):
7.6.5.4.3.2.1.0

se quindi ad esempio voglio accendere il 6° led mi basta scrivere bitset(7, byte) e dichiaro prima la variabile byte=B0000000; ?

ancora problemi ç_ç
scrivendo questo codice

digitalWrite(npn[0], HIGH);
  digitalWrite(latch, LOW); 
  shiftOut(data, clock, MSBFIRST, 0b00000010); 
  shiftOut(data, clock, MSBFIRST, 0b00000000);
  digitalWrite(latch, HIGH);

dovrebbe accendermi il 7° led giusto?
invece mi accende con luce maggiore il 6° e con luce fioca il 7° ..... ho pensato quindi ad un problema nei collegamenti, li ho rivisti e nessun filo si tocca, inoltre ho grattato anche un po' con la punta del giravite fra i due pin in caso ci sia qualche cosa che li metta a contatto, ma niente.
Però usando lo sketch che li accende uno per uno sequenzialmente, questo problema non me lo da :expressionless: .... sto uscendo pazzo mi sa

lo sketch uno per uno è questo

void uno_per_uno()
{
  int i; //contatore
  for(i=0;i<4;i++)
 {
  digitalWrite(npn[i], HIGH); //attivo il livello corrispondente al contatore
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b10000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b01000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00100000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00010000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00001000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000100); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000010); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000001); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b10000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b01000000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00100000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00010000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00001000); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000100); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000010); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(latch, LOW); //latch basso per passare la serie di bit
  shiftOut(data, clock, MSBFIRST, 0b00000000); //prima serie di bit dello 74HC595 n°1
  shiftOut(data, clock, MSBFIRST, 0b00000001); //seconda serie di bit dello 74HC595 n°2
  digitalWrite(latch, HIGH); //riattivo il latch per attivare le uscite
  delay(pausa); //pausa
  
  digitalWrite(npn[i], LOW);//disattivo il livello
 
 }
}

toti94:
se quindi ad esempio voglio accendere il 6° led mi basta scrivere bitset(7, byte) e dichiaro prima la variabile byte=B0000000; ?

La variabile da passargli è la variabile che poi passi agli shift register.
Ed hai invertito i parametri, prima si passa la variabile e poi la posizione del led da accendere. Per accendere il 6° led si deve passare il valore 5, perché le posizioni partono da 0 (ma è tutto scritto in quel link, lo hai letto? :stuck_out_tongue: )

Esempio:

byte miaVar = 0;
bitSet(miaVar, 5); //accendo il led in posizione 5, ossia il 6°
shiftOut(data, clock, MSBFIRST, miaVar);

toti94:
invece mi accende con luce maggiore il 6° e con luce fioca il 7°

Te lo fa con un solo piano oppure su tutti e 4?

Aspetta, leggendo 595 mi viene un dubbio ... ma le sequenze di pilotaggio glie le passi correttamente ? ... perche' non e' uno shift/latch, e' uno shift/store/3state ... non ti so scrivere lo sketch, ma la sequenza piu logica per pilotare uno di quelli e' questa:

(partendo con SCK, SI e RCK bassi, G sempre basso, non usando le uscite 3state):

ciclo iniziale ...

  1. spegni tutti gli strati
  2. impulso LOW su SCLR (pulisce il registro)
  3. invio stringa su SI e clock su SCK
  4. impulso alto su RCK (passa i dati in latch, poi deve tornare basso per mantenerli)
  5. abilita strato 1

da qui in poi ...

  1. impulso LOW su SCLR (pulisce il registro, ma i dati delle uscite sono mantenuti dai latch)
  2. invio stringa su SI e clock su SCK
  3. spegni strato 1
  4. impulso alto su RCK (passa i dati in latch, poi deve tornare basso per mantenerli)
  5. abilita strato 2

torna ad 1) ... ecc ...

Tu lo piloti in questo modo ?