Frequenzumrichter mit Schaffner-Entstörfilter


Google-Suche auf MEINE-SCHALTUNG.de :





Online Rechner

Chronik

Dauerkalender


Signale zusammenführen mit Arduino


TFT-Anzeige


Zwei analoge Signale 0-10V sollen zusammengeführt werden und ein gemeinsames neues 0-10V Ausgangssignal bilden. Solche Operationen werden oft verwendet, da viele Sensoren standardgemäß ein analoges Signal 0-10V zur Verfügung stellen. Nicht selten müssen in den Steuerungen zwecks besseren Regelergebnissen zwei oder mehrere solche Signale zusammengeführt werden.
Je nachdem, welche Aufgabe die einzelnen Signale zu erfüllen haben, müssen sie bei Zusammenführung skaliert werden.
Als Beispiel können zwei Antriebe, die nahezu synchron laufen sollen, dienen. Der Antrieb A übergibt mithilfe eines analogen Signals 0-10V seine Geschwindigkeit an Antrieb B. Beim Signalwert gleich 0V stehen die Antriebe. Beim Wert gleich 10V wird die maximale Geschwindigkeit erreicht. Das hier agierende Signal wird oft als Leitwert bezeichnet. Da der Antrieb B nicht in der Lage ist, zu jedem Zeitpunkt exakt identische Geschwindigkeit wie der Leitantrieb zu entwickeln, wird ein weiteres Signal benötigt, um die Laufungenauigkeiten auszuregeln. Durch Bildung z.B. eines Materialspeichers, kann festgestellt werden, ob der Folgeantrieb zu schnell oder zu langsam ist. Mit einem zweiten Signal, das die aktuelle Situation widerspiegelt, kann der Folgeantrieb zusätzlich verlangsamt oder beschleunigt werden. In diesem Fall werden die Signale passend skaliert. Der Leitwert bekommt z.B. eine Gewichtung von 90%, das zusätzliche Hilfssignal bekäme dann entsprechend eine Gewichtung von 10%.

Schaltplan

Schaltplan


In dem folgenden Versuch realisieren wir die Aufgabe mit einem Arduino. Die Signale werden jeweils mit einem 10V-Spannungsregler und einem Potentiometer imitiert.

Signal A: IC1 (78L10 Spannungsregler fest 10VDC) + Potentiometer P1
Signal B: IC2 (78L10 Spannungsregler fest 10VDC) + Potentiometer P2

Da die Signale für Arduino einen zu hohen Wert darstellen, Arduino kann nur mit 5V-Signalen arbeiten, werden sie mithilfe von Spannungsteiler halbiert.

Signal A: Spannungsteiler R1-R2
Signal B: Spannungsteiler R3-R4

Mit dem dritten Potentiometer P3 wird die Skalierung der Signale eingestellt. In dem Programm erfolgt dann die entsprechende Umrechnung.
Das Ergebnis wird an einen PWM-Ausgang des Arduino ausgegeben. Mit dem Signal wird ein Optokoppler, der mit einem dritten (IC3) 10V-Spannungsregler arbeitet, angesteuert. Auf diesem Weg entsteht ein drittes 0-10V Endsignal, das die Summe der beiden Eingangssignale mit der vorgegebenen Skalierung darstellt.

Programm (Sketch)

// ************************************************************************************************
// Zwei analoge Signale skalieren und zusammenführen
// Mit Arduino Mega 2560 R3, TFT LCD 320x240
// Bibliothek MCUFRIEND_kbv.h - V 2.9.9
// Arduino IDE - V 2.3.4
// ************************************************************************************************

#include <MCUFRIEND_kbv.h>                                // Bibliothek einbinden

MCUFRIEND_kbv tft;

#define BLACK   0x0000                                    // Farben Hexadezimal
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

                          // A8 - Analoger Eingang Signal A
                          // A9 - Analoger Eingang Signal B
                          // A10 - Analoger Eingang Skalierung
                          // D44 - PWM Ausgang

float Messung;                                            // Messwert am analogen Eingang
float Spannung;                                           // Endergebnis gemessene Spannung
String Ausgabe;                                           // String Variable für TFT Anzeige
                                        // Alte Anzeigewerte werden zum Löschen festgehalten
String Ausgabe_alt_A;                                     // Alter Spannungswert Signal A
String Ausgabe_alt_B;                                     // Alter Spannungswert Signal B
String Ausgabe_alt_SkalA;                                 // Alter Skalierungswert Signal A
String Ausgabe_alt_SkalB;                                 // Alter Skalierungswert Signal B
String Ausgang_alt;                                       // Alter Spannungswert Ausgang A+B
float Ausgang;                                            // Spannungswert am Ausgang

