LED Cube 8x8x8 RGB PWM...tre soluzioni diverse...quale usare?

Ciao a tutti,

volevo costruire un led cube 8x8x8 rgb pwm, ne ho già costruito uno non rgb, quindi ho un po’ di dimestichezza, non sono un ingegnere elettronico ma con un po’ di pazienza si fa quasi tutto. Sono un po’ indeciso sulla strada da seguire, datemi un consigli, alimentazione a 5 volt con dc step down o alimentatore(quindi regolabile entro certi limiti).

1) Usare 12 5940, servono led con anodo comune; per l’anodo potrei usare due udn2981 in parallelo e multiplexare i piani; per alimentare i led uso direttamente i 5940 visto che non ho problemi di termica, poche saldature, nessuna resistenza.

2) Usare i famosi 74hc595 e la libreria shiftPWM, ho dato una veloce lettura alla libreria e non sembra difficilissima da usare, ma visti i 70 mA massimi dovrò usare anche degli udn 2981 o degli uln2803 (a seconda dell'anodo o catodo comune dei led) e delle resistenze, il circuito e soprattutto le saldature da fare aumentano notevolmente…qualcuno ha provato a vedere se i 74hc595 reggono 160mA?

3) Usare i neopixel ws2811 e risparmiare praticamente la parte elettronica, non ho bisogno di multiplexare, riesco ad accendere se voglio 8 piani insieme, poche saldature, non dovrei avere problemi con la memoria ram (3*512) ma ho bisogno di un alimentatore da 30A e mi sembra un po' di barare.

Sono tre strade completamente diverse e radicalmente diverse, voi cosa mi consigliate?

Indipendentemente dalla strada consigliata, come faccio per la memoria? Premesso che userò un mega per la memoria maggiore, ma con il primo led cube sono arrivato a esaurire la memoria interna (over 40000 righe di codice), esiste un modo per aumentare lo spazio a disposizione per lo sketch?

grazie in anticipo

1) Se vuoi pilotare uno strato alla volta Ti servono 16 TLC5940. Devi usare una libreria di multiplexing del TLC5940 come la trovi su http://www.thebox.myzen.co.uk/Hardware/Mini_Monome.html (link ZIP in basso nel capitolo Arduino Firmware) Saluti e grazie a Grumpy Mike. Non mettere i udn2981 in paralello ma pilota una parte dello strato con una uscita. Usa per questo 2 o 4 UDN e usa sempre solo un uscita per strato. Comunque perdi ca 1,5V sui transistori di potenza del UDN.

2) Ci sono i TPIC6A595 che sono shift register e hanno uscite Open Drain e reggono 350mA per uscita.

3) Non é che solo i WS2812 consumano 30 A. Anche le altre soluzioni succhiano parecchia corrente. Se accendi uno strato tutti i 3 colori ( luce bianca) e hai settato la corrente a 20mA allora hai comunque 3,8A Questa corrente é di 8 volte minore che se useresti dei WS2812, ma i LED a causa del Multiplexing (sempre acceso solo 1/8 dei LED oppure detto in altre parole un LED é acceso solo 1/8 del tempo) sono di 7/8 piú deboli.

Per la mia personale esperienza e scelta tenderei ad usare i Ws2812 in tutti le occassioni dove devo regolare il colore e l' intensitá di un LED.

Ultimamente ho usato un TLC5940 per un display 7 segmenti da 100mm di altezza bicolore rosso verde dove sono per ogni segmento 4 LED in serie e devo alimentarli con 12V ( 5V sono troppo poche). Inolte faccio un Multiplexing 8x4 Ciao Uwe

