Matrice con 19 display 5x7 principio di funzionamento

[pablos71]

Buonasera a tutti.

Sono qui a chiedere delucidazioni sul funzionamento hardware di un display composto da 19 elementi led 5x7 a scritte scorrevoli. Non vi è più possibilità di recuperare la tastiera IR per programmarlo, sarebbe possibile via RS232 TTL, ma io vorrei rimodernarla attingendo dati da sensori locali, da internet tipo meteo, borsa, notizie varie con l'utilizzo di una ethernet shield, ma questo non assolutamente un problema.
Il problema salta fuori quando viene distaccata dal suo microcomputer e analizzando i collegamenti non tutto mi è chiaro, chiedo una spiegazione a voi esperti di elettronica sul principio di funzionamento.

Per ciascun display 5x7 cè un

• MC14094BCP (8-StageShift/StoreRegister withThree-StateOutputs)
  e un
• ULN2003A - Array di 7 Transistor Darlington che controllano in tutto le 95 colonne

Ci sono in tutto 12 fili che vanno al display

• sensore IR TSOP (che non mi interessa piu)
• +5 v riga 1 (95 leds)
• +5 v riga 2 (95 leds)
• +5 v riga 3 (95 leds)
• +5 v riga 4 (95 leds)
• +5 v riga 5 (95 leds)
• +5 v riga 6 (95 leds)
• +5 v riga 7 (95 leds)
• un filo che unisce delle piste sotto i display e non riesco a vederlo
• DATA (il seriale dei shift register)
• STROBE connesso anche ai +Vdd dei MC14094BCP
  -GND

Con la sigla della matrice led LJ2041 non ho trovato nulla se non altre LJ20**, perciò ripercorrendo le piste e alcune semplici prove ne ho capito le polarizzazioni e i collegamenti.
Ho già visto un pò di link e sono tutti ad una matrice singola dove linee e colonne vengono collegate direttamente ai pin del 328

Ora la domanda è ... come faccio a far scorrere un singolo led?

C'è solo un 7805 che alimenta tutto il display ed è troppo piccolo per accendere 475 led, quindi cosa succede? ogni riga viene alimentata in modo impulsivo che incrociandosi con la colonna ad una certa frequenza inganna l'occhio?

Avete idea di come collegare arduino a questo display?
Che cosa mi conviene usare per pilotare a +5V le 7 righe da 95 led?

Grazie a tutti, ciao

[pablos71]

3 foto per rendere l'idea
Ho dovuto metterla a terra perchè troppo lunga

[pablos71]

Nessuna idea? nemmeno per

Che cosa mi conviene usare per pilotare a +5V le 7 righe da 95 led?

[Pelletta]

Secondo me potresti usare direttamente un alimentatore da 5V per tutto il circuito tanto il MC14094 lavora con logica TTL. Così ti sbarazzi pure del regolatore di tensione.
Per una cosa simile per dimensionare l'alimentatore ho usato il ramo 5V di un atx e poi ho misurato l'assorbimento del circuito.
Attendi anche cosa dicono gli esperti

[pablos71]

Ciao Pelletta
ho già collegato tutto a 5v 450W, ma le linee devono lavorare mi sa a 50Hz quindi vanno separate e pilotate dal miocro.
Quello che mi lascia perplesso nelle connessioni è che arduino fa da clock perfettamente con un pin a 20ms di blink i led scorrono tutti insieme per ora (tutte le righe sono uguali), ma se collego il filo data a un pin output (che fanno da high/low) non ho nessuna variazione del buffer, se prendo lo stesso filo e lo metto su +5 e gnd dell'alimentatore in modo manuale, il serial data viene accettato, sono bit casuali, però li legge :o .
Altra cosa strana lo scorrimento con la sua scheda originale avviene da destra verso sinistra, con i collegamenti manuali i led mi scorrono da sinistra verso destra .. mha!!!
E' veramente un casino, pensavo fosse più "elementare watson"

[Pelletta]

Hai provato a mettere una resistenza di pulldown sul pin di arduino che trasmette i dati?

[pablos71]

Si pelletta, le ho messe dappertutto, ho fatto un reverse engineering e ho visto che le linee sono controllate in questo modo con un 74LS145 che pilota 2 finali di potenza STA402A (4 PNP Darlington ciscuno) le linee ABCD del 145 entrano nel microcontrollore 8049, ora devo capire come funziona il bus seriale e come si gestiscono le colonne, poi costruire tutti char, le direzioni, velocità, ecc ecc

Non uso display a 7 seg, ma il principio è lo stesso

