Arduino Forum

International => Italiano => Software => Topic started by: toti94 on Jun 22, 2013, 11:24 pm

Title: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 22, 2013, 11:24 pm
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
Code: [Select]
/* 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
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: uwefed on Jun 23, 2013, 12:02 am
Non so se é questo il problema ma un numero binari si scrive cosí B00110010 e non 0b00110010.

Ciao Uwe
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 23, 2013, 12:29 am
in realtà io lo inviavo con 0b quando facevo le prove su bredboard e andava con 8 bit :\
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: gpb01 on Jun 23, 2013, 06:04 am

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 : http://gcc.gnu.org/onlinedocs/gcc/Binary-constants.html (http://gcc.gnu.org/onlinedocs/gcc/Binary-constants.html) (... documentazione gcc gnu) ;)

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

Guglielmo
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 23, 2013, 07:19 am
@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:
Code: [Select]
#define B00000100 4
La forma "C-puro" è invece proprio 0bxxxxxxxx.
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 23, 2013, 07:22 am
@Toti:

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?
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 23, 2013, 02:21 pm
Usando uno sketch che mi illumina tutti i led uno alla volta, va tutto bene
Code: [Select]
/* 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
Code: [Select]
/* 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
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 23, 2013, 05:16 pm
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.
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 23, 2013, 06:28 pm
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
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 23, 2013, 08:26 pm
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
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 23, 2013, 09:28 pm
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.
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 23, 2013, 09:57 pm
Sisi ho provato con tutti e 4 i piani e si accendono tutti i led
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 23, 2013, 10:20 pm
Il reference per quanot riguarda bitset(x, n) l'ho visto ma non è che c'ho capito molto :|
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 24, 2013, 07:48 am

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?
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 24, 2013, 07:50 am

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

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
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 24, 2013, 03:08 pm
Quote
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
Quote

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; ?
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 24, 2013, 05:21 pm
ancora problemi ç_ç
scrivendo questo codice
Code: [Select]
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 :| .... sto uscendo pazzo mi sa

lo sketch uno per uno è questo
Code: [Select]
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

}
}

Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 24, 2013, 05:56 pm

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?  :P )

Esempio:
Code: [Select]
byte miaVar = 0;
bitSet(miaVar, 5); //accendo il led in posizione 5, ossia il 6°
shiftOut(data, clock, MSBFIRST, miaVar);
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 24, 2013, 06:02 pm

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?
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 24, 2013, 06:38 pm
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 ?
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 24, 2013, 07:09 pm
Quote
è tutto scritto in quel link, lo hai letto?  smiley-razz )

Quale link?  :smiley-slim:
Quote
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

Non è che ci abbia capito molto   :smiley-sweat:
Comunque io  prima accendo il livello (che non è connesso ad uno shift register), poi abbasso il latch, passo i dati (nella funzione c'è sia il  bit di clock che quello del serial input) e poi riattivo il latch
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 24, 2013, 09:24 pm

Quote
è tutto scritto in quel link, lo hai letto?  smiley-razz )

Quale link?  :smiley-slim:

Scusa, "pagina". La pagina di spiegazione del comando bitSet.

@etemenanki:
No, va bene come fa per gli s/r in serie.
I pin di latch e di clock sono tutti connessi fra di loro, quando mandi low il latch lo fai per tutti i registri, ogni colpo di clock manda avanti di 1 posizione i registri di tutti gli shift register per cui dopo l'8° bit, il 9° passa dal primo al secondo shift automaticamente. Alla fine della sequenza, ritirando su il segnale del latch tutti gli shift presentano il registro sui loro pin.
Ovviamente questo discorso è valido se le connessioni sono fatte come si deve...  ;)
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 24, 2013, 09:35 pm
Le connessioni le ho riviste 10mila volte  =(
poi scusa perchè con la funzione "uno_per_uno()" va tutto bene e con gli altri non molto? :S
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 25, 2013, 07:13 am
Ripartiamo da capo....
1) serve lo schema elettrico. Magari hai sbagliato qualcosa e non te ne accorgi perché per te è giusto ma in realtà è sbagliato.
2) serve lo sketch completo di uno_per_uno() - non hai messo il setup ed il loop, vediamoli.
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 25, 2013, 10:02 am

...
I pin di latch e di clock sono tutti connessi fra di loro, quando mandi low il latch lo fai per tutti i registri ...


Si, ma se colleghi insieme RCK e SCK, le uscite saranno sempre una posizione spostate rispetto allo shift interno ... dal datasheet ;) http://pdf.datasheetcatalog.com/datasheets/320/387709_DS.pdf " ... If both clocks are connected together, the shift register state will always be one clock pulse ahead of the storage register. ... "

In genere la sequenza che ho postato si usa per rendere piu "fluido" il passaggio dei dati, e per evitare questo problema ... prima cancelli lo shift per essere sicuro che non rimangano vecchi dati, poi mandi le due stringhe negli shift, poi dai un singolo impulso all'RCK per passare i dati dallo shift al latch in un colpo solo, poi puoi rifare il tutto per le stringhe successive mentre il latch ti tiene i dati di prima sulle uscite ... se il latch lo passi nelle "pause" fra lo spegnimento di uno strato e l'accensione del successivo, in teoria anche l'animazione dovrebbe risultare piu fluida e regolare, senza sovrapposizione di stati ... e dato che sia la cancellazione che il latch dovrebbero richiedere solo un paio di cicli di clock, non ci dovrebbero essere pause avvertibili ...
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 25, 2013, 10:27 am
Non sapevo di questa cosa. Io ho sempre fatto come detto (latch su low, spedizione con shiftout dei byte per tutti gli shift register e poi latch su high) e non mai avuto problemi, forse perché le mie necessità erano differenti, nel senso che non avevo bisogno di animazioni ultraveloci.
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 25, 2013, 11:48 am
Si, funziona anche cosi, ma solo perche' il 595 usa dei flip-flop D come latch (mi ero confuso anch'io pensando che avessi collegato insieme i due clock) ... la procedura di cui parlavo io si usava principalmente per trasferire dati sui bus, usando normali shift register ... in quel modo, infatti, quando il latch cambia, cambia tutto in una volta, senza sovrapposizioni di bit, ed e' predicibile (sai in quale momento cambia e puoi sincronizzarci gli ingressi del bus).

Comunque per il 595 il trasferimento avviene solo sul fronte positivo dell'impulso di clock, quindi in teoria e' indifferente il riportare il latch a LOW per memorizzare i dati ... ti funziona lo stesso, perche' trasferisci tutto nel momento in cui lo mandi HIGH ... con i diversi latch piu comuni, quelli cosiddetti "trasparenti" invece, se non usi la procedura corretta, i dati in uscita cambiano man mano che i bit dello shift vengono caricati (nel senso che invece di trasferire lo shift al buffer solo sul fronte di salita, le uscite sono connesse, ad esempio, allo shift quando il latch e' a LOW e vengono latchate solo quando il pin di latch e' a HIGH, quindi se li usassi nello stesso modo avresti uno sfarfallio di tutti i led durante i cicli di shiftout ... con il 595 invece, mandare il latch a HIGH dopo aver caricato i dati, o dargli un solo impulso e riportarlo a LOW, e' la stessa cosa ... non serve neppure che lo porti a LOW mentre carichi i dati nello shift, e' sufficente l'impulso alla fine ;)
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 25, 2013, 12:41 pm
Non ho uno schema ordinato :S però ho fatto questo su fritzing giusto per farvi vedere i collegamenti tra i due s/r e le due colonne e due livelli, ho lasciato stare i collegamenti con i pin di arduino perchè poi quelli dipendono dal programma
(http://i39.tinypic.com/jt81vq.jpg)

Ma quindi come dovrei scrivere nello sketch per fare quello che dice Etemenanki .... non sono così preparato in materia per capire al 100% quello che ha detto >_<
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 25, 2013, 02:18 pm
Allora, connessioni: i due pin 10 assieme (clear degli shift) ad un'uscita che chiamerai "canc" o simile (per cancellare gli shift prima di scriverci una nuova sequenza di bit) ... i due pin 11 (SCK) assieme ed all'uscita "clock" ... i due pin 12 (RCK) assieme, ed all'uscita "latch" ... i due pin 13 assieme ed a massa ... il pin 14 del primo shift all'uscita "data", il pin 14 del secondo shift al pin 9 del primo shift ...

Io ancora non riesco a scrivere uno sketch decente, quindi posto solo le sequenze logiche, poi tu controllale ed inseriscile nel tuo sketch, anche perche' sto andando a mente e non ho nulla di pronto per testarle qui, ok ?


blocco degli azzeramenti preliminari: va eseguito solo una volta all'accensione, serve per azzerare tutto in modo da essere sicuri di partire con tutto a zero ... magari non e' indispensabile, ma male non fa :P :D

digitalWrite(npn[1], LOW); //spegne strato
digitalWrite(npn[2], LOW); //spegne strato
digitalWrite(npn[3], LOW); //spegne strato
digitalWrite(npn[4], LOW); //spegne strato
digitalWrite(canc, LOW); //cancella shift
digitalWrite(canc, HIGH); //sblocca canc
digitalWrite(latch, HIGH); //azzera latch (passandogli tutti gli 0 dello shift)
digitalWrite(latch, LOW); //blocca latch

...

inizio dei cicli, sequenza logica dei comandi:

shiftOut(data, clock, MSBFIRST, 0b10101010); //primo 74HC595
shiftOut(data, clock, MSBFIRST, 0b10101010); //secondo 74HC595
digitalWrite(latch, HIGH); //passa shift al latch
digitalWrite(latch, LOW); //azzera pilotaggio latch (le uscite non cambiano)
digitalWrite(npn[1], HIGH);//attiva strato

...

per passare i dati da uno strato all'altro:
 
digitalWrite(canc, LOW); //cancella shift
digitalWrite(canc, HIGH); //sblocca canc
shiftOut(data, clock, MSBFIRST, 0b01010101); //primo 74HC595
shiftOut(data, clock, MSBFIRST, 0b01010101); //secondo 74HC595
digitalWrite(npn[1], LOW);//spegne strato 1
digitalWrite(latch, HIGH); //passa shift al latch
digitalWrite(latch, LOW); //azzera pilotaggio latch
digitalWrite(npn[2], HIGH);//attiva strato 2
 
... e cosi via ... come ho detto, e' solo la sequenza logica, devi trasformarla tu in uno sketch ;)
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 25, 2013, 02:24 pm
ma cancellando lo shift si spegneranno i led accesi prima?
cioè se io volessi accendere prima 3 led in un piano e poi 3 su un altro, se uso canc dello shift poi i primi 3 led si spengono?
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 25, 2013, 02:43 pm
I primi 3 led si spengono quando spegni lo strato precedente per accendere quello successivo, ovviamente ... se vuoi tenere accesi led su strati differenti devi riscrivere le loro stringhe quando il multiplex ti riaccende quello strato.

Ad esempio, metti di voler tenere accesi il led 1 sulo strato 1, il led 2 sullo strato 2, il led 3 sullo strato 3 ed il led 4 sullo strato 4 ... la tua sequenza di multiplexing e':

spedisco stringa 1 allo shift -> accendo strato 1 -> azzero shift, spedisco sequenza 2 allo shift (nel frattempo il led 1 rimane acceso perche' e latchato) -> spengo strato 1 -> latch -> accendo strato 2 -> azzero, spedisco sequenza 3 allo shift -> spengo strato 2 -> latch -> accendo strato 3 -> azzero, spedisco sequenza 4 allo shift -> spengo strato 3 -> latch -> accendo strato 4 -> torno all'inizio ... e cosi via ...e' la persistenza visiva che te li fa vedere tutti accesi, in realta' il multiplex te li accende e spegne ad ogni passaggio, sempre, anche quando vuoi accendere un singolo led ...
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 25, 2013, 08:15 pm
Prima di cambiare le connessioni vorrei capire meglio XD
Quindi devo prendere i due pin 10 degli s/r e collegarli entrambi su un solo pin di arduino?
poi quindi quando invio la serie di bit devo fare:

invio prima serie
accendo il piano
azzero (settando high i due pin 10)
latch su low per memorizzare
invio seconda
accendo piano
azzero
latch


e così via?
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 25, 2013, 10:19 pm
i pin 10 ora a me sono collegati a +5V
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 26, 2013, 07:43 am
Quando su un pin vedi un segno "-" vuol dire che quel pin è attivato da un segnale basso.
Vedi che MR ha il segno sopra, per cui se lo metti su High non resetti i chip, per resettarli devi metterli su low.
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 26, 2013, 09:42 am
Allora ... i pin 10 sono il reset degli shift register interni, nel funzionamento normale vanno tenuti ad 1, e quando gli dai un'impulso a 0 cancella la parte shift register (o se preferisci, ci scrive tutti 0 ... il che potrebbe velocizzare lo sketch ogni volta che le due stringhe sono tutte a 0, ma questo e' un'altro discorso ;)) ... lo si usa per essere sicuri di partire con tutti i registri a 0, ma NON cancella le uscite perche' quelle sono memorizzate nel banco dei flip-flop, per cancellare tutte le uscite devi prima mettere tutti i registri a 0 (impulso a 0 su SCLK), poi latcharle (impulso ad 1 su RCK) ... questo lo fai una volta sola all'inizio del programma per essere sicuro di partire con tutto a 0, non e' indispensabile.

Si, se vuoi usare la funzione di cancellazione fra una stringa e l'altra, devi scollegare i due pin 10 dal positivo e collegarli ad una delle uscite di arduino (che puoi chiamare clear o in qualsiasi altro modo vuoi) ... a questa uscita che deve rimanere alta durante il funzionamento normale, mandi impulsi bassi solo quando vuoi cancellare la parte shift register, subito prima di inviare la nuova stringa di dati.

Come dice anche leo, quando sul datasheet vedi degli ingressi con il nome con sopra una riga, significa "negato", cioe' che funziona in negativo ... un'ingresso normale si abilita dandogli un 1, mentre un'ingresso negato si abilita dandogli uno 0 ... in questo caso, il reset degli shift rimane ad 1 nel funzionamento normale e resetta quando va a 0 ... lo stesso per i pin 13, G negato, che per far funzionare le uscite deve essere a 0 (se lo metti ad 1, apre le uscite in 3state)

Nella tua sequenza di multiplexing, per inviare i dati, partendo con tutto a 0 e gli strati spenti

invii i due shiftout
mandi un'impulso positivo su RCK (il che memorizza i dati dello shift nel latch, poi riporti a zero RCK)
abiliti lo strato corrispondente a quella sequenza (diciamo 1)
mandi un'impulso 0 sui pin 10 (cancelli gli shift, le uscite rimangono accese perche' sono memorizzate nel latch)
invii i due successivi shiftout
spegni lo strato 1
invii un'impulso positivo su RCK (memorizza la nuova stringa nel latch)
accendi lo strato 2

e cosi via ...


>leo: MR ? ... sui miei datasheet non c'e' nessun pin segnato MR, suppongo che intendi SCLR ? (il reset degli shift ?)



Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 26, 2013, 11:49 am
Ok ora mi è chiaro xD
Scusate l'ignoranza  :smiley-sweat:
Ora cambio i collegamenti e scrivo lo sketch e vifarò sapere xD
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 26, 2013, 12:24 pm

>leo: MR ? ... sui miei datasheet non c'e' nessun pin segnato MR, suppongo che intendi SCLR ? (il reset degli shift ?)

http://www.nxp.com/documents/data_sheet/74HC_HCT595.pdf
vedi figura fig. 5, pag. 4

e poi tabella 2, pag. 6:
MR   10   master reset (active LOW)
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: stefa24 on Jun 26, 2013, 12:55 pm
ciao
comunque entrambi sono sul pin 10

stefano
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 26, 2013, 02:27 pm
Si, ho visto ... su entrambi i datasheet che ho io i nomi sono diversi dal tuo, ma le funzioni sono le stesse, chi ha stampato quel datasheet si e' limitato a cambiare i nomi ai pin ...

SCLR diventa MR ... RCK diventa STCP ... CLK diventa SHCP ... SI diventa DS ... G diventa OE ... ecc ... alla faccia dello "standard" :P XD
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 27, 2013, 09:19 pm
Ecco qui, ho collegato i due pin 10 ad un pin di arduino.
Ma lo sketch cubo() continua a non andare bene D:
Però come al solito lo sketch uno_per_uno() funziona a dovere
lo sketch è questo:
Code: [Select]
void cubo()
{
  digitalWrite(canc, HIGH);
  digitalWrite(latch, LOW);
 
  shiftOut(data, clock, MSBFIRST, 0b00000000);
  shiftOut(data, clock, MSBFIRST, 0b10000000);
  digitalWrite(latch, HIGH);
  digitalWrite(latch, LOW);
  digitalWrite(npn[0], HIGH);
  digitalWrite(canc, LOW);
  digitalWrite(canc, HIGH);

  shiftOut(data, clock, MSBFIRST, 0b1001000);
  shiftOut(data, clock, MSBFIRST, 0b00001001);
  digitalWrite(latch, HIGH);
  digitalWrite(latch, LOW);
  digitalWrite(npn[1], HIGH);
  digitalWrite(canc, LOW);
  digitalWrite(canc, HIGH);
 
  shiftOut(data, clock, MSBFIRST, 0b1001000);
  shiftOut(data, clock, MSBFIRST, 0b00001001);
  digitalWrite(latch, HIGH);
  digitalWrite(latch, LOW);
  digitalWrite(npn[2], HIGH);
  digitalWrite(canc, LOW);
  digitalWrite(canc, HIGH);
 
  shiftOut(data, clock, MSBFIRST, 0b11111001);
  shiftOut(data, clock, MSBFIRST, 0b10011111);
  digitalWrite(latch, HIGH);
  digitalWrite(latch, LOW);
  digitalWrite(npn[3], HIGH);
 
  digitalWrite(latch, HIGH);
}


ovviamente nel loop() ho semplicemente scritto cubo();

Continuano a non accendersi i contorni del cubo led ma altri led :|
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 27, 2013, 09:29 pm
Oggi mi ero messo a giocare con un paio di 595 ed un pò di led... appena montato tutto, scrivo uno sketch velocissimo per fare accendere tutti i led... Risultato: tutti SPENTI  :smiley-yell:
Ricontrollo, ed avevo invertito i segnali dati ai pin MR e OE  ]:D
Metto tutto a posto, riprovo.... led impazziti, che si accendono a caso. Addirittura, sfilando il cavo del segnale di clock, lampeggiano tutti i led....  :smiley-sweat:
Ricontrollo tutto altre 10 volte e poi? Avevo sbagliato il programma: dichiaravo i pin 5/6/7 per latch, clock e dati mentre avevo collegato i fili sui pin 6/7/8  :smiley-yell: :smiley-yell:

Questo per dirti che anche riguardando spesso sembra tutto fatto bene ma poi l'erroruccio è dietro l'angolo. Ah, ti confesso che avevo pensato a te, non so però se più come ad uno iettatore o ad un compagno di sventura  ;)
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 27, 2013, 09:40 pm
hahahahahahahahaha spero come compagno di sventura ahahahaha XD
Ora controllo per la 100sima volta :)
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 28, 2013, 09:40 am
Prova cosi, per curiosita' (ho fatto copia incolla dal tuo, ho solo cambiato un paio di linee) ... in teoria dovrebbe (se funziona :P) accenderti i 4 led sulle colonne esterne , passandoli di strato in strato (mettici tu dei delay della durata che vuoi per rallentarlo se vuoi controllare)

Code: [Select]
void cubo()
{
 
 shiftOut(data, clock, MSBFIRST, 0b10010000);
 shiftOut(data, clock, MSBFIRST, 0b00001001);
 digitalWrite(npn[0], LOW);
 digitalWrite(npn[1], LOW);
 digitalWrite(npn[2], LOW);
 digitalWrite(npn[3], LOW);
 digitalWrite(latch, HIGH);
 digitalWrite(latch, LOW);
 digitalWrite(npn[0], HIGH);
 digitalWrite(canc, LOW);
 digitalWrite(canc, HIGH);

 shiftOut(data, clock, MSBFIRST, 0b10010000);
 shiftOut(data, clock, MSBFIRST, 0b00001001);
 digitalWrite(npn[0], LOW);
 digitalWrite(npn[1], LOW);
 digitalWrite(npn[2], LOW);
 digitalWrite(npn[3], LOW);
 digitalWrite(latch, HIGH);
 digitalWrite(latch, LOW);
 digitalWrite(npn[1], HIGH);
 digitalWrite(canc, LOW);
 digitalWrite(canc, HIGH);
 
 shiftOut(data, clock, MSBFIRST, 0b10010000);
 shiftOut(data, clock, MSBFIRST, 0b00001001);
 digitalWrite(npn[0], LOW);
 digitalWrite(npn[1], LOW);
 digitalWrite(npn[2], LOW);
 digitalWrite(npn[3], LOW);
 digitalWrite(latch, HIGH);
 digitalWrite(latch, LOW);
 digitalWrite(npn[2], HIGH);
 digitalWrite(canc, LOW);
 digitalWrite(canc, HIGH);
 
 shiftOut(data, clock, MSBFIRST, 0b10010000);
 shiftOut(data, clock, MSBFIRST, 0b00001001);
 digitalWrite(npn[0], LOW);
 digitalWrite(npn[1], LOW);
 digitalWrite(npn[2], LOW);
 digitalWrite(npn[3], LOW);
 digitalWrite(latch, HIGH);
 digitalWrite(latch, LOW);
 digitalWrite(npn[3], HIGH);
 digitalWrite(canc, LOW);
 digitalWrite(canc, HIGH);

}


Bada che anch'io sto imparando ora, quindi non mi ritengo responsabile se i miei tentativi causano risultati imprevedibili, fumo e/o fuoco, la zombificazione del vicinato, o il lancio di una testata nucleare dalla nazione vicina come rappresaglia, ok ? ;) XD

EDIT: per trasformare il blocco di 4 righe che scrive tutti 0 sulle uscite, c'e' un modo per mandare lo stesso comando contemporaneamente a tutte e 4 le uscite ? (sul reference non ho trovato nulla a proposito di questo) ... oppure bisogna per forza definire una subroutine esterna e richiamarla ogni volta ? ...
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 28, 2013, 07:48 pm
Quote
per trasformare il blocco di 4 righe che scrive tutti 0 sulle uscite, c'e' un modo per mandare lo stesso comando contemporaneamente a tutte e 4 le uscite ? (sul reference non ho trovato nulla a proposito di questo) ... oppure bisogna per forza definire una subroutine esterna e richiamarla ogni volta ? .


Non ho capito di quale blocco parli :\

Comunque il tuo sketch funziona a dovere XD mi accende le 4 colonne agli angoli.
Quindi l'errore è nei miei sketch xD

Però modificando la prima serie e l'ultima serie di bit viene tutto scombinato >_>
Inoltre volevo chiedere, in questo sketch ho usato male la funzione bitset?
Code: [Select]
void colonne(int pausa)
{
  byte address_1= B00000000;
  byte address_2= B00000000;
 
  for(i=0;i<16;i++)
  {
    if(i<8)
    bitSet(i, address_1);
    else
    bitSet(i, address_2);
   
    digitalWrite(canc, HIGH);
    digitalWrite(latch, LOW);
    shiftOut(data, clock, MSBFIRST, address_1);
    shiftOut(data, clock, MSBFIRST, address_2);
    digitalWrite(latch, HIGH);
    digitalWrite(latch, LOW);
    digitalWrite(npn[0], HIGH);
    digitalWrite(npn[1], HIGH);
    digitalWrite(npn[2], HIGH);
    digitalWrite(npn[3], HIGH);
    digitalWrite(canc, LOW);
    digitalWrite(canc, HIGH);
    delay(pausa);
  }
}
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 28, 2013, 08:50 pm

in questo sketch ho usato male la funzione bitset?

L'hai usata in modo strano...  :smiley-sweat:
bitSet accetta 2 parametri: la variabile su cui lavorare e la posizione del bit da impostare ad 1. Esempio:
Code: [Select]
bitSet(miaVar, 2);
Tu non ho capito invece come la stai usando  :*
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 28, 2013, 10:07 pm
Quote
byte address_1= B00000000;
bitSet(i, address_1);

In pratica prima dichiaro il byte, poi setto su 1 il bit corrispondente al contatore del ciclo, da 0 a 7 sulla prima serie e da 7 a 15 sulla seconda serie :\
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: leo72 on Jun 28, 2013, 10:11 pm
Allora hai invertito i parametri.
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 29, 2013, 11:39 am

Quote
per trasformare il blocco di 4 righe che scrive tutti 0 sulle uscite, c'e' un modo per mandare lo stesso comando contemporaneamente a tutte e 4 le uscite ? (sul reference non ho trovato nulla a proposito di questo) ... oppure bisogna per forza definire una subroutine esterna e richiamarla ogni volta ? .


Non ho capito di quale blocco parli :\


Mi riferivo a:

  digitalWrite(npn[0], LOW);
  digitalWrite(npn[1], LOW);
  digitalWrite(npn[2], LOW);
  digitalWrite(npn[3], LOW);

Per spegnere tutti gli strati ... mi chiedevo se fosse possibile con una digitalwrite sola passare lo stesso parametro a 4 o piu pin diversi (sul reference non ho trovato nulla a proposito di questo), o se fosse meglio creare una subroutine e richiamarla ogni volta ...
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: toti94 on Jun 29, 2013, 12:11 pm
o fai ogni volta un ciclo così:
Code: [Select]

for(i=0;i<4;i++)
{
digitalWrite(npn[i], LOW);
}

oppure questo ciclo lo inserisci in una funzione che chiami spegni_livelli() e ogni volta te la richiami, altri modi non li conosco :\
Title: Re: Programmare cubo led 4x4x4 con due 74HC595
Post by: Etemenanki on Jun 29, 2013, 12:55 pm
Si, era quello che intendevo ... una funzione esterna o un ciclo, non c'e' apparentemente modo di passare lo stesso comando a piu pin contemporaneamente con una sola digitalwrite ... grazie.