// ************************************************************************************************
void setup(void)   {                                           
  
    tft.begin(0x9341);                                    // Ausgabe Maske vorbereiten
    tft.setRotation(1);                                   // Ausrichtung
    tft.fillScreen(BLUE);                                 // Hintergrundfarbe   
    tft.setTextSize(3);                                   // Schriftgrösse
    tft.setTextColor(CYAN);                               // Textfarbe
    tft.setCursor(10, 15);                                // Neue Cursorposition
    tft.print("Signal A:      V");                        // Text "Signal A:"
    tft.setCursor(10, 45);                                // Neue Cursorposition
    tft.print("Signal B:      V");                        // Text "Signal B:"
    tft.setTextSize(2);                                   // Schriftgrösse
    tft.setCursor(95, 90);                                // Neue Cursorposition
    tft.print("Skalierung");                              // Text "Skalierung"
    tft.setTextSize(3);                                   // Schriftgrösse
    tft.setCursor(10, 120);                               // Neue Cursorposition
    tft.print("A:    % - B:    %");                       // Text
    tft.setCursor(10, 190);                               // Neue Cursorposition
    tft.print("OUT:           V");                        // Text
}

// ************************************************************************************************
void loop(void) {
                                                           
                                                          // Skalierung Signal A ermitteln --------
    Messung = analogRead(A10);                            // Analog Eingang lesen
    long Skalierung = (Messung * 100) / 1023;             // Skalierung Berechnung in %
    Ausgabe = String(Skalierung);                         // Skalierung in String umwandeln
    Anzeige (Ausgabe, Ausgabe_alt_SkalA, 50, 120, 3);     // Unterprogramm "Anzeige" aufrufen
    Ausgabe_alt_SkalA = Ausgabe;                          // Variable Ausgabe_alt_SkalA neu belegen  

                                                          // Signal A messen und anzeigen ---------
    Messung = analogRead(A8);                             // Analog Eingang lesen
    Spannung = ((Messung * 10) / 1023);                   // Berechnung der Spannung
    Ausgabe = String(Spannung, 1);                        // Spannungswert in String umwandeln
    Anzeige (Ausgabe, Ausgabe_alt_A, 180, 15, 3);         // Unterprogramm "Anzeige" aufrufen
    Ausgabe_alt_A = Ausgabe;                              // Variable Ausgabe_alt_A neu belegen

                                                          // Anteil A am Ausgang berechnen --------
    Ausgang = (Spannung * Skalierung) / 100;              // Ausgang-Wert mit Anteil A

                                                          // Signal B messen und anzeigen ---------
    Messung = analogRead(A9);                             // Analog Eingang lesen
    Spannung = ((Messung * 10) / 1023);                   // Berechnung der Spannung Signal B
    Ausgabe = String(Spannung, 1);                        // Spannungswert in String umwandeln
    Anzeige (Ausgabe, Ausgabe_alt_B, 180, 45, 3);         // Unterprogramm "Anzeige" aufrufen
    Ausgabe_alt_B = Ausgabe;                              // Variable Ausgabe_alt_B neu belegen
                                                                                                                    
                                                          // Spannung am Ausgang berechnen --------
    Ausgang = Ausgang + (Spannung * (100 - Skalierung)) / 100;
    Ausgabe = String(Ausgang,1);                          // Spannungswert in String umwandeln  
    Anzeige (Ausgabe, Ausgang_alt, 110, 170, 6);          // Unterprogramm "Anzeige" aufrufen
    Ausgang_alt = Ausgabe;                                // Variable Ausgang_alt neu belegen

                                                          // Skalierung Signal B anzeigen ---------
    Skalierung = 100 - Skalierung;                        // Berechnung der Spannung
    Ausgabe = String(Skalierung);                         // Spannungswert in String umwandeln
    Anzeige (Ausgabe, Ausgabe_alt_SkalB, 230, 120, 3);    // Unterprogramm "Anzeige" aufrufen
    Ausgabe_alt_SkalB = Ausgabe;                          // Variable Ausgabe_alt_SkalB neu belegen

                                                          // Ausgang setzen -----------------------
    float Wert = 255 - (Ausgang * 255) / 10;              // PWM-Wert berechnen (0-255)
    int PWM_Wert = Wert;
    analogWrite(44, PWM_Wert);                            // Ausgabe am Pin D44

    delay(100);                                           // Wartezeit
}

// ************************************************************************************************
void Anzeige (String Wert_Neu, String Wert_Alt, int X, int Y, int Schrift) {

    tft.setTextSize(Schrift);                             // Schriftgrösse
    int Abstand = 20;                                     // Zeichenabstand
    if (Schrift == 6) { Abstand = 30; }
    for (int i = 0; i < 4; i++) {                         // Wertausgabe erfolgt stellenweise
        int X_Pos = X + (i * Abstand);                    // X Position auf dem Display
        tft.setCursor(X_Pos, Y);                          // Koordinaten setzen
        if (Wert_Neu.charAt(i) != Wert_Alt.charAt(i)) {   // Soll der alte Wert gelöscht werden?
            tft.setTextColor(BLUE);                       // Überschreiben mit Hintergrundfarbe
            tft.print(Wert_Alt.charAt(i));                // Alten Wert schreiben
            tft.setCursor(X_Pos, Y);                      // Zurück auf die Startposition (x,y)
        }
        tft.setTextColor(YELLOW);                         // Ausgabe Farbe
        tft.print(Wert_Neu.charAt(i));                    // Neuen Wert schreiben
    }
}

// ************************************************************************************************        

         

Testschaltung

Testschaltung


Kurzvideo

Kurzvideo


Weitere Themen:


Google-Suche auf MEINE-SCHALTUNG.de :


Home Impressum Datenschutz