VU meter stereo regolabile

Ciao e benvenuto all'ultima parte della serie "VU-Meter".

In questa parte, affrontiamo alcune delle vostre richieste di miglioramento e forniamo al nostro VU Meter nuove opzioni di impostazione. Con l'aiuto di un totale di 4 nuovi potenziometri rotanti, la luminosità del display può ora essere impostata in un ampio intervallo e la sensibilità per ogni singolo canale può anche essere regolata nel suo insieme!

Tuttavia, ti chiediamo di capire che non tutte le tue grandi idee e suggerimenti per il miglioramento possono essere prese in considerazione, poiché abbiamo altre grandi idee per progetti che vogliamo presentarti.

Affrontiamo innanzitutto le espansioni hardware di oggi per il nostro contatore VU. Innanzitutto, un potenziometro da 2 KOhm è collegato in serie nei due canali audio R e L. Insieme, formano un controller di sensibilità separato, efficace, approssimativo e regolabile individualmente per entrambi i canali. Inoltre, abbiamo un eccellente controller di sensibilità da 10 KOhm, che cattura entrambi i canali, come opzione di impostazione separata supportata dal software. Si consiglia di progettare i due controller di input come potenziometri di stampa, che, una volta impostati, rimangono impostati nella custodia del misuratore VU. Il regolatore di sensibilità fine, d'altra parte, dovrebbe essere attaccato e regolato dall'esterno usando una manopola.

Infine, manca ancora un'opzione di impostazione per la luminosità del display dall'1 al 100%. Finora abbiamo definito staticamente la luminosità nel codice, anche per mantenere il carico corrente entro limiti. Poiché ciò non è più necessario con il nostro nuovo e più potente alimentatore (5 volt, 2,5 A min), rilasciamo questo parametro anche all'esterno tramite un potenziometro da 10 KOhm per la regolazione. Consiglio di installare questo potenziometro dall'esterno con una manopola regolabile.

Per l'ultima parte della serie, viene visualizzato il seguente elenco parziale: 

• 1x Arduino Nano (con FTDI)
• 1x Pannello LED U64
• 2 resistori da 10 KOhm 1%
• 2x resistenza 680 ohm 5%
• 1x alimentatore da 5 volt, min 2,5 amp
• Condensatore elettrolitico 2x 10 uF 64 volt
• 1x connettore jack stereo da 3,5 mm
• 2x diodo zener da 5,1 volt
• 2x potenziometri rotativi da 10 KOhm (luminosità, sensibilità di regolazione fine)
• 2x potenziometri rotativi da 2 KOhm (sensibilità di regolazione approssimativa R / L)

Ora colleghiamo i componenti del seguente schema elettrico:

Dopo aver completamente costruito o aggiornato il circuito, ora possiamo caricare il codice personalizzato sul nostro Arduino:

#include <Adafruit_NeoPixel.B>

// Quale pin di Arduino è collegato ai NeoPixels?
// Su un gingillo o Gemma ti consigliamo di cambiarlo in 1:
#define LED_PIN     13
// Quanti NeoPixels sono collegati ad Arduino?
#define LED_COUNT  64

