[Risolto] Matrice Led 7x5..Problema software? HELP

ciao a tuttii…da poko mi sto buttando (anche se è una cosa semplicissima >.<) nella comunicazione seriale di byte a Registri (74hc595)…
qualche tempo fa mio padre mi portò un tabellone dove stanno 35 gruppi di led da 10 divisi in 7 gruppi da 5 righe
ecco qua: → http://elettrofacebook.altervista.org/other/images/SAM_0161.JPG
in pratika ogni colonna di 7 gruppi è controllata da un 595 della texas instrument(datasheet: http://www.ti.com/lit/ds/symlink/tpic6595.pdf)
due domandine:
1-innanzitutto vorrei avere la conferma che il piedino RCK è il Clock pin e ke il SRCK è Latch pin
2-Gli altri registri sono messi a cascata quindi se non sbaglio quando invio un byte arriva prima all’ultimo registro?
Detto questo potete dirmi il comando più semplice per inviare un byte?

PS: per far accendere un gruppo di led devo dare il segnale negativo 0 e non positivo 1 perchè il comune di ogni gruppo è il positivo

scusate x l’enorme discorso :smiley: e graziee a chi mi aiuta

Se sono piú 595 messi inserie devi mandare 8 byte per ogni 595 che transitano attraverso tutti finche sono caricati tutti e li fai uscire sulle uscite.
Per sapere come pilotare i led di quella scheda devi indagare come sono collegati. Un 595 non ha la potenza di far illuminare 8 LEd collegato alle sue uscite. Puó dare in tutto solo 70mA.
Ci sono sicuramente altri integrati presenti sulla scheda.
Una volta che si sa come sono collegati/pilotati si puó scrivere un programma per pilotarli con arduino.

Esempio di pilotaggio di 1 o 2 74HC595: http://www.arduino.cc/en/Tutorial/ShiftOut
una libreria dedicata ai 595: Arduino Playground - HomePage

Ciao Uwe

grazie uwe finalmente una risposta...allora mi ero dimenticato di dire ke i 12 non 10 led ke formano un gruppo sono messi tutti in parallelo e cmq x alimentrli bisogna dare sul piedino primario del gruppo il negativo di alimentazione....
i 595 sono collegati direttamente ai gruppi perciò per accendere x esempio una colonna devo dare questo byte : 00000000
mentre x spegnere 11111111... il contrario insomma
il mio problema è ke anke avendo seguito quei tutorial le accensioni non andavano bene non vorrei ke avessi collegato il latch pin e clock pin al contrario

e cmq x inviare un byte insomma devo dare questa istruzione:
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, byte da inviare);
digitalWrite(latchPin, HIGH);
? ma il byte arriva prima all'ultimo registro vero?
grazie

PS: in ke senso devo mandare 8 byte? nn dovrei mandare 8 bit su un registro? non capisco se è un errore tuo o sn io ke nn ho capito la teoria :grin:
e inoltre sul pannello in realtà ci sono 2 tensioni..una è la 12 v e l'altra è la logica 5v anke se x la logica c'era uno stabilizzatore 12vTO5v ormai andato....quindi io arduino l'ho collegato così:
latch pin--> il latch pin di un registro poichè messo in parallelo con gli altri
clock pin--> il clock pin // // // // // ecc.
data pin--> serial in del primo registro (so con certezza quale sia il primo)
poi noon so come fare x l'alimentazione..cioè basta mettere in comune la massa delle alimentazioni oppure ne devo usare una per le due apparecchiatura? O_O scusa tutte le domande ma non ho mai fatto uan cosa del genere

Uwe parlava degli 8 bit di un byte, la cosa è evidente, inutile sottilizzare.
Riguardo l'alimentazione dovresti spiegare qualcosa in più:
cosa alimenti a 12V?
il regolatore a 5V è rotto, ok, quindi vuoi sapere se puoi alimentare questa sezione con l'alimentazione di Arduino, e come fare? Se la risposta è sì devi dire di cosa si tratta in termini di assorbimento, altrimenti diventa difficile capire quale modalità adottare.

menniti:
Uwe parlava degli 8 bit di un byte, la cosa è evidente, inutile sottilizzare.
Riguardo l'alimentazione dovresti spiegare qualcosa in più:
cosa alimenti a 12V?
il regolatore a 5V è rotto, ok, quindi vuoi sapere se puoi alimentare questa sezione con l'alimentazione di Arduino, e come fare? Se la risposta è sì devi dire di cosa si tratta in termini di assorbimento, altrimenti diventa difficile capire quale modalità adottare.

allora x l'alimentazione ho risolto:
12v all'ingresso 12v del tabellone
5v all'ingresso 5v del tabellone
arduino alimenteto dai 5v

io non capisco se il tabellone è rotto o no..qualcuno di voi ha già realizzato il circuito ke sta http://www.arduino.cc/en/Tutorial/ShiftOut
se si nel primo codice cosa succede? si accende un led uno alla volta?