Per ora devo risolvere i problemi hardware.
Devo solo trovare il componente che mi regga 95 led tutti accesi e che sia veloce a commutare, circa 2A per linea, se mi date un suggerimento, vi sarei grato.

[icio]

Dalle foto vedo che i fili sono 14 non 12 pablo, dall'elenco manca il segnale CK dei 13 4094 messi in serie per un totale di 104 bits , usati solo95, ma forse sono solo 12 pezzi , non vedo bene , i l203 sono 14 cioè 98 bit usati solo 95

Il funzionamento è: ogni 10 o 20 msec viene inviata una stringa di 95 bit ai 4094 ad una frequenza minima di 10khz di cui uno solo dei 95bit=high , questo accenderà la colonna puntata di 7 leds , subito dopo il MC attiva i 7 leds mediante i 2 STR402A con delle resistenze in serie presumo da circa 10 ohm per una corrente impulsiva di 200mA, essendo accesi per 1/95 del periodo si illuminano come se ci scorresse 2-5mA, il consumo totale con tutti i 665 led accesi è di 200x7=1400mA

[pablos71]

Grazie Icio

In realtà i fili utili sono 11 perche 3 sono GND e l'arancio in alto fa il ricevitore IR, ma dalla foto non si vedeva. (allego dettaglio se interessa)
Appena la riparo riprendo i test, purtroppo nel tentativo di trovare un transistor adatto a pilotare una linea ho mandato un GND nel posto sbagliato e ho guastato il primo 4094 del bus seriale.
Me ne sono accorto bypassando il bus data al secondo integrato, le scritte tornano a scorrere ma il primo display accende led a caso
In tutto sono 13 pezzi 4094 e 14 ULN2003A

Ho visto che gli STA402 per avere 2 pezzi mi costa 40 euro in tutto, altri TR di potenza da 2A circa 20-25 euro

Ho chiesto qui sul forum per ben 3 volte un consiglio sul TR da usare, ma non ho ottenuto considerazione ... vabbè nessun problema in quache modo mi arrangio, forse nessuno lo sa .

Gli MC14094BCP 8-StageShift register sono alimentati a 5v e anche questi sono piuttosto cari e devo prenderne uno stock per averne 1, se lo sostituisco con un CD4094 che a pin sembra compatibile va bene lo stesso no? se fossero alimentati a 9-12v e ci fossero tempi di risposta elevati sarebbe un problema .... che dite?

datasheet MC14094BCP

mc14094b-d.pdf

datasheet CD4094B

cd4094b.pdf

datasheet 74HC4094; 74HCT4094
http://www.nxp.com/documents/data_sheet/74HC_HCT4094.pdf

ciao

[Pelletta]

Il datasheet dice: Pin–for–Pin Compatible with CD4094B
Per i transistor passo

[pablos71]

Mmm bene, dove hai letto sul datasheet la compatibilità?
ciao

[Pelletta]

Pagina 1, appena sotto la descrizione sotto la voce Feature

[pablos71]

hai ragione ... devo comprarmi uno smartphone a 32'' ... grazie per la segnalazione

[icio]

dovrebbe essere:

verde = pin2 4094 data
arancio =pin1 4094 strobe (ma che si può anche collegare ai 5V per escluderlo)
giallo =pin3 4094 ck

l'altro arancio alla fine del connettore potrebbe essere i 5V di alimentazione?

per sostituire i 2 STR402A puoi usare i 7 BDX54A-C

sulla scheda bastavano 12 4094 anzichè 13 (12x8=96bit), non capisco perche ne hanno usato 13.....

[pablos71]

Ho riparato il display con la sostituzione del chip danneggiato con successo, aiutandomi con alcuni tutorial sugli shiftregister ho ottimizzato il programma, tutto sommato si ha un discreto risultato, le scritte scorrono in modo regolare ma:

• i led hanno il 60% della loro luminosità massima, per aumentarla è necessario diminuire il clock, ma poi si ha l'effetto negativo di notare lo sfarfallio fastidioso.
• non è possibile aumentare la velocità perchè il 2560 è già spremuto al massimo (troppe operazioni annidate e troppi dati seriali da inviare + linee da sincronizzare) ... 19 display 5x7 sono tantini.
  tenterò con la DUE, forse aumentando la velocità dei dati seriali e diminuendo la velocità dei refresh linee riesco ad aumentare la luminosità, sempre che quei chip accettino una velocità elevata seriale.

