Volt und Milivolt mit dem Ardurino Uno R3 ermitteln und weiter verarbeiten

International Deutsch
14

Hallo in die Runde.

Ich hatte nun die Gelegenheit den Code und den UNO auf seine HF-festigkeit zu testen. So in meiner offenen Bauweise scheint sich das alles in Grenzen zu halten. Ebenso hatte ich die Befürchtung, das ich das unvermeidliche Rauschen am "Reflecktet" Sensor in Engen Grenzen halten lässt. 0 Volt feststellen ist ja immer so eine Sache, wenn HF im Spiel ist. Ich meine Festgestellt zu haben, das es nicht schädlich ist, die nicht benötigten Analogen Eingänge mit 500K auf Masse zu legen. So können diese kaum noch Unfug anstellen. Definiertes Potenzial. Das Tiefpass-Filter direkt an A4 A5 mit 200µH und 0,01µF stellt eine hinreichende Dämpfung der HF bereit.
Scheint bis jetzt hinreichend "Weich" zu laufen.

Allerdings ist es mir nicht möglich die folgenden Code Zeilen zu entschlüsseln.

  1. lcd.write(row ? 'F' : 'R');
    Was ist der Sinn und der Zweck?

  2. int anL = map(sqrt(analogRead(IN_LEFT)*19), 0, 128, 0, 100);
    Ebenso hier, benötige ich ein etwas Nachhilfe.

Den Sketch so weit ich den Selben verstanden habe, ist nur unvollständig kommentiert.
Für mich und jeden Anderen, wäre es wohl sehr hilfreich wenn die Funktionen genauer beschrieben werden könnten.

Ich bitte hiermit darum den Code zu überprüfen und dabei den einen oder anderen Kommentar zu ergänzen.

Die Vorangegangene Warnmeldung konnte ich durch ändern von
long lastT = 0; in unsigned long lastT = 0;
Beheben.

Besten Dank im Voraus

[code]
#include <LiquidCrystal.h>
 
#define IN_LEFT    A4  // analog input for left channel
#define IN_RIGHT   A5  // analog input for right channel
 
#define T_REFRESH    25                   // msec bar refresh rate
#define T_PEAKHOLD   (50 * T_REFRESH)     // msec peak hold time before return
 
LiquidCrystal lcd(7,    // RS
                  8,    // E
                  9,    // DB4
                  10,   // DB5
                  11,   // DB6
                  12    // DB7
                  );
 
byte  fill[6] = {0x20, 0x00, 0x01, 0x02, 0x03, 0xFF};       // character used to fill (0=empty  5=full)
byte  peak[7] = {0x20, 0x00, 0x04, 0x05, 0x06, 0x07, 0x20}; // character used to peak indicator
byte block[8][8]=
{
  {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10}, // define character for fill the bar
  {0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18},
  {0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C},
  {0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E},
 
  {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08}, // define character for peak level
  {0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04},
  {0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02},
  {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
};
 
int lmax[2];    // level max memory
int dly[2];     // delay & speed for peak return

unsigned long lastT = 0;
 
void  bar(int row, int lev) {
 
    lcd.setCursor(0, row);
//   lcd.write(row ? 'F' : 'R');
 
    for(int i = 1; i < 20; i++) {
        int f = constrain(lev-i*5, 0, 5);
        int p = constrain(lmax[row]-i*5, 0, 6);
        if(f)
            lcd.write(fill[f]);
        else
            lcd.write(peak[p]);
    }
 
    if(lev > lmax[row]) {
        lmax[row] = lev;
        dly[row]  = -(T_PEAKHOLD) / T_REFRESH;      // Starting delay value. Negative=peak don’t move
    }
    else {
        if(dly[row] > 0)
            lmax[row] -= dly[row];
 
        if(lmax[row] < 0)
            lmax[row] = 0;
        else
            dly[row]++;
    }
}
 
void  setup() {
 
    byte fillbar[8] = {
    B00000,
    B01000,
    B01100,
    B01010,
    B01001,
    B01010,
    B01100,
    B01000
    };
 
    byte mark[8] = {
    B00000,
    B01010,
    B10001,
    B10101,
    B10001,
    B01010,
    B00000,
    B00000
    };

 
    lcd.begin(20, 4);           //Vorspann beginnt
 
    lcd.createChar(0, fillbar);
    lcd.createChar(1, mark);
 
    lcd.setCursor(2, 3);
    lcd.print("RF PEAK & LEVEL");
    
 
    for(int i = 0; i < 20; i++) {
        lcd.setCursor(i, 1);
        lcd.write((byte)0);
 
        delay(150);
    }                           //Vorspann beendet
 
    lcd.clear();

    lcd.setCursor(0, 0);
    lcd.write("Power  =");    //Nur Text in 0

    lcd.setCursor(0, 3);
    lcd.write("Revers =");    //Nur Text in 3
 
    for(int j = 0; j < 8; j++)
        lcd.createChar(j, block[j]);
        
}
 
void  loop() {
 
    if(millis() < lastT)
        return;
 
    lastT += T_REFRESH;
    
                                  // sqrt to have non linear scale (better was log)
    int anL = map(sqrt(analogRead(IN_LEFT)*19), 0, 128, 0, 100);
    int anR = map(sqrt(analogRead(IN_RIGHT)*19), 0, 128, 0, 100);
     
    bar(1, anL);
    bar(2, anR);
}
[/code]