Usa i WS … come ha detto gia uwe, in multiplexing la luminosita’ “percepita” dall’occhio e’ un’ottavo circa di quella effettiva, perche’ i led “accesi” in realta’ stanno spenti per i sette ottavi del tempo … quindi non ti serve impostare i WS alla massima corrente per avere la stessa luminosita’, ti basta fare lo sketch in modo che il “massimo” venga impostato a circa un’ottavo della scala disponibile … con l’ulteriore vantaggio, usando i WS, che puoi collegare un potenziometro (o perfino una fotoresistenza per la regolazione automatica notturna) ad un’ingresso analogico ed usarlo per regolare la luminosita’ dell’intero cubo da software, cosa che se volessi farla con il multiplexer sarebbe possibile, ma decisamente piu incasinata :slight_smile:

uwefed: 1) Se vuoi pilotare uno strato alla volta Ti servono 16 TLC5940. Devi usare una libreria di multiplexing del TLC5940 come la trovi su http://www.thebox.myzen.co.uk/Hardware/Mini_Monome.html (link ZIP in basso nel capitolo Arduino Firmware) Saluti e grazie a Grumpy Mike. Non mettere i udn2981 in paralello ma pilota una parte dello strato con una uscita. Usa per questo 2 o 4 UDN e usa sempre solo un uscita per strato. Comunque perdi ca 1,5V sui transistori di potenza del UDN.

2) Ci sono i TPIC6A595 che sono shift register e hanno uscite Open Drain e reggono 350mA per uscita.

3) Non é che solo i WS2812 consumano 30 A. Anche le altre soluzioni succhiano parecchia corrente. Se accendi uno strato tutti i 3 colori ( luce bianca) e hai settato la corrente a 20mA allora hai comunque 3,8A Questa corrente é di 8 volte minore che se useresti dei WS2812, ma i LED a causa del Multiplexing (sempre acceso solo 1/8 dei LED oppure detto in altre parole un LED é acceso solo 1/8 del tempo) sono di 7/8 piú deboli.

Per la mia personale esperienza e scelta tenderei ad usare i Ws2812 in tutti le occassioni dove devo regolare il colore e l' intensitá di un LED.

Ultimamente ho usato un TLC5940 per un display 7 segmenti da 100mm di altezza bicolore rosso verde dove sono per ogni segmento 4 LED in serie e devo alimentarli con 12V ( 5V sono troppo poche). Inolte faccio un Multiplexing 8x4 Ciao Uwe

1) perchè 16?Ogni TLC5940 ha 16 output, 192/16=12...i piani li comanderei apparte,ma anche comandando i piani avrei bisogno di 15 TLC5940...cosa mi sfugge?

2) Non li conoscevo, sembrano costare tanto e guardando il datasheet hanno i pin disposti in modo un po' antipatico. Avevo a suo tempo realizzato un led cube 4*4*4 rgb con 6 74hc595 in cascata ma non avevo idea che potessi pilotarli in pwm.

Ho fatto la prova a eliminare un udn2981 e alimentare direttamente 8 led con un 74hc595, niente da fare, dopo un po' diventa eccessivamente caldo. Ieri sera mi ci sono messo un po' ed effettivamente è possibile con la libreria shiftPWM, abbastanza flessibile e intuitiva, solo che ho qualche problema a multiplexare in quanto sfarfalla un po', anche se piloto con i pin per SPI,quindi 13 e 11.

Dovrei aumentare la pwmFrequency ma sopra i 125 non va e non capisco perchè, se avete qualche idea ben venga.

Anyway in serata carico un video, si parla spesso di ledcube ma oddio ci fosse qualcuno che poi aggiorna :D

Sembra cmq la strada più complessa, se già ho problemi con 6 registri in cascata, penso che con 24 diventi un po' troppo complesso, almeno per il sottoscritto che è un ingegnere si, ma industriale.

3)Beh, 3.8A sono un assorbimento nella media, 30A sticazzi...ovviamente nessuno mi dice che devo accendere tutto il cubo, quindi è un "falso" problema.

Indubbiamente è la soluzione più facile, meno saldature, niente sbattimenti particolari, ma più costo, penso che partono 100€ per i led; il prezzo sarebbe un falso problema in realtà, è che viene meno il prio di realizzare la schedina di controllo con la millefori, guardarla una volta finita, provarla, vedere cosa c'è che non va etc etc etc.