Lo strobe che nel mio caso connette fisicamente insieme i pin del 4094 (+VCC 5v), (Strobe), (Output Enable) l'ho collegato a +5v dell'alimentatore, se messo a GND spegne tutto il display, ma a questo punto bastano degli 0 nel DATA per spegnerlo.
Le uniche connessioni utili sono:

• 7 pin delle linee gestite con 7 TIP122 5A
• 1 pin CLOCK e 1 pin DATA gestiti egregiamente dall'istruzione "shiftOut", si può ottimizzare la trasmissione dello shiftOut riducendo il dalay tra un bit e l'altro (minimo 1 us)

comunque questo è il progr. se interessa a qualcuno

byte riga1Pin = 30;
byte riga2Pin = 31;
byte riga3Pin = 32;
byte riga4Pin = 33;
byte riga5Pin = 34;
byte riga6Pin = 35;
byte riga7Pin = 36;
byte clockPin = 2;
byte dataPin = 3;

void setup() {
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(riga1Pin, OUTPUT);
  pinMode(riga2Pin, OUTPUT);
  pinMode(riga3Pin, OUTPUT);
  pinMode(riga4Pin, OUTPUT);
  pinMode(riga5Pin, OUTPUT);
  pinMode(riga6Pin, OUTPUT);
  pinMode(riga7Pin, OUTPUT);
}

byte bitmap[8][12]; 
byte numZones = sizeof(bitmap) / 8; 
byte maxZoneIndex = numZones-1;
byte numCols = numZones * 8;