// Dichiara il nostro oggetto striscia NeoPixel:
Adafruit_NeoPixel striscia(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argomento 1 = Numero di pixel nella striscia NeoPixel
// argomento 2 = numero pin Arduino (la maggior parte sono validi)
// Argomento 3 = Flag di tipo pixel, sommati secondo necessità:
// NEO_KHZ800 bitstream 800 KHz (la maggior parte dei prodotti NeoPixel con LED WS2812)
// NEO_KHZ400 400 KHz (pixel FLORA 'v1' classici (non v2), driver WS2811)
// I pixel NEO_GRB sono cablati per bitstream GRB (la maggior parte dei prodotti NeoPixel)
// I pixel NEO_RGB sono cablati per bitstream RGB (pixel FLORA v1, non v2)
// I pixel NEO_RGBW sono cablati per bitstream RGBW (prodotti NeoPixel RGBW)

#define analogPinLeft A5 // Canale audio sinistro, collegato al pin analogico A5
#define analogPinRight A4 // Canale audio sinistro, collegato al pin analogico A4
#define analogPinBrightness A3 // Potenziometro di luminosità 10 K, collegato al pin analogico A3
#define analogPinSensivity A2 // Potenziometro di sensibilità 10 K, collegato al pin analogico A2

#definire Left_Channel_Deviation  5
#definire Right_Channel_Deviation 5
#definire Led_Brightness_Deviation 5
#definire VU_Sensivity_Deviation 7

int val_left_old = 0;  // variabile per memorizzare il valore letto dal canale sinistro
int Base_Left = 0;   // 0 Base
int val_right_old = 0;  // variabile per memorizzare il valore letto dal canale sinistro
int Base_Right = 0;   // 0 Base

int leftDropTime, rightDropTime;
int dropDelay = 4;                                        // tempo di attesa prima di far cadere i led
int Led_Brightness = 512;  // 50% Led Led_Brightness default
int Led_Brightness_old = 512;
int GlobalSensivity = 512; // Init con sensibilità minima

byte LedRun_Brightness = 255;  // Led_Brightness massimo al 100%
int VU_Sensivity = 0;
int VU_Sensivity_old  = 0;
galleggiante dropFactor = .98;

vuoto impostare()
{   Seriale.inizio(9600);   striscia.inizio();           // INIZIALIZZA oggetto striscia NeoPixel (RICHIESTO)   Led_Brightness = analogRead(analogPinBrightness);   striscia.SetBrightness(carta geografica(Led_Brightness, 0, 1023, 1, 255)); // Impostare LUMINOSITÀ in base al potenziometro   striscia.mostrare();            // Disattiva tutti i pixel AL PIÙ PRESTO   VU_Sensivity = analogRead(analogPinSensivity);   VU_Sensivity += analogRead(analogPinSensivity);   VU_Sensivity += analogRead(analogPinSensivity);   VU_Sensivity += analogRead(analogPinSensivity);   VU_Sensivity = VU_Sensivity / 4;   Base_Left = analogRead(analogPinLeft);   Base_Left += analogRead(analogPinLeft);   Base_Left += analogRead(analogPinLeft);   Base_Left += analogRead(analogPinLeft);   Base_Left = Base_Left / 4;   Base_Right = analogRead(analogPinRight);   Base_Right += analogRead(analogPinRight);   Base_Right += analogRead(analogPinRight);   Base_Right += analogRead(analogPinRight);   Base_Right = Base_Right / 4;   Seriale.inizio(9600);   colorWipe(striscia.Colore(255, 0, 0), 5); // Rosso   Led_Brightness = analogRead(analogPinBrightness);   striscia.SetBrightness(carta geografica(Led_Brightness, 0, 1023, 1, 255)); // Impostare LUMINOSITÀ in base al potenziometro   striscia.mostrare();   colorWipe(striscia.Colore(255, 255, 0), 5); // giallo   Led_Brightness = analogRead(analogPinBrightness);   striscia.SetBrightness(carta geografica(Led_Brightness, 0, 1023, 1, 255)); // Impostare LUMINOSITÀ in base al potenziometro   striscia.mostrare();   colorWipe(striscia.Colore(0, 255, 0), 5); // Verde   Led_Brightness = analogRead(analogPinBrightness);   striscia.SetBrightness(carta geografica(Led_Brightness, 0, 1023, 1, 255)); // Impostare LUMINOSITÀ in base al potenziometro   striscia.mostrare();   rainbowFade2White(1, 1, 1);   Led_Brightness = analogRead(analogPinBrightness);   striscia.SetBrightness(carta geografica(Led_Brightness, 0, 1023, 1, 255)); // Impostare LUMINOSITÀ in base al potenziometro   striscia.mostrare();   Seriale.println("Init complete. Virtual Zeroline:");   Seriale.Stampa("Sinistra : ");   Seriale.println(Base_Left);   Seriale.Stampa("Giusto: ");   Seriale.println(Base_Right);
}

vuoto ciclo continuo()
{   Left_VU_Meter(LED_COUNT / 2, GlobalSensivity);   Right_VU_Meter(LED_COUNT / 2, GlobalSensivity);   Read_External_Parameters();   striscia.mostrare();   // Aggiorna striscia per abbinare
}


vuoto Read_External_Parameters()
{   Led_Brightness = 0;   Led_Brightness = analogRead(analogPinBrightness);   Led_Brightness += analogRead(analogPinBrightness);   Led_Brightness = Led_Brightness / 2;   Se ((addominali(Led_Brightness - Led_Brightness_old) > Led_Brightness_Deviation))   {     Led_Brightness_old = Led_Brightness;     // Serial.print ("Nuova luminosità LED:");     // Serial.println (mappa (Led_Brightness, 0, 1023, 1, 255));     striscia.SetBrightness(carta geografica(Led_Brightness, 0, 1023, 1, 255)); // Impostare LUMINOSITÀ in base al potenziometro     striscia.mostrare();   }   VU_Sensivity = 0;   VU_Sensivity = analogRead(analogPinSensivity);   VU_Sensivity += analogRead(analogPinSensivity);   VU_Sensivity =  VU_Sensivity / 2;   Se ((addominali( VU_Sensivity - VU_Sensivity_old) >  VU_Sensivity_Deviation))   {     VU_Sensivity_old =  VU_Sensivity;     GlobalSensivity = carta geografica(VU_Sensivity, 0, 1023, 30, 512);     // Serial.print ("New VU Sensivity:");     // Serial.println (GlobalSensivity);   }
}

vuoto Left_VU_Meter(byte Level_Max_Pixels, int sensibilità)
{   int val_left = 0;   bool Sovraccarico = falso;   uint32_t rgbcolor;   uint32_t colore;   int La potenza del segnale = 0;   byte VU_Led_Level = 0;   val_left = analogRead(analogPinLeft);  // legge il pin di input   val_left += analogRead(analogPinLeft);  // legge il pin di input   val_left += analogRead(analogPinLeft);  // legge il pin di input   val_left += analogRead(analogPinLeft);  // legge il pin di input   val_left = val_left / 4;   Se (!(addominali(val_left - val_left_old) > Left_Channel_Deviation)) {     val_left = val_left_old;   }   Se (val_left < val_left_old)   {     leftDropTime++;     Se (leftDropTime > dropDelay)     {       val_left = val_left_old * dropFactor;       leftDropTime = 0;     }     altro     {       val_left = val_left_old;     }   }   val_left_old = val_left;   La potenza del segnale = val_left - Base_Left;   Se (La potenza del segnale < 0) {     La potenza del segnale = - La potenza del segnale;   }   VU_Led_Level =  carta geografica(La potenza del segnale, 0, sensibilità , 0, Level_Max_Pixels);   Se (VU_Led_Level > Level_Max_Pixels)   {     Sovraccarico = vero;     VU_Led_Level = Level_Max_Pixels;   } altro {     Sovraccarico = falso;   }   per (int io = 0; io < Level_Max_Pixels; io++) {     striscia.setPixelColor(io, 0, 0, 0);  // Cancella il colore dei pixel (in RAM)   }   per (int io = 0; io < VU_Led_Level; io++) { // Per ogni pixel nella striscia ...     colore = carta geografica(io, Level_Max_Pixels - 1, 0, 0, 21800);     Se (Sovraccarico) {       rgbcolor = striscia.Colore(255, 0, 0);   // Conversazione da tonalità a RGB     } altro {       rgbcolor = striscia.ColorHSV(colore, 255, LedRun_Brightness);     }     striscia.setPixelColor(io, rgbcolor);         // Imposta il colore del pixel (in RAM)   }
}

vuoto colorWipe(uint32_t colore, int aspettare) {   per (int io = 0; io < striscia.numPixels(); io++) { // Per ogni pixel nella striscia ...     striscia.setPixelColor(io, colore);         // Imposta il colore del pixel (in RAM)     striscia.mostrare();                          // Aggiorna striscia per abbinare     ritardo(aspettare);                           // Pausa per un momento   }
}

vuoto Right_VU_Meter(byte Level_Max_Pixels, int sensibilità)
{   int val_right = 0;   bool Sovraccarico = falso;   uint32_t rgbcolor;   uint32_t colore;   int La potenza del segnale = 0;   byte VU_Led_Level = 0;   val_right  = analogRead(analogPinRight);  // legge il pin di input   val_right  += analogRead(analogPinRight);  // legge il pin di input   val_right  += analogRead(analogPinRight);  // legge il pin di input   val_right  += analogRead(analogPinRight);  // legge il pin di input   val_right  = val_right / 4;   Se (!(addominali(val_right - val_right_old) > Right_Channel_Deviation)) {     val_right = val_right_old;   }   Se (val_right < val_right_old)   {     rightDropTime++;     Se (rightDropTime > dropDelay)     {       val_right = val_right_old * dropFactor;       rightDropTime = 0;     }     altro     {       val_right = val_right_old;     }   }   val_right_old = val_right;   La potenza del segnale = val_right - Base_Right;   Se (La potenza del segnale < 0) {     La potenza del segnale = - La potenza del segnale;   }   VU_Led_Level =  carta geografica(La potenza del segnale, 0, sensibilità , 0, Level_Max_Pixels);   Se (VU_Led_Level > Level_Max_Pixels)   {     Sovraccarico = vero;     VU_Led_Level = Level_Max_Pixels;   } altro {     Sovraccarico = falso;   }   int ColorVector = 0;   per (int io = LED_COUNT - Level_Max_Pixels; io < LED_COUNT; io++) {     striscia.setPixelColor(io, 0, 0, 0);  // Cancella il colore dei pixel (in RAM)   }   int StartVector = LED_COUNT - VU_Led_Level;   per (int io = LED_COUNT - Level_Max_Pixels; io < LED_COUNT; io++) { // Per ogni pixel nella striscia ...     colore = carta geografica(ColorVector, Level_Max_Pixels - 1, 0, 21800, 0);     ColorVector++;     Se ( io >= StartVector)     {       Se (Sovraccarico) {         rgbcolor = striscia.Colore(255, 0, 0);   // Conversazione da tonalità a RGB       } altro {         rgbcolor = striscia.ColorHSV(colore, 255, LedRun_Brightness);       }       striscia.setPixelColor(io, rgbcolor);         // Imposta il colore del pixel (in RAM)     }   }
}

vuoto rainbowFade2White(int aspettare, int rainbowLoops, int whiteLoops) {   int fadeVal = 0, fadeMax = 100;   // La tonalità del primo pixel esegue il ciclo completo 'rainbowLoops' attraverso il colore   // ruota. La ruota dei colori ha un intervallo di 65536 ma va bene se ci capovolgiamo, quindi   // basta contare da 0 a rainbowLoops * 65536, usando i passaggi di 256, quindi noi   // avanza intorno alla ruota con una clip decente.   per (uint32_t firstPixelHue = 0; firstPixelHue < rainbowLoops * 65536;        firstPixelHue += 256) {     per (int io = 0; io < striscia.numPixels(); io++) { // Per ogni pixel nella striscia ...       // Sfalsa la tonalità dei pixel di un importo per fare un giro completo del       // ruota dei colori (intervallo di 65536) lungo la lunghezza della striscia       // (strip.numPixels () steps):       uint32_t pixelHue = firstPixelHue + (io * 65536L / striscia.numPixels());       // strip.ColorHSV () può accettare 1 o 3 argomenti: una tonalità (da 0 a 65535) o       // opzionalmente aggiunge saturazione e valore (luminosità) (ciascuno da 0 a 255).       // Qui stiamo usando solo la variante a tre argomenti, sebbene il       // il secondo valore (saturazione) è una costante 255.       striscia.setPixelColor(io, striscia.gamma32(striscia.ColorHSV(pixelHue, 255,                                            255 * fadeVal / fadeMax)));     }     striscia.mostrare();     ritardo(aspettare);     Se (firstPixelHue < 65536) {                             // Primo ciclo,       Se (fadeVal < fadeMax) fadeVal++;                      // dissolvenza     } altro Se (firstPixelHue >= ((rainbowLoops - 1) * 65536)) { // Last loop,       Se (fadeVal > 0) fadeVal--;                            // dissolvenza     } altro {       fadeVal = fadeMax; // Loop intermedio, assicurarsi che la dissolvenza sia al massimo     }   }   per (int K = 0; K < whiteLoops; K++) {     per (int j = 0; j < 256; j++) { // Aumenta da 0 a 255       // Riempi l'intera striscia di bianco al livello di luminosità con correzione gamma 'j':       striscia.riempire(striscia.Colore(0, 0, 0, striscia.gamma8(j)));
            strip.show ();
    }
  }
}

Die erste Kalibrierung der Empfindlichkeit sollte an den getrennten R / L Grobreglern vorgenommen werden. Questo è il motivo per cui è stato realizzato, dass der Fein Regler für die Empfindlichkeit auf "Minimum" eingestellt wird. Weiterhin sollte darauf geachtet werden, dass während des Einschaltens des VU Meters und dem Abspielen des Intros die Virtuelle Nulllinie eingelesen wird. Dannazione di Kalibrierung korrekt ablaufen kann, è un esempio, quando è in arrivo in fase di segnale audio anzulegen. Prima di tutto ho iniziato a parlare con me, con un analogo film di angelo.

Ich wünsche viel Spaß beim Musik hören und nachbauen.

Bis zum nächsten Mal.

Nachtrag: Fehlende Zeilen im Quellcode wurden hinzugefügt. Danke an Denis für den Hinweis!