Il principio è molto semplice, da un lato hai 3 pin di pilotaggio dall'altro hai 8 uscite.
Nella fase di caricamento dello shift tu invii una sequenza di otto 1 o 0 che caricano il 595, finito il carico si accendono tutti i led il cui pin corrisponde a valore HIGH.
Se p.es mandi la sequenza 00011001 degli 8 led si accenderanno solo quelli che corrispondono al valore 1 (HIGH)

ah ora è + chiaro
quindi se ho 5 x 595 collegati in serie dovrei inviare 5 byte 1 x ogni 595
concludendo io facendo in questo mdo accenderò 8led:

//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

void setup() {
//set pins to output so you can control the shift register
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);

digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, 11111111);
digitalWrite(latchPin, HIGH);
}

void loop() {}

è giusto?

Con questo sketch, ad occhio, in 5 loop accenderai tutti i 40 led

Lo sketch non va bene per una serie di motivi:

  1. stai pilotando 1 solo 595 dato che hai spedito solo 1 byte
  2. hai messo la funzione shiftOut nel setup, per cui verrà eseguita solo 1 volta quando si avvia l’Arduino
  3. 11111111 non è un numero in formato binario ma un intero lungo. Un numero in formato binario è preceduto da 0b quindi 0b11111111

Quindi devi fare una cosa del genere:

....
byte matriceLed[5]; 

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  for (byte i=0; i<5; i++) {
    matriceLed[i]=0; //azzeri le singole celle
  }
  //setup iniziale: led tutti spenti
  inviaStatoLed();
}

void loop() {
  .......tuo codice....
  //esempio
  matriceLed[2]=0b10101010; //modifichi i led gestiti dal 3° 595
  inviaStatoLed();
  ...ecc....
}

void inviaStatoLed() {
  digitalWrite(latchPin, LOW);
  for (byte i=0; i<5; i++) {
    shiftOut(dataPin, clockPin, MSBFIRST, matriceLed[i]);  
  }
  digitalWrite(latchPin, HIGH);
}

Ti crei una matrice di 5 byte e lì metti lo stato dei led. Poi ogni volta che devi variare l’accensione dei led, modifichi

grazie leo ora provo subito e faccio sapere

Correggi la funzione inviaStatoLed mettendo nel ciclo for il controllo i<5 e nel setup altrimenti spedisce solo i primi 4 byte, ho sbagliato.

ragazzi sono proprio un kretino.....:facepalm: alla fine avevo ragione..il PROBLEMA era ke avevo scambiato il latchpin con il clock pin e viceversa...ora funziona bemsissimo devo solo farmi un buono sketch
cmq @leo lo sketch ke mi hai postato funziona benissimo a parte l'asterisco dopo il byte (" byte* matriceLed") ke mi dava un errore nella compilazione
penso ike il topic lo posso dare per risolto grazie a tutti della pazizenza ;D

Ops... svista mia. Ero partito con lo scrivere una cosa e poi ne ho scritta un'altra. Non l'avevo provato, sorry :*

leo72:
Ops... svista mia. Ero partito con lo scrivere una cosa e poi ne ho scritta un'altra. Non l'avevo provato, sorry :*

tranquillo tutti possono sbagliare soprattutto tu ke scrivi sketch x tantissime persone :wink: grazie davvero
cmq in conclusione il pannello funziona alla grande ora non mi resta ke scrivere lo sketch per una scritta scorrevoole ]:smiley:

igor99480:
cmq in conclusione il pannello funziona alla grande ora non mi resta ke scrivere lo sketch per una scritta scorrevoole ]:smiley:

Se provenivi dal mondo dei computer ad 8 bit degli anni '80 non avresti neanche posto la domanda XD
Lo scorrimento delle scritte era fatto semplicemente prendendo il 1° carattere a SX, scorrendo la stringa di un carattere a SX e mettendo il carattere in fondo :wink:

PIPPO VA AL MARE
PIPPO VA AL MARE**
IPPO VA AL MAREP
PPO VA AL MARE
PI
ecc...
:wink:

:smiley: grazie mille
tanto la scritta ke devo fare non è molto lunga il problema è fare 5 matrici xD penso proprio di farmi un programmino in vb ke mi da automaticamente la matrice in base ai led ke "accendo" sul form

x ki legge

grazie a ki mi ha aiutato on qst problema e grazie anke al forum
ecco il video del mio progetto: DJ IGOR text scrolling - YouTube
x voi sembrerà una cavolata quello ke ho ftto ma x me no xk io ci lavoro a quella matrice da due anni e solo dopo aver acquistato Arduino sn riuscito a portarlo a termine grazie davvero a tutti ;D

A me non sembra tanto una cavolata, io devo ancora iniziare a "spippolare" con le mie matrici di led arrivate 1 mese fa :sweat_smile:

leo72:
A me non sembra tanto una cavolata, io devo ancora iniziare a “spippolare” con le mie matrici di led arrivate 1 mese fa :sweat_smile:

vabbè questa matrice non è quella classca xk ci sono meno led da controllare(in poch parole solo 35 led)…ieriin 30 min ho scritto tutto lo sketch…ora lo post e se qualcuno ha dei suggerimenti ne sarei grato :wink:

byte matriceLed[5]; 