byte alphabets[][5] = {
{0x00,0x00,0x00,0x00,0x00}, //   0x20 32
{0x00,0x00,0x6f,0x00,0x00}, // ! 0x21 33
{0x00,0x07,0x00,0x07,0x00}, // " 0x22 34
{0x14,0x7f,0x14,0x7f,0x14}, // # 0x23 35
{0x00,0x07,0x04,0x1e,0x00}, // $ 0x24 36
{0x23,0x13,0x08,0x64,0x62}, // % 0x25 37
{0x36,0x49,0x56,0x20,0x50}, // & 0x26 38
{0x00,0x00,0x07,0x00,0x00}, // ' 0x27 39
{0x00,0x1c,0x22,0x41,0x00}, // ( 0x28 40
{0x00,0x41,0x22,0x1c,0x00}, // ) 0x29 41
{0x14,0x08,0x3e,0x08,0x14}, // * 0x2a 42
{0x08,0x08,0x3e,0x08,0x08}, // + 0x2b 43
{0x00,0x50,0x30,0x00,0x00}, // , 0x2c 44
{0x08,0x08,0x08,0x08,0x08}, // - 0x2d 45
{0x00,0x60,0x60,0x00,0x00}, // . 0x2e 46
{0x20,0x10,0x08,0x04,0x02}, // / 0x2f 47
{0x3e,0x51,0x49,0x45,0x3e}, // 0 0x30 48
{0x00,0x42,0x7f,0x40,0x00}, // 1 0x31 49
{0x42,0x61,0x51,0x49,0x46}, // 2 0x32 50
{0x21,0x41,0x45,0x4b,0x31}, // 3 0x33 51
{0x18,0x14,0x12,0x7f,0x10}, // 4 0x34 52
{0x27,0x45,0x45,0x45,0x39}, // 5 0x35 53
{0x3c,0x4a,0x49,0x49,0x30}, // 6 0x36 54
{0x01,0x71,0x09,0x05,0x03}, // 7 0x37 55
{0x36,0x49,0x49,0x49,0x36}, // 8 0x38 56
{0x06,0x49,0x49,0x29,0x1e}, // 9 0x39 57
{0x00,0x36,0x36,0x00,0x00}, // : 0x3a 58
{0x00,0x56,0x36,0x00,0x00}, // ; 0x3b 59
{0x08,0x14,0x22,0x41,0x00}, // < 0x3c 60 
{0x14,0x14,0x14,0x14,0x14}, // = 0x3d 61 
{0x00,0x41,0x22,0x14,0x08}, // > 0x3e 62
{0x02,0x01,0x51,0x09,0x06}, // ? 0x3f 63
{0x3e,0x41,0x5d,0x49,0x4e}, // @ 0x40 64
{0x7e,0x09,0x09,0x09,0x7e}, // A 0x41 65
{0x7f,0x49,0x49,0x49,0x36}, // B 0x42 66
{0x3e,0x41,0x41,0x41,0x22}, // C 0x43 67
{0x7f,0x41,0x41,0x41,0x3e}, // D 0x44 68
{0x7f,0x49,0x49,0x49,0x41}, // E 0x45 69
{0x7f,0x09,0x09,0x09,0x01}, // F 0x46 70
{0x3e,0x41,0x49,0x49,0x7a}, // G 0x47 71
{0x7f,0x08,0x08,0x08,0x7f}, // H 0x48 72
{0x00,0x41,0x7f,0x41,0x00}, // I 0x49 73
{0x20,0x40,0x41,0x3f,0x01}, // J 0x4a 74
{0x7f,0x08,0x14,0x22,0x41}, // K 0x4b 75
{0x7f,0x40,0x40,0x40,0x40}, // L 0x4c 76
{0x7f,0x02,0x0c,0x02,0x7f}, // M 0x4d 77
{0x7f,0x04,0x08,0x10,0x7f}, // N 0x4e 78
{0x3e,0x41,0x41,0x41,0x3e}, // O 0x4f 79
{0x7f,0x09,0x09,0x09,0x06}, // P 0x50 80
{0x3e,0x41,0x51,0x21,0x5e}, // Q 0x51 81
{0x7f,0x09,0x19,0x29,0x46}, // R 0x52 82
{0x46,0x49,0x49,0x49,0x31}, // S 0x53 83
{0x01,0x01,0x7f,0x01,0x01}, // T 0x54 84
{0x3f,0x40,0x40,0x40,0x3f}, // U 0x55 85
{0x0f,0x30,0x40,0x30,0x0f}, // V 0x56 86
{0x3f,0x40,0x30,0x40,0x3f}, // W 0x57 87
{0x63,0x14,0x08,0x14,0x63}, // X 0x58 88
{0x07,0x08,0x70,0x08,0x07}, // Y 0x59 89
{0x61,0x51,0x49,0x45,0x43}, // Z 0x5a 90
{0x3c,0x4a,0x49,0x29,0x1e}, // [ 0x5b 91
{0x02,0x04,0x08,0x10,0x20}, // \ 0x5c 92
{0x00,0x41,0x7f,0x00,0x00}, // ] 0x5d 93
{0x04,0x02,0x01,0x02,0x04}, // ^ 0x5e 94
{0x40,0x40,0x40,0x40,0x40}, // _ 0x5f 95
{0x00,0x00,0x03,0x04,0x00}, // ` 0x60 96
{0x20,0x54,0x54,0x54,0x78}, // a 0x61 97
{0x7f,0x48,0x44,0x44,0x38}, // b 0x62 98
{0x38,0x44,0x44,0x44,0x20}, // c 0x63 99
{0x38,0x44,0x44,0x48,0x7f}, // d 0x64 100
{0x38,0x54,0x54,0x54,0x18}, // e 0x65 101
{0x08,0x7e,0x09,0x01,0x02}, // f 0x66 102
{0x0c,0x52,0x52,0x52,0x3e}, // g 0x67 103
{0x7f,0x08,0x04,0x04,0x78}, // h 0x68 104
{0x00,0x44,0x7d,0x40,0x00}, // i 0x69 105
{0x20,0x40,0x44,0x3d,0x00}, // j 0x6a 106
{0x00,0x7f,0x10,0x28,0x44}, // k 0x6b 107
{0x00,0x41,0x7f,0x40,0x00}, // l 0x6c 108
{0x7c,0x04,0x18,0x04,0x78}, // m 0x6d 109
{0x7c,0x08,0x04,0x04,0x78}, // n 0x6e 110
{0x38,0x44,0x44,0x44,0x38}, // o 0x6f 111
{0x7c,0x14,0x14,0x14,0x08}, // p 0x70 112
{0x08,0x14,0x14,0x18,0x7c}, // q 0x71 113
{0x7c,0x08,0x04,0x04,0x08}, // r 0x72 114
{0x48,0x54,0x54,0x54,0x20}, // s 0x73 115
{0x04,0x3f,0x44,0x40,0x20}, // t 0x74 116
{0x3c,0x40,0x40,0x20,0x7c}, // u 0x75 117
{0x1c,0x20,0x40,0x20,0x1c}, // v 0x76 118
{0x3c,0x40,0x30,0x40,0x3c}, // w 0x77 119
{0x44,0x28,0x10,0x28,0x44}, // x 0x78 120
{0x0c,0x50,0x50,0x50,0x3c}, // y 0x79 121
{0x44,0x64,0x54,0x4c,0x44}, // z 0x7a 122
{0x00,0x08,0x36,0x41,0x41}, // { 0x7b 123
{0x00,0x00,0x7f,0x00,0x00}, // | 0x7c 124
{0x41,0x41,0x36,0x08,0x00}, // } 0x7d 125
{0x04,0x02,0x04,0x08,0x04}, // ~ 0x7e 126
};

void RefreshDisplay(){
  for (byte riga = 0; riga < 8; riga++) {     
       PORTC=0;//per la mega2560
    
    for (int zone = maxZoneIndex; zone >= 0; zone--) {
      shiftOut(dataPin, clockPin, MSBFIRST, bitmap[riga][zone]) ;     
    }
      
    digitalWrite (29+riga, 1);    
    delay(1);
  }
}

void Plot(byte col, byte riga, bool isOn){
  byte zone = col / 8;
  byte colBitIndex = col % 8;
  byte colBit = 1 << colBitIndex;
  if (isOn)
    bitmap[riga][zone] =  bitmap[riga][zone] | colBit;
  else
    bitmap[riga][zone] =  bitmap[riga][zone] & (~colBit);
}

void AlphabetSoup(){
  char msg[] = "Arduino Test * ";
  for (byte charIndex=0; charIndex < (sizeof(msg)-1); charIndex++){
   
    byte alphabetIndex = msg[charIndex] - ' ';
    if (alphabetIndex < 0) alphabetIndex=0;
     
    for (byte col = 0; col < 6; col++){
      for (byte riga = 0; riga < 8; riga++){
      
        bool isOn = 0;
        if (col<5) isOn = bitRead( alphabets[alphabetIndex][col], 7-riga ) == 1;
        Plot( numCols-1, riga, isOn); 
      }
      
        RefreshDisplay();

      for (byte riga=0; riga<8; riga++){        
        for (byte zone=0; zone < numZones; zone++){      
          bitmap[riga][zone] = bitmap[riga][zone] >> 1;             
          if (zone < maxZoneIndex) bitWrite(bitmap[riga][zone], 7, bitRead(bitmap[riga][zone+1],0));
        }
      }
    }
  }
} 

void loop() { 
  AlphabetSoup(); 
}

Mi avrebbe fatto piacere aggiungere tanti effetti, ma col 2560 siamo troppo stretti e non so se vale la pena fare un pure c/c++
saluti

[icio]

Mi era sfuggito che il filo arancio in alto era il ricevitore IR, lo avevi anche scritto!! Bene , ci sei riuscito, comunque al posto del TIP122 che è un NPN dovresti usare TIP125 126 o 127 che sono PNP come gli STR402 originali o il BDX che ti ho consigliato, probabilmente avresti più luminosità

[vbextreme]

@pablos, aumentare la frequenza di refresh non aumenta la luminosità.
il tempo massimo di accensione è sempre 1/96, circa 0.01s
quindi già una frequenza di 50hz è già buona, 100hz è ottima.
La configurazione a matrice ha quella pecca,

• LED = -LUMINOSITÀ
  non ho ben capito tutto lo schema, ma hai modo di accendere più led in contemporaneamente?
  Anche su colonne o righe separate.

[pablos71]

@icio, si avevo letto il tuo suggerimento, ma è quello che sabato pomeriggio ho trovato a 80 cent cadauno in negozio :), magari posso provare con altri.

@vbextreme

hai modo di accendere più led in contemporaneamente?

si, con incroci di linee e colonne faccio quello che voglio, ma il programma impiega troppo tempo a fare il refresh delle 7 righe e in più a elaborare i dati delle linee, per quello dicevo ....
Mi spiego meglio:
Prendiamo arduino e facciamogli solo accendere le 7 righe con 10/20ms di ciclo ... ecco che ho una buona luminosità. ma se in mezzo ci piazzo anche un programma che deve fare le colonne perdo tempo e quindi luce
ecco +/- è così

ciao

[pablos71]

E se porto la tensione dei collettori a 7v? faccio una cacata? tanto 7v non gli arriverranno mai, nemmeno 5v
mmmm no, se arresto la scritta al centro mi vanno a fuoco ahahahha

mi sa che hai ragione ... La configurazione a matrice ha quella pecca!!
Dei transistors superapidi a commutare potrebbero fare la differenza?
Condensatori che rallentano lo spegnimento sulle linee?
Se dico fregnacce ditelo pure, non mi offendo
Quando vedo quelle scritte delle farmacie che ti acciecano anche di giorno, eh mi girano perchè io non posso

[icio]

Anche se porti i collettori dei TIP122 a 7V o 12V la luminosità non cambia ma i TIP122 scalderanno di più, se invece li sostituisci con dei PNP meglio se normali, no darlington, e pilotati in base da un NPN come nel disegno puoi alimentarli da 5V a 12V, la resistenza da 33 ohm è dimensionata per 12V