Frickelpiet.de

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Sie befinden sich hier: start » arduino » spektrumanalysator » programmversion_0.5
Zuletzt angesehen:
arduino:spektrumanalysator:programmversion_0.5

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
arduino:spektrumanalysator:programmversion_0.5 [01.10.2017 00:43] – Frickelpietarduino:spektrumanalysator:programmversion_0.5 [18.05.2023 12:34] (aktuell) – Externe Bearbeitung 127.0.0.1
Zeile 1: Zeile 1:
 ====== Spektrumanalysator - Programmversion 0.5 ====== ====== Spektrumanalysator - Programmversion 0.5 ======
 +Diese Programmversion bindet ein OLED-Display ein. Die Bibliothek von Adafruit ist sehr langsam, was die Verwendung des Displays stark einschränkt. Perspektivisch soll das Display aber primär dafür verwendet werden, verschiedene Parameter anzuzeigen, so dass der Inhalt nur geändert werden muss, wenn Einstellungen vorgenommen wurden. Dafür ist die Geschwindigkeit der Bibliothek ausreichend.
  
-(kommt bald!)+Wenn das Eingangssignal unter einen gewissen Pegel fällt und auf diesem Pegel verbleibt, wird das OLED-Display mit einem coolen Effekt ausgeschaltet. 
 + 
 +Menüstruktur: 
 +Hauptmenü 
 +  * Input Select 
 +  * Anzeigemodi 
 +  * Auto Input Level Control 
 +  * Pixel Fading 
 + 
 + 
 +Der Code zur Ansteuerung der Signalrelais ist noch nicht getestet. 
 + 
 +<code> 
 +// Spektrumanalysator 
 +// Für einen NeoPixel-Streifen mit 72 NeoPixeln 
 +// Bindet ein OLED-Display ein 
 +// Steuert drei Signalrelais 
 + 
 +//Bibliotheken 
 +#include <Audio.h>                                        // Teensy Audio-Bibliothek 
 +#include <Wire.h> 
 +#include <SPI.h> 
 +#include <SD.h> 
 +#include <SerialFlash.h> 
 +#include <Adafruit_GFX.h>                                 // GFX_Bibliothek von Adafruit 
 +#include <Adafruit_SSD1351.h>                             // SSD1351-Bibliothek von Adafruit (OLED-Display) 
 +#include <Encoder.h>                                      // Encoder 
 +#include <Adafruit_NeoPixel.h>                            // NeoPixel-Bibliothek von Adafruit 
 + 
 +// Pins 
 +#define encoderChannelA  24                               // Kanal A 
 +#define encoderChannelB  25                               // Kanal B 
 + 
 +#define NEOPIXELPIN      33                               // NeoPixel-Streifen 
 + 
 +#define relayA_on        27                               // Relais A, An-Spule 
 +#define relayA_off       28                               // Relais A, Aus-Spule 
 +#define relayB_on        29                               // Relais B, An-Spule 
 +#define relayB_off       30                               // Relais B, Aus-Spule 
 +#define relayC_on        31                               // Relais C, An-Spule 
 +#define relayC_off       32                               // Relais C, Aus-Spule 
 + 
 +#define sclk 14  // 38 
 +#define mosi 7   // 39 
 +#define dc   20 
 +#define cs   21 
 +#define rst  8 
 + 
 +// Color definitions 
 +#define BLACK           0x0000 
 +#define BLUE            0x001F 
 +#define RED             0xF800 
 +#define GREEN           0x07E0 
 +#define CYAN            0x07FF 
 +#define MAGENTA         0xF81F 
 +#define YELLOW          0xFFE0   
 +#define WHITE           0xFFFF 
 + 
 +// Option 1: use any pins but a little slower 
 +Adafruit_SSD1351 oled = Adafruit_SSD1351(cs, dc, mosi, sclk, rst);   
 + 
 +// Option 2: must use the hardware SPI pins  
 +// (for UNO thats sclk = 13 and sid = 11) and pin 10 must be  
 +// an output. This is much faster - also required if you want 
 +// to use the microSD card (see the image drawing example) 
 +//Adafruit_SSD1351 tft = Adafruit_SSD1351(cs, dc, rst); 
 + 
 +// Dreh-Encoder 
 +Encoder myEnc(encoderChannelA, encoderChannelB); 
 + 
 +long newPosition = 0; 
 +long oldPosition; 
 + 
 +// Signaleingang 
 +int input = 0;                                 // 0 = kein Input, 1 = digital, 2 = analog Cinch, 3 = analog Klinke 
 + 
 +// Signalrelais 
 +boolean relayA = HIGH;                                   // Input digital 
 +boolean relayB = LOW;                                    // Input Cinch 
 +boolean relayC = LOW;                                    // Input Klinke 
 + 
 +// OLED-Display 
 +boolean refresh = true;                                  // Wird wahr, wenn das Display aktualisiert werden muss 
 +float autoGainGraphArray[128];                           // Speichert die Variable autoGain in einem Array, um einen Graph auf dem OLED-Display darzustellen 
 +int x; 
 +int z; 
 +float masterPeakGraphArray[128];                         // Speichert die Variable peak_Max in einem Array, um einen Graph auf dem OLED-Display darzustellen 
 + 
 +// Menü Spektrumanalysator 
 +unsigned char analyzerMode = 0;                          // Verschiedene Anzeigemodi 
 + 
 +// Automatische Eingangspegelregelung 
 +boolean autoInputLevelControl = true;                     // Aktiviert und deaktiviert die automatische Eingangspegelregelung 
 +float peakMaxDecrease = 0.001;                            // Wert, um den der Maximalpeak kontinuierlich verringert wird. (Kann später im Menü angepasst werden.) 
 + 
 +float level_L[36];                                        // Array für die Daten der FFT (linker Kanal) 
 +float level_R[36];                                        // Array für die Daten der FFT (rechter Kanal) 
 +float leftPeak;                                           // Pegel linker Kanal. Kann Werte zwischen 0.00 und 1.00 annehmen. 
 +float rightPeak;                                          // Pegel rechter Kanal. Kann Werte zwischen 0.00 und 1.00 annehmen. 
 +float masterPeak;                                         // Pegel des rechten und des linken Kanals. Kann Werte zwischen 0.00 und 1.00 annehmen. 
 +float masterPeakMax;                                      // Maximalpegel beider Audiokanäle, von dem schrittweise "peakDecrease" substrahiert wird. Kann Werte zwischen 0.00 und 1.00 annehmen. 
 +float peakDecrease = 0.001; 
 +float autoGain;                                           // Anhebung des Eingangssignals: Dämpfung zwischen 0.00 bis 1.00, Anhebung ab 1.01 
 +float masterPeakArray[10];                                // Dieses Array wird für die bestimmung des lautesten Pegels von 10 Messungen verwendet. 
 +float peak_Max; 
 +int a; 
 + 
 +// Konfiguriert den NeoPixel-Ring 
 +int numPixels = 72;                                             // Anzahl der NeoPixel 
 +Adafruit_NeoPixel strip = Adafruit_NeoPixel(numPixels, NEOPIXELPIN, NEO_GRBW + NEO_KHZ800); 
 + 
 +// Anzeige Spektrumanalysator 
 +float n; 
 +int i;                                                    // Variable zum zählen 
 +byte r = 0; 
 +byte g = 0; 
 +byte b = 0; 
 +byte w = 0; 
 + 
 +// GUItool: begin automatically generated code 
 +AudioInputI2S            i2s1;             //xy=98,272 
 +AudioMixer4              mixer_R;          //xy=245,320 
 +AudioMixer4              mixer_L;          //xy=247,235 
 +AudioAnalyzePeak         peak_R;           //xy=442,293 
 +AudioAnalyzeFFT1024      fft1024_R;        //xy=451,327 
 +AudioAnalyzePeak         peak_L;           //xy=455,146 
 +AudioAnalyzeFFT1024      fft1024_L;        //xy=461,184 
 +AudioConnection          patchCord1(i2s1, 0, mixer_L, 0); 
 +AudioConnection          patchCord2(i2s1, 1, mixer_R, 0); 
 +AudioConnection          patchCord3(mixer_R, peak_R); 
 +AudioConnection          patchCord4(mixer_R, fft1024_R); 
 +AudioConnection          patchCord5(mixer_L, peak_L); 
 +AudioConnection          patchCord6(mixer_L, fft1024_L); 
 +AudioControlSGTL5000     sgtl5000_1;        //xy=107,430 
 +// GUItool: end automatically generated code 
 + 
 +// Definiert die Tracking-Variablen für die IF-Abfragen 
 +unsigned long previousMillisAutoInputLevelControl = 0;          // Berechnung des maximalen Peaks für die automatische Inputlevel-Regelung 
 +unsigned long previousMillisOLED = 0;                           // OLED-Display 
 + 
 +// Definiert die Intervalle für die IF-Abfragen in Millisekunden 
 +unsigned long intervalAutoInputLevelControl = 100;              // Berechnung des maximalen Peaks für die automatische Inputlevel-Regelung 
 +unsigned long intervalOLED = 100;                               // OLED-Display 
 + 
 + 
 +// Taktung Schleifen 
 +unsigned long lastMillis = 0; 
 +unsigned long duration = 0; 
 + 
 + 
 +void setup() { 
 +  Serial.begin(115200);                  
 + 
 +// OLED-Display 
 +  oled.begin(); 
 + 
 +  oled.fillScreen(BLACK); 
 +  oled.setCursor(15, 32); 
 +  oled.setTextColor(WHITE, BLACK); 
 +  oled.setTextSize(0); 
 +  oled.print("Spektrumanalysator"); 
 +  oled.setCursor(20, 55); 
 +  oled.print("Programmversion"); 
 +  oled.setCursor(45, 75); 
 +  oled.setTextSize(2); 
 +  oled.print("0.5"); 
 + 
 +  delay(500); 
 +  oled.fillScreen(BLACK); 
 +  
 +  // Audio-Funktionen 
 +  AudioMemory(22);                                              // Audiospeicher 
 + 
 +  sgtl5000_1.enable(); 
 +  sgtl5000_1.muteHeadphone(); 
 +  sgtl5000_1.muteLineout(); 
 +  sgtl5000_1.inputSelect(AUDIO_INPUT_LINEIN); 
 +  sgtl5000_1.lineInLevel(5); 
 +   
 +  // Configure the window algorithm to use 
 +  fft1024_L.windowFunction(AudioWindowHanning1024); 
 +  fft1024_R.windowFunction(AudioWindowHanning1024); 
 +    
 +  // Eingangsrelais 
 +  pinMode(relayA_on, OUTPUT);                                   // sets the digital pin as output 
 +  pinMode(relayA_off, OUTPUT);                                  // sets the digital pin as output 
 +  pinMode(relayB_on, OUTPUT);                                   // sets the digital pin as output 
 +  pinMode(relayB_off, OUTPUT);                                  // sets the digital pin as output 
 +  pinMode(relayC_on, OUTPUT);                                   // sets the digital pin as output 
 +  pinMode(relayC_off, OUTPUT);                                  // sets the digital pin as output 
 +   
 +  digitalWrite(relayA_on, HIGH);                                // Die An-Spule von Relais A wird eingeschaltet 
 +  delay(20); 
 +  digitalWrite(relayA_on, LOW);                                 // Die An-Spule von Relais A wird ausgeschaltet 
 +  delay(20); 
 +  digitalWrite(relayA_off, HIGH);                               // Die Aus-Spule von Relais A wird eingeschaltet 
 +  delay(20); 
 +  digitalWrite(relayA_off, LOW);                                // Die Aus-Spule von Relais A wird ausgeschaltet 
 +  delay(20); 
 +   
 +  digitalWrite(relayB_on, HIGH);        
 +  delay(20); 
 +  digitalWrite(relayB_on, LOW);        
 +  delay(20); 
 +  digitalWrite(relayB_off, HIGH); 
 +  delay(20); 
 +  digitalWrite(relayB_off, LOW); 
 +  delay(20); 
 +   
 +  digitalWrite(relayC_on, HIGH);        
 +  delay(20); 
 +  digitalWrite(relayC_on, LOW);        
 +  delay(20); 
 +  digitalWrite(relayC_off, HIGH); 
 +  delay(20); 
 +  digitalWrite(relayC_off, LOW); 
 +  delay(20); 
 + 
 +  if (input == 1) { 
 +    digitalWrite(relayA_on, HIGH);        
 +    delay(20); 
 +    digitalWrite(relayA_on, LOW);        
 +  } 
 +  else if (input == 2) { 
 +    digitalWrite(relayB_on, HIGH);        
 +    delay(20); 
 +    digitalWrite(relayB_on, LOW); 
 +  } 
 +  else if (input == 3) { 
 +    digitalWrite(relayC_on, HIGH);        
 +    delay(20); 
 +    digitalWrite(relayC_on, LOW); 
 +  } 
 +   
 +  // Initialisiert den NeoPixel-Teststrip 
 +  strip.begin(); 
 +  strip.show();                                                 // Initialize all pixels to 'off' 
 +  strip.setBrightness(64);                                      // 1/4 der maximalen Helligkeit 
 +   
 +  // Legt den Anzeigemodus fest (provisorisch) 
 +  analyzerMode = 0; 
 + 
 +  // Schaltet die automatische Inputlevelregelung ein bzw. aus. (Kann später im Menü aktiviert und deaktiviert werden.) 
 +  autoInputLevelControl = true; 
 +} 
 + 
 +void loop() { 
 +  // Aktuelle Zeit abfragen 
 +  unsigned long currentMillis = millis(); 
 +   
 +  // Encoder 
 +  newPosition = myEnc.read(); 
 +  if (newPosition != oldPosition) { 
 +    oldPosition = newPosition; 
 +  } 
 +  if (newPosition < 0) { 
 +    newPosition = 0; 
 +  } 
 +  if (newPosition >= 120) { 
 +    newPosition = 120; 
 +  }   
 + 
 +  // Gain Control   
 +  if (autoInputLevelControl == false) {                        // Die manuelle Inputlevel-Kontrolle ist nur aktiv, wenn die automatische Inputlevel-Regelung deaktiviert ist 
 +    mixer_L.gain(0, (newPosition / 40.0)); 
 +    mixer_R.gain(0, (newPosition / 40.0)); 
 +  } 
 + 
 +  // Fast Fourier Transformation (FFT) 
 +  if (fft1024_L.available() && fft1024_R.available()) {        // Wenn die FFT neue Daten berechnet hat, werden für beide Kanäle je 512 FFT Frequenzen ausgelesen und in je 36 Bändern zusammengefasst. 
 +     
 +    // Zuerst ist der linke Kanal an der Reihe 
 +    level_L[35] =  fft1024_L.read(0); 
 +    level_L[34] =  fft1024_L.read(1); 
 +    level_L[33] =  fft1024_L.read(2); 
 +    level_L[32] =  fft1024_L.read(3); 
 +    level_L[31] =  fft1024_L.read(4, 5); 
 +    level_L[30] =  fft1024_L.read(6, 7); 
 +    level_L[29] =  fft1024_L.read(8, 9); 
 +    level_L[28] =  fft1024_L.read(10, 11); 
 +    level_L[27] =  fft1024_L.read(12, 14); 
 +    level_L[26] =  fft1024_L.read(15, 17); 
 +    level_L[25] = fft1024_L.read(18, 20); 
 +    level_L[24] = fft1024_L.read(21, 24); 
 +    level_L[23] = fft1024_L.read(25, 28); 
 +    level_L[22] = fft1024_L.read(29, 32); 
 +    level_L[21] = fft1024_L.read(33, 37); 
 +    level_L[20] = fft1024_L.read(38, 43); 
 +    level_L[19] = fft1024_L.read(44, 49); 
 +    level_L[18] = fft1024_L.read(50, 56); 
 +    level_L[17] = fft1024_L.read(57, 64); 
 +    level_L[16] = fft1024_L.read(65, 73); 
 +    level_L[15] = fft1024_L.read(74, 83); 
 +    level_L[14] = fft1024_L.read(84, 94); 
 +    level_L[13] = fft1024_L.read(95, 107); 
 +    level_L[12] = fft1024_L.read(108, 121); 
 +    level_L[11] = fft1024_L.read(122, 137); 
 +    level_L[10] = fft1024_L.read(138, 155); 
 +    level_L[9] = fft1024_L.read(156, 175); 
 +    level_L[8] = fft1024_L.read(176, 198); 
 +    level_L[7] = fft1024_L.read(199, 223); 
 +    level_L[6] = fft1024_L.read(224, 251); 
 +    level_L[5] = fft1024_L.read(252, 283); 
 +    level_L[4] = fft1024_L.read(284, 319); 
 +    level_L[3] = fft1024_L.read(320, 359); 
 +    level_L[2] = fft1024_L.read(360, 404); 
 +    level_L[1] = fft1024_L.read(405, 454); 
 +    level_L[0] = fft1024_L.read(455, 511); 
 +       
 +    // Und dann der rechte Kanal 
 +    level_R[0] =  fft1024_R.read(0); 
 +    level_R[1] =  fft1024_R.read(1); 
 +    level_R[2] =  fft1024_R.read(2); 
 +    level_R[3] =  fft1024_R.read(3); 
 +    level_R[4] =  fft1024_R.read(4, 5); 
 +    level_R[5] =  fft1024_R.read(6, 7); 
 +    level_R[6] =  fft1024_R.read(8, 9); 
 +    level_R[7] =  fft1024_R.read(10, 11); 
 +    level_R[8] =  fft1024_R.read(12, 14); 
 +    level_R[9] =  fft1024_R.read(15, 17); 
 +    level_R[10] = fft1024_R.read(18, 20); 
 +    level_R[11] = fft1024_R.read(21, 24); 
 +    level_R[12] = fft1024_R.read(25, 28); 
 +    level_R[13] = fft1024_R.read(29, 32); 
 +    level_R[14] = fft1024_R.read(33, 37); 
 +    level_R[15] = fft1024_R.read(38, 43); 
 +    level_R[16] = fft1024_R.read(44, 49); 
 +    level_R[17] = fft1024_R.read(50, 56); 
 +    level_R[18] = fft1024_R.read(57, 64); 
 +    level_R[19] = fft1024_R.read(65, 73); 
 +    level_R[20] = fft1024_R.read(74, 83); 
 +    level_R[21] = fft1024_R.read(84, 94); 
 +    level_R[22] = fft1024_R.read(95, 107); 
 +    level_R[23] = fft1024_R.read(108, 121); 
 +    level_R[24] = fft1024_R.read(122, 137); 
 +    level_R[25] = fft1024_R.read(138, 155); 
 +    level_R[26] = fft1024_R.read(156, 175); 
 +    level_R[27] = fft1024_R.read(176, 198); 
 +    level_R[28] = fft1024_R.read(199, 223); 
 +    level_R[29] = fft1024_R.read(224, 251); 
 +    level_R[30] = fft1024_R.read(252, 283); 
 +    level_R[31] = fft1024_R.read(284, 319); 
 +    level_R[32] = fft1024_R.read(320, 359); 
 +    level_R[33] = fft1024_R.read(360, 404); 
 +    level_R[34] = fft1024_R.read(405, 454); 
 +    level_R[35] = fft1024_R.read(455, 511); 
 + 
 +    // Anzeigemodi 
 +    //Effekt "0" 
 +    if (analyzerMode == 0) {  
 +      
 +      // Anschließend werden Farbwerte für die linke Seite des NeoPixel-Streifens berechnet 
 +      for (i=0; i<(numPixels/2); i++) { 
 +        n = level_L[i]; 
 +        if (n >= 0.01) { 
 +          // Scale 'heat' down from 0-255 to 0-191 
 +          byte t192 = round((n * 2000  /255.0) * 191); 
 +       
 +          byte heatramp = t192 & 0x3F; // 0..63 
 +          heatramp <<= 2; // scale up to 0..252 
 +        
 +          if(t192 > 0x80) {                       // hottest 
 +            strip.setPixelColor(i, 255, 255, heatramp, 0); 
 +            }  
 +          else if(t192 > 0x40) {             // middle 
 +            strip.setPixelColor(i, 255, heatramp, 0, 0); 
 +            } 
 +          else {                               // coolest 
 +            strip.setPixelColor(i, heatramp, 0, 0, 0); 
 +          } 
 +        } 
 +        else { 
 +          strip.setPixelColor(i, 0, 0, 0, 0); 
 +        } 
 +      } 
 + 
 +      // Dann werden die Farbwerte für die rechte Seite des NeoPixel-Streifens berechnet 
 +      for (i=0; i<(numPixels/2); i++) { 
 +        n = level_R[i]; 
 +        if (n >= 0.01) { 
 +          // Scale 'heat' down from 0-255 to 0-191 
 +          byte t192 = round((n * 2000  /255.0) * 191); 
 +       
 +          byte heatramp = t192 & 0x3F; // 0..63 
 +          heatramp <<= 2; // scale up to 0..252 
 +       
 +          if(t192 > 0x80) {                       // hottest 
 +            strip.setPixelColor(i+36, 255, 255, heatramp, 0); 
 +            }  
 +          else if(t192 > 0x40) {             // middle 
 +            strip.setPixelColor(i+36, 255, heatramp, 0, 0); 
 +            } 
 +          else {                               // coolest 
 +            strip.setPixelColor(i+36, heatramp, 0, 0, 0); 
 +          } 
 +        } 
 +        else { 
 +          strip.setPixelColor(i+36, 0, 0, 0, 0); 
 +        } 
 +      } 
 + 
 +      // Die Daten werden an den NeoPixel-Streifen geschickt 
 +      strip.show(); 
 +    } 
 + 
 + 
 +    // Automatische Eingangspegelregelung 
 +    if (autoInputLevelControl == true) { 
 +      // Es werden die Pegel des linken und rechten Audiokanals ausgelesen. 
 +      if (peak_L.available() && peak_R.available()) { 
 +        leftPeak = peak_L.read();                                       // Der Pegel des linken Kanals wird in die Variable geschrieben. 
 +        rightPeak = peak_R.read();                                      // Der Pegel des rechten Kanals wird in die Variable geschrieben. 
 +      } 
 +      // Für die automatische Eingangspegelregelung wird der lautere der beiden Audiokanäle verwendet. 
 +      masterPeak = max(leftPeak, rightPeak); 
 +  
 +      // Der Maximalpegel wird gespeichert 
 +      if (masterPeak > masterPeakMax) { 
 +        masterPeakMax = masterPeak; 
 +      } 
 +      // Alle 100 Millikekunden wird die Eingangspegelanpassung berechnet 
 +      if ((unsigned long)(currentMillis - previousMillisAutoInputLevelControl) >= intervalAutoInputLevelControl) { 
 +        // Die automatische Eingangspegelanpassung hebt leise Eingangspegel an, aber ohne den Pegel vollständig zu kompensieren. 
 +        // Auf diese Weise haben leise Eingangssignale einen geringeren Pegelausschalg als laute, es wird aber dennoch "mehr" angezeigt.  
 +        masterPeakMax = masterPeakMax - peakDecrease;                   // Der Maximalpegel wird schrittweise um den Wert "peakDecrease" verringert.    
 + 
 +        autoGain = (1.00 - masterPeakMax) * 4;                          // autoGain wird berechnet 
 +        if (autoGain > 4.00) {                                          // Die Maximale Pegelanhebung soll den Faktor 4 nicht überschreiten 
 +          autoGain = 4.00; 
 +        } 
 +        if (autoGain < 1.00) {                                          // Die Maximale Pegelanhebung soll den Faktor 1 nicht unterschreiten 
 +          autoGain = 1.00; 
 +        } 
 +        mixer_L.gain(0, autoGain);                                      // Der Eingangspegel des linken Kanals wird angepasst 
 +        mixer_R.gain(0, autoGain);                                      // Der Eingangspegel des rechten Kanals wird angepasst 
 + 
 +        previousMillisAutoInputLevelControl = currentMillis; 
 +      } 
 +      // Für die grafische Darstellung des Maximalpegels auf dem OLED-Display wird der größte aus 10 Messwerten bestimmt 
 +      a++;                                                // Es werden 10 Werte in einem Array gespeichert 
 +      masterPeakArray[a] = masterPeak; 
 +      if (a > 9) { 
 +        a = 0; 
 +      }    
 +      unsigned char kmax=0;                               // Es wird der größte Wert in dem Array bestimmt 
 +      float max=0; 
 +      for (unsigned char k=0; k<10; k++) { 
 +        if (masterPeakArray[k] > max) { 
 +          max = masterPeakArray[k]; 
 +          kmax = k; 
 +        } 
 +      } 
 +      peak_Max = masterPeakArray[kmax];      
 +              
 +    } 
 + 
 + 
 +    // Es wird die Zeit in Millisekunden berechnet, die für einen Durchgang benötigt wurde 
 +    duration = currentMillis - lastMillis; 
 +    lastMillis = currentMillis; 
 +       
 +    // Serieller Output 
 +    Serial.print(" cpu:"); 
 +    Serial.print(AudioProcessorUsageMax()); 
 +    Serial.print(" mem:"); 
 +    Serial.print(AudioMemoryUsageMax()); 
 +    Serial.print(" duration:"); 
 +    Serial.print(duration); 
 +    Serial.print(" pos:"); 
 +    Serial.print(float(newPosition) / 40); 
 +    Serial.print(" peak_L:"); 
 +    Serial.print(leftPeak); 
 +    Serial.print(" peak_R:"); 
 +    Serial.print(rightPeak); 
 +    Serial.print(" masterPeak:"); 
 +    Serial.print(masterPeak); 
 +    Serial.print(" masterPeakMax:"); 
 +    Serial.print(masterPeakMax); 
 +    if (autoInputLevelControl == true) { 
 +      Serial.print(" autoGain:"); 
 +      Serial.print(autoGain); 
 +    } 
 +    Serial.println(); 
 + 
 +     
 + 
 +   
 +  } 
 + // OLED-Display 
 +  if (refresh == true) { 
 +    oled.setTextColor(WHITE, BLACK); 
 +    oled.setTextSize(0); 
 +    oled.setCursor(0, 0); 
 +    oled.print("AILC: "); 
 +    if (autoInputLevelControl == true) { 
 +      oled.print("on"); oled.print(" (sawtooth)"); 
 +    } 
 +    else if (autoInputLevelControl == false) { 
 +      oled.print("off"); 
 +    } 
 +    refresh = false;     
 +  }        
 +  if ((unsigned long)(currentMillis - previousMillisOLED) >= intervalOLED) { 
 +    x++; 
 +    if (x < 127) {                                                          // Bis x = 126 wird ein Graph gezeichnet 
 +      autoGainGraphArray[x] = autoGain; 
 +      oled.drawPixel(x, (128 - (autoGainGraphArray[x] * 25)), WHITE); 
 +      masterPeakGraphArray[x] = peak_Max; 
 +      //oled.drawPixel(x, (128 - (masterPeakGraphArray[x] * 20)), RED); 
 +      oled.drawFastVLine(x, (127 - (masterPeakGraphArray[x] * 20)), (masterPeakGraphArray[x] * 20), RED); 
 +    } 
 +    else if (x >= 127) {                                                    // Ab x >= 127 wird der alte Graph gelöscht, um ein Pixel nach links verschoben, um den aktuellen Messwert ergänzt und neu gezeichnet 
 +      for (z=0; z<127; z++) { 
 +        oled.drawPixel(z, (128 - (autoGainGraphArray[z] * 25)), BLACK); 
 +        //oled.drawPixel(z, (128 - (masterPeakGraphArray[z] * 20)), BLACK); 
 +        oled.drawFastVLine(z, (127 - (masterPeakGraphArray[z] * 20)), (masterPeakGraphArray[z] * 20), BLACK); 
 +      } 
 +      for (z=1; z<127; z++) { 
 +        autoGainGraphArray[z - 1] = autoGainGraphArray[z];                 // Alle Werte in dem Arrayy werden um eine Stelle nach links verschoben. 
 +        masterPeakGraphArray[z - 1] = masterPeakGraphArray[z];             // Alle Werte in dem Arrayy werden um eine Stelle nach links verschoben. 
 +      }       
 +      autoGainGraphArray[126] = autoGain; 
 +      masterPeakGraphArray[126] = peak_Max; 
 +      for (z=0; z<128; z++) { 
 +        oled.drawPixel(z, (128 - (autoGainGraphArray[z] * 25)), WHITE);    // Der aktualisierte Graph wird gezeichent. 
 +        //oled.drawPixel(z, (128 - (masterPeakGraphArray[z] * 20)), RED);    // Der aktualisierte Graph wird gezeichent. 
 +        oled.drawFastVLine(z, (127 - (masterPeakGraphArray[z] * 20)), (masterPeakGraphArray[z] * 20), RED); 
 +      } 
 +      x = 127;       
 +    } 
 +    previousMillisOLED = currentMillis; 
 +  } 
 +  
 +}                                                     // Void Loop Ende 
 +</code> 
 +{{tag>Arduino Spektrumanalysator Teensy}}
arduino/spektrumanalysator/programmversion_0.5.1506811431.txt.gz · Zuletzt geändert: 18.05.2023 12:16 (Externe Bearbeitung)