int latchPin = 8;
int clockPin = 12;
int dataPin = 11;
int textSpeed;
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(A5,INPUT);
  for (byte i=0; i<5; i++) {
    matriceLed[i]=0; //azzeri le singole celle
  }
  //setup iniziale: led tutti spenti
  inviaStatoLed();
  textSpeed=analogRead(A5);
}



void loop() {
matriceLed[4]=0b1100001;
matriceLed[3]=0b1010001;
matriceLed[2]=0b1010001;
matriceLed[1]=0b1010101;
matriceLed[0]=0b1100111;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1000010;
matriceLed[3]=0b0100010;
matriceLed[2]=0b0100010;
matriceLed[1]=0b0101010;
matriceLed[0]=0b1001110;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0000101;
matriceLed[3]=0b1000101;
matriceLed[2]=0b1000101;
matriceLed[1]=0b1010101;
matriceLed[0]=0b0011101;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0001010;
matriceLed[3]=0b0001010;
matriceLed[2]=0b0001010;
matriceLed[1]=0b0101010;
matriceLed[0]=0b0111010;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0010101;
matriceLed[3]=0b0010101;
matriceLed[2]=0b0010101;
matriceLed[1]=0b1010101;
matriceLed[0]=0b1110101;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0101011;
matriceLed[3]=0b0101010;
matriceLed[2]=0b0101010;
matriceLed[1]=0b0101010;
matriceLed[0]=0b1101011;
inviaStatoLed();delay(textSpeed);

//---------------------------

matriceLed[4]=0b1010111;
matriceLed[3]=0b1010101;
matriceLed[2]=0b1010100;
matriceLed[1]=0b1010101;
matriceLed[0]=0b1010111;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0101110;
matriceLed[3]=0b0101010;
matriceLed[2]=0b0101000;
matriceLed[1]=0b0101011;
matriceLed[0]=0b0101110;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1011100;
matriceLed[3]=0b1010100;
matriceLed[2]=0b1010000;
matriceLed[1]=0b1010110;
matriceLed[0]=0b1011100;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0111001;
matriceLed[3]=0b0101001;
matriceLed[2]=0b0100001;
matriceLed[1]=0b0101101;
matriceLed[0]=0b0111001;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1110011;
matriceLed[3]=0b1010010;
matriceLed[2]=0b1000010;
matriceLed[1]=0b1011010;
matriceLed[0]=0b1110011;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1100111;
matriceLed[3]=0b0100101;
matriceLed[2]=0b0000101;
matriceLed[1]=0b0110101;
matriceLed[0]=0b1100111;
inviaStatoLed();delay(textSpeed);

//---------------------------

matriceLed[4]=0b1001110;
matriceLed[3]=0b1001010;
matriceLed[2]=0b0001010;
matriceLed[1]=0b1101010;
matriceLed[0]=0b1001110;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0011101;
matriceLed[3]=0b0010101;
matriceLed[2]=0b0010101;
matriceLed[1]=0b1010101;
matriceLed[0]=0b0011101;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0111011;
matriceLed[3]=0b0101010;
matriceLed[2]=0b0101011;
matriceLed[1]=0b0101011;
matriceLed[0]=0b0111010;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1110111;
matriceLed[3]=0b1010101;
matriceLed[2]=0b1010111;
matriceLed[1]=0b1010110;
matriceLed[0]=0b1110101;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1101110;
matriceLed[3]=0b0101010;
matriceLed[2]=0b0101110;
matriceLed[1]=0b0101100;
matriceLed[0]=0b1101010;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1011101;
matriceLed[3]=0b1010101;
matriceLed[2]=0b1011101;
matriceLed[1]=0b1011001;
matriceLed[0]=0b1010101;
inviaStatoLed();delay(textSpeed);
//-------------------------------------

matriceLed[4]=0b0111011;
matriceLed[3]=0b0101010;
matriceLed[2]=0b0111010;
matriceLed[1]=0b0110010;
matriceLed[0]=0b0101011;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1110110;
matriceLed[3]=0b1010101;
matriceLed[2]=0b1110101;
matriceLed[1]=0b1100101;
matriceLed[0]=0b1010110;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1101100;
matriceLed[3]=0b0101010;
matriceLed[2]=0b1101010;
matriceLed[1]=0b1001010;
matriceLed[0]=0b0101100;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b1011000;
matriceLed[3]=0b1010100;
matriceLed[2]=0b1010100;
matriceLed[1]=0b0010101;
matriceLed[0]=0b1011001;
inviaStatoLed();delay(textSpeed);

matriceLed[4]=0b0110000;
matriceLed[3]=0b0101000;
matriceLed[2]=0b0101000;
matriceLed[1]=0b0101010;
matriceLed[0]=0b0110011;
inviaStatoLed();delay(textSpeed);
}

void inviaStatoLed() {
  textSpeed=analogRead(A5);
  digitalWrite(latchPin, LOW);
  for (byte i=0; i<5; i++) {
    shiftOut(dataPin, clockPin, MSBFIRST, matriceLed[i]);  
  }
  digitalWrite(latchPin, HIGH);
}