Etemenanki: Usa i WS ... come ha detto gia uwe, in multiplexing la luminosita' "percepita" dall'occhio e' un'ottavo circa di quella effettiva, perche' i led "accesi" in realta' stanno spenti per i sette ottavi del tempo ... quindi non ti serve impostare i WS alla massima corrente per avere la stessa luminosita', ti basta fare lo sketch in modo che il "massimo" venga impostato a circa un'ottavo della scala disponibile ... con l'ulteriore vantaggio, usando i WS, che puoi collegare un potenziometro (o perfino una fotoresistenza per la regolazione automatica notturna) ad un'ingresso analogico ed usarlo per regolare la luminosita' dell'intero cubo da software, cosa che se volessi farla con il multiplexer sarebbe possibile, ma decisamente piu incasinata :)

Si si, ho fatto un led cube 8x8x8 blu e so perfettamente di cosa si parla.

In realtà il tutto avrebbe uno scopo didattico, quindi speravo in qualche commento del tipo "ah, sei un cheater se usi quelli"...però sicuramente sono la strada più semplice e visto che ormai gli shift register li so usare, forse può essere più utile imparare a usare i ws piuttosto che un led driver.

xyzthjk: 1) perchè 16?Ogni TLC5940 ha 16 output, 192/16=12...i piani li comanderei apparte,ma anche comandando i piani avrei bisogno di 15 TLC5940...cosa mi sfugge?

Hai ragione mi sono sbagliato per un piano servono 12 TLC5940. Comunque non puoi usarli per pilotare i piani perché le uscite sono uscite corrente contiuna dove la corrente va dal LED nel uscita a massa simile a dei Open Collector (il LED va collegato tra + alimentazione e uscita.

xyzthjk: Ho fatto la prova a eliminare un udn2981 e alimentare direttamente 8 led con un 74hc595, niente da fare, dopo un po' diventa eccessivamente caldo.

attenzione Non puoi usare i TPIC6A595 al posto dei udn2981. I primi sono riferiti a massa e i secondi a positivo dell'alimentazione. Puoi usare i TPIC6A595 al posto della combinazione 75HC595 e ULN2803.

xyzthjk: In realtà il tutto avrebbe uno scopo didattico, quindi speravo in qualche commento del tipo "ah, sei un cheater se usi quelli"...però sicuramente sono la strada più semplice e visto che ormai gli shift register li so usare, forse può essere più utile imparare a usare i ws piuttosto che un led driver.

Noi? come possiamo pensare a quello??? Ciao Uwe

uwefed: Hai ragione mi sono sbagliato per un piano servono 12 TLC5940. Comunque non puoi usarli per pilotare i piani perché le uscite sono uscite corrente contiuna dove la corrente va dal LED nel uscita a massa simile a dei Open Collector (il LED va collegato tra + alimentazione e uscita. attenzione Non puoi usare i TPIC6A595 al posto dei udn2981. I primi sono riferiti a massa e i secondi a positivo dell'alimentazione. Puoi usare i TPIC6A595 al posto della combinazione 75HC595 e ULN2803. Noi? come possiamo pensare a quello??? Ciao Uwe

Sei stato chiarissimo, la prova da me fatta era giusto per vedere se gli udn2981 erano necessari oppure no, almeno nella mia configurazione...eh si, sono necessari, sono un po' diventava troppo caldo.

Quindi appurato che la terza soluzione è la migliore, avete idea di perchè non riesco a salire con la frequenza di modulazione?

con 125 ho un periodo di 8 millisecondi, vorrei salire un po' per potere multiplexare meglio ma poi crasha, qualche idea?Forse con 6 registri in cascata non riesce a gestire una tale quantità di dati?

Effettivamente potrei fare la prova a metterne solo 1 e vedere a quale frequenza "mura", ma una spiegazione teorica è sicuramente meglio.

È un po difficile dire qualcosa sul Tuo Sketch se non lo vediamo. Ciao Uwe

Ecco qui, non ho modificato molto rispetto all’esempio della libreria shiftPWM, solo la frequenza che era di 75.

/************************************************************************************************************************************
 * ShiftPWM blocking RGB fades example, (c) Elco Jacobs, updated August 2012.
 *
 * ShiftPWM blocking RGB fades example. This example uses simple delay loops to create fades.
 * If you want to change the fading mode based on inputs (sensors, buttons, serial), use the non-blocking example as a starting point.
 * Please go to www.elcojacobs.com/shiftpwm for documentation, fuction reference and schematics.
 * If you want to use ShiftPWM with LED strips or high power LED's, visit the shop for boards.
 ************************************************************************************************************************************/
 
// ShiftPWM uses timer1 by default. To use a different timer, before '#include <ShiftPWM.h>', add
// #define SHIFTPWM_USE_TIMER2  // for Arduino Uno and earlier (Atmega328)
// #define SHIFTPWM_USE_TIMER3  // for Arduino Micro/Leonardo (Atmega32u4)

// Clock and data pins are pins from the hardware SPI, you cannot choose them yourself if you use the hardware SPI.
// Data pin is MOSI (Uno and earlier: 11, Leonardo: ICSP 4, Mega: 51, Teensy 2.0: 2, Teensy 2.0++: 22) 
// Clock pin is SCK (Uno and earlier: 13, Leonardo: ICSP 3, Mega: 52, Teensy 2.0: 1, Teensy 2.0++: 21)

// You can choose the latch pin yourself.
const int ShiftPWM_latchPin=7;

// ** uncomment this part to NOT use the SPI port and change the pin numbers. This is 2.5x slower **
// #define SHIFTPWM_NOSPI
// const int ShiftPWM_dataPin = 11;
// const int ShiftPWM_clockPin = 13;


// If your LED's turn on if the pin is low, set this to true, otherwise set it to false.
const bool ShiftPWM_invertOutputs = false; 

// You can enable the option below to shift the PWM phase of each shift register by 8 compared to the previous.
// This will slightly increase the interrupt load, but will prevent all PWM signals from becoming high at the same time.
// This will be a bit easier on your power supply, because the current peaks are distributed.
const bool ShiftPWM_balanceLoad = false;

#include <ShiftPWM.h>   // include ShiftPWM.h after setting the pins!

// Here you set the number of brightness levels, the update frequency and the number of shift registers.
// These values affect the load of ShiftPWM.
// Choose them wisely and use the PrintInterruptLoad() function to verify your load.
// There is a calculator on my website to estimate the load.

unsigned char maxBrightness = 255;
unsigned char pwmFrequency = 75;
int numRegisters = 6;
int numRGBleds = numRegisters*8/3;

void setup(){
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  Serial.begin(9600);

  // Sets the number of 8-bit registers that are used.
  ShiftPWM.SetAmountOfRegisters(numRegisters);

  // SetPinGrouping allows flexibility in LED setup. 
  // If your LED's are connected like this: RRRRGGGGBBBBRRRRGGGGBBBB, use SetPinGrouping(4).
  ShiftPWM.SetPinGrouping(16); //This is the default, but I added here to demonstrate how to use the funtion
  
  ShiftPWM.Start(pwmFrequency,maxBrightness);
}



void loop()
{    
  digitalWrite(2, HIGH);
  digitalWrite(3, HIGH);
  digitalWrite(4, HIGH);
  digitalWrite(5, HIGH);
  // Turn all LED's off.
  ShiftPWM.SetAll(0);

  // Print information about the interrupt frequency, duration and load on your program
  ShiftPWM.PrintInterruptLoad();

  // Fade in and fade out all outputs one by one fast. Usefull for testing your hardware. Use OneByOneSlow when this is going to fast.
  ShiftPWM.OneByOneFast();

  // Fade in all outputs
  for(int j=0;j<maxBrightness;j++){
    ShiftPWM.SetAll(j);  
    delay(20);
  }
  // Fade out all outputs
  for(int j=maxBrightness;j>=0;j--){
    ShiftPWM.SetAll(j);  
    delay(20);
  }


  // Fade in and out 2 outputs at a time
  for(int output=0;output<numRegisters*8-1;output++){
    ShiftPWM.SetAll(0);
    for(int brightness=0;brightness<maxBrightness;brightness++){
      ShiftPWM.SetOne(output+1,brightness);
      ShiftPWM.SetOne(output,maxBrightness-brightness);
      delay(1);
    }
  }

  // Hue shift all LED's
  for(int hue = 0; hue<360; hue++){
    ShiftPWM.SetAllHSV(hue, 255, 255); 
    delay(50);
  }

  // Alternate LED's in 6 different colors
  for(int shift=0;shift<6;shift++){
    for(int led=0; led<numRGBleds; led++){
      switch((led+shift)%6){
      case 0:
        ShiftPWM.SetRGB(led,255,0,0);    // red
        break;
      case 1:
        ShiftPWM.SetRGB(led,0,255,0);    // green
        break;
      case 2:
        ShiftPWM.SetRGB(led,0,0,255);    // blue
        break;
      case 3:
        ShiftPWM.SetRGB(led,255,128,0);  // orange
        break;
      case 4:
        ShiftPWM.SetRGB(led,0,255,255);  // turqoise
        break;
      case 5:
        ShiftPWM.SetRGB(led,255,0,255);  // purple
        break;
      }
    }
    delay(2000);
  }

  // Update random LED to random color. Funky!
  for(int i=0;i<1000;i++){
    ShiftPWM.SetHSV(random(numRGBleds),random(360),255,255);
    delay(15);
  }


  // Immitate a VU meter
  int peak=0;
  int prevPeak=0;

  int currentLevel = 0;
  for(int i=0;i<40;i++){
    prevPeak = peak;
    while(abs(peak-prevPeak)<5){
      peak =  random(numRGBleds); // pick a new peak value that differs at least 5 from previous peak
    }
    // animate to new top
    while(currentLevel!=peak){
      if(currentLevel<peak){
        currentLevel++;
      }
      else{
        currentLevel--;
      }
      for(int led=0;led<numRGBleds;led++){
        if(led<=currentLevel){
          int hue = (numRGBleds-1-led)*120/numRGBleds; // From green to red
          ShiftPWM.SetHSV(led,hue,255,255); 
        }
        else{
          ShiftPWM.SetRGB(led,0,0,0);
        }
      }
      delay((64/numRGBleds)*(numRGBleds-currentLevel)); // go slower near the top
    }
  }

  //  A moving rainbow for RGB leds:
  rgbLedRainbow(numRGBleds, 5, 3, numRegisters*8/3); // Fast, over all LED's
  rgbLedRainbow(numRGBleds, 10, 3, numRegisters*8/3*4); //slower, wider than the number of LED's
}

void rgbLedRainbow(int numRGBLeds, int delayVal, int numCycles, int rainbowWidth){
  // Displays a rainbow spread over a few LED's (numRGBLeds), which shifts in hue. 
  // The rainbow can be wider then the real number of LED's.

  ShiftPWM.SetAll(0);
  for(int cycle=0;cycle<numCycles;cycle++){ // loop through the hue shift a number of times (numCycles)
    for(int colorshift=0;colorshift<360;colorshift++){ // Shift over full color range (like the hue slider in photoshop)
      for(int led=0;led<numRGBLeds;led++){ // loop over all LED's
        int hue = ((led)*360/(rainbowWidth-1)+colorshift)%360; // Set hue from 0 to 360 from first to last led and shift the hue
        ShiftPWM.SetHSV(led, hue, 255, 255); // write the HSV values, with saturation and value at maximum
      }
      delay(delayVal); // this delay value determines the speed of hue shift
    } 
  }  

}

ecco il video

https://youtu.be/LMYlJqq3eKM

se riuscissi a colorare i piani in maniera diversa penso che potrei ritenermi pienamente soddisfatto

news?