next topic »

[on:]

Salve ragazzi, metto un paio di domande prima però spiego brevemente cosa devo fare.
In sostanza devo accendere dei led in sequenza (una trentina, ancora non so il numero esatto); ho scartato la via sempliciotta del classico NE555 con CD4017 perchè i led devono rimanere accesi.
Premettendo che il circuito deve essere il più semplice possibile ho pensato subito al MAX7219, la scelta è caduta su questo integrato per molti motivi:
- ce l'ho sia DIP che SMD;
- consuma meno perchè fa il multiplexing;
- bastano solo 3 pin, una resistenza e un paio di condensatori per controllare i led;
- non so ancora il numero di led esatto e questo IC mi permette di collegarne fino a 64.
Dopo aver deciso di usare questo integrato ho provato a vedere su quale micro poterlo utilizzare.
Anche qui solito discorso: non ho spazio!
Scarto a priori gli atmega**8 per ingombro e pin che rimarrebbero inutilizzati, mi rimangono gli attiny.
Al momento ho solo gli attiny2313 e gli attiny13a.
Ho provato a compilare un esempio per l'attiny2313, ci sto dentro con la memoria quindi sparo la prima domanda: la libreria ledControl è compatibile con gli attiny2313? So che i MAX7219 si comandano tramite SPI e gli attiny ce l'hanno.
Passiamo all'attiny13: non riesco a compilare lo sketch di esempio, esce un errore dovuto alla mancanza di qualcosa (penso sia qualcosa di banale) nel core.
Non gli piacciono variabili di questo tipo:
‘B01111110’
proprio non le riconosce e non compila.
Mi sarebbe piaciuto almeno a vedere se ci stavo dentro con la memoria perchè l'attiny13a ha soltanto 6 pin utilizzabili e ho anche la versione smd... una manna visto che ho davvero pochissimo spazio.
Altre alternative per accendere questi led sono sempre ben accette...
Grazie a tutti per la lettura, se serve qualche altra informazione non c'e problema.

[Reply #1 on:]

Piccolo aggiornamento del topic: riesco a far funzionare il Max7219 sull'ATtiny13A.
Non posso usare la libreria ledControl perchè  non entra nel micro però ho trovato un altro metodo nel playground.
Ho collegato al max7219 una matrice di 64 led e ho dimensionato la resistenza da mettere sul pin 18(RSet) in modo da far circolare su ogni led 1.5V 10mA. Ho misurato l'assorbimento di tutto il circuito quindi attiny13, max7219 e 64 led accesi misurando solo 58mA.
Può essere veritiero un valore così basso o devo iniziare a pensare che il mio multimetro è proprio una chiavica?

[Reply #2 on:]

Piccolo aggiornamento del topic: riesco a far funzionare il Max7219 sull'ATtiny13A.
Non posso usare la libreria ledControl perchè  non entra nel micro però ho trovato un altro metodo nel playground.
Ho collegato al max7219 una matrice di 64 led e ho dimensionato la resistenza da mettere sul pin 18(RSet) in modo da far circolare su ogni led 1.5V 10mA. Ho misurato l'assorbimento di tutto il circuito quindi attiny13, max7219 e 64 led accesi misurando solo 58mA.
Può essere veritiero un valore così basso o devo iniziare a pensare che il mio multimetro è proprio una chiavica?

proprio in questi giorni sto facendo misurazioni con la gestione multiplexer di display a led. Se vuoi leggere il consumo effettivo devi rallentare il mux fino a farlo diventare una chiavica, al pari del multimetro . Scherzo, io da me leggo che ogni segmento assorbe 2-3mA, sembra un valore stravagante e probabilmente lo è. Credo che la frequenza di aggiornamento del multimetro sia decisamente più bassa di quella del mux, quindi non riesce a fare una misura completa; questo vale anche per il mio multimetro di buona qualità ma un po' datato. Se diminuisci di molto la frequenza, avrai modo di leggere correttamente il reale consumo di un singolo LED o di una riga/colonna (ora non so come li stai pilotando); è la prova che farò io appena possibile, penso sia l'unica per vedere il consumo reale.

[Reply #3 on:]

In realtà faccio accendere tutti i led in sequenza fino ad arrivare a 64 led accesi; la funzione l'ho messa tutta nel setup perchè in sostanza il circuito deve fare solo quello... il loop è vuoto.
L'ultima istruzione che arriva al multiplexer è quella di far accendere tutti i led.
---edit---
Ora ho il clock impostato a 9.6MHz, giusto per verificare lo imposto a 128 KHz.

[Reply #4 on:]

In realtà faccio accendere tutti i led in sequenza fino ad arrivare a 64 led accesi; la funzione l'ho messa tutta nel setup perchè in sostanza il circuito deve fare solo quello... il loop è vuoto.
L'ultima istruzione che arriva al multiplexer è quella di far accendere tutti i led.
---edit---
Ora ho il clock impostato a 9.6MHz, giusto per verificare lo imposto a 128 KHz.

sì, meglio ancora se riesci a schiaffarci un delay di qualche secondo e fare la misura in quel periodo di tempo...

[Reply #5 on:]

Puoi caricare il codice ? A giorni dovrebbero, spero che arrivino i miei così provo ... 

[Reply #6 on:]

Puoi caricare il codice ? A giorni dovrebbero, spero che arrivino i miei così provo ...  

Ammazza... ma ancora non ti sono arrivati?
Questo sketch fa accendere i led di due matrici 8x8 (due MAX7219 in cascata);
Comunque ti avviso: non pensare di fare scritte scorrevoli o giochetti strani perchè hai solo 1k a disposizione; il codice che ho scritto per l'accensione dei led è veramente ridotto all'osso.
Ecco il codice:

const int dataIn = 0;
const int load = 1;
const int clock = 2;

const int maxInUse = 2;    //change this variable to set how many MAX7219's you'll use

                     // define max7219 registers
const byte max7219_reg_noop        = 0x00;
const byte max7219_reg_digit0      = 0x01;
const byte max7219_reg_digit1      = 0x02;
const byte max7219_reg_digit2      = 0x03;
const byte max7219_reg_digit3      = 0x04;
const byte max7219_reg_digit4      = 0x05;
const byte max7219_reg_digit5      = 0x06;
const byte max7219_reg_digit6      = 0x07;
const byte max7219_reg_digit7      = 0x08;
const byte max7219_reg_decodeMode  = 0x09;
const byte max7219_reg_intensity   = 0x0a;
const byte max7219_reg_scanLimit   = 0x0b;
const byte max7219_reg_shutdown    = 0x0c;
const byte max7219_reg_displayTest = 0x0f;

const byte array[] = {0,1,3,7,15,31,63,127,255};
const int ritardo = 35;
const byte acceso = 255;
const byte spento = 0;
byte array_flag[] = {0,0,0,0,0,0,0,0,0}; //array x flag accose/spento

void setup ()
{
  pinMode(dataIn, OUTPUT);
  pinMode(clock,  OUTPUT);
  pinMode(load,   OUTPUT);

//////////////////////////////////////////////initiation of the max 7219
  maxAll(max7219_reg_scanLimit, 0x07);      
  maxAll(max7219_reg_decodeMode, 0x00);  // using an led matrix (not digits)
  maxAll(max7219_reg_shutdown, 0x01);    // not in shutdown mode
  maxAll(max7219_reg_displayTest, 0x00); // no display test
   for (int e=1; e<=8; e++) {    // empty registers, turn all LEDs off
    maxAll(e,0);
  }
  maxAll(max7219_reg_intensity, 0x0f & 0x0f);    // the first 0x0f is the value you can set
  
  // accende singolarmente tutti i led della matrice                                             // range: 0x00 to 0x0f
  for(int i=1;i<9;i++)
  {
    for(int n=1;n<9;n++)
    {
      //assegna il flag corrente (i) con tutti i valori di array[]
      array_flag[ i ] = array[n];
      //richiama la funzione
      maxAll(1,array_flag[1]);
      maxAll(2,array_flag[2]);
      maxAll(3,array_flag[3]);
      maxAll(4,array_flag[4]);
      maxAll(5,array_flag[5]);
      maxAll(6,array_flag[6]);
      maxAll(7,array_flag[7]);
      maxAll(8,array_flag[8]);
      delay(ritardo);
    }
    //lascia acceso il flag per il prossimo ciclo
    array_flag[ i ] = acceso;
  }
}  

void loop (){}

void putByte(byte data) {
  byte z = 8;
  byte mask;
  while(z > 0) {
    mask = 0x01 << (z - 1);      // get bitmask
    digitalWrite( clock, LOW);   // tick
    if (data & mask){            // choose bit
      digitalWrite(dataIn, HIGH);// send 1
    }else{
      digitalWrite(dataIn, LOW); // send 0
    }
    digitalWrite(clock, HIGH);   // tock
    --z;                         // move to lesser bit
  }
}

void maxAll (byte reg, byte col) {    // initialize  all  MAX7219's in the system
  int c = 0;
  digitalWrite(load, LOW);  // begin    
  for ( c =1; c<= maxInUse; c++) {
  putByte(reg);  // specify register
  putByte(col);//((data & 0x01) * 256) + data >> 1); // put data
    }
  digitalWrite(load, LOW);
  digitalWrite(load,HIGH);
}

Binary sketch size: 716 bytes (of a 1024 byte maximum) Ci può stare no?  

[Reply #7 on:]

Grazie 

[Reply #8 on:]

Grazie  

Ma figurati, per così poco....
Ti mostro cosa fa lo sketch:

Aspetta a copiarlo perchè devo sistemare gli errori di visualizzazione sul codice; nota questa cosa: come vedi ho impostato il delay a 35 ma in realtà è più lento. Fossero stati davvero 35 ms si sarebbero accesi quasi subito tutti i led. E' il core dell'attiny13 che ha i tempi sballati

[Reply #9 on:]

Non ti preoccupare, ho preso i max perchè li ho trovati ad un prezzo allettante ma non li ho ancora usati e devo ancora capire dove potrei usarli quindi fretta non ne ho, grazie comunque, sei gentilissimo !

[Reply #10 on:]

Hai pensato agli ATtiny4313? Hanno più spazio e sono identici ai 2313.
Io lo ho presi su Ebay.

[Reply #11 on:]

Si si, li conosco ma ancora non ho avuto il piacere di usarli... i 2313 invece li ho nel cassetto dei microcontrollori che attendono di essere seviziati