Dauerkalender

Multifunktionszähler mit DIP-Schaltern und zwei Eingängen

Bei dieser Schaltung handelt es sich um einen Multifunktionszähler. Die Grundfunktionalität entspricht allen Zählern, die als solche im Handel angeboten werden. Es werden Impulse gezählt und sobald ein voreingestellter Sollwert erreicht wird, erfolgt eine voreingestellte Reaktion. Unser Zähler stellt zahlreiche unterschiedliche Modis, die mit Dipschaltern eingestellt werden können, zur Verfügung. Die vielen Varianten machen ihn somit über den Standard hinaus zu einem Multifunktionszähler.
Für die Parametrierung stehen in diesem Beispiel zwei DIP-Schalter-Blöcke zur Verfügung. Der Parameter DIPA-Block verfügt über sechs einzelne DIP-Schalter. Der zweite Block DIPB, mit fünf einzelnen DIP-Schaltern dient zur Vorgabe des Sollwertes.
Die Bedeutung der einzelnen DIP-Schalter in dem Parameter DIP-Block ist wie folgt festgelegt:

000000

Alle DIP-Schalter aus. Die Impulse (positive Flanke) am Zähleingang A werden gezählt und angezeigt. Zu keinem Zeitpunkt erfolgt eine Reaktion am Ausgang der Schaltung. Die Impulse am Eingang B werden nicht berücksichtigt. In diesem Modus fungiert der Zähler als ein Impulsanzeigegerät.

100000

DIP-Schalter 1 EIN. Polarität. Die Einstellung bezieht sich auf beide Impuls-Eingänge A und B. Wenn der Schalter auf OFF steht, wird jeweils die positive Flanke an beiden Eingängen gezählt (am Eingang B, sofern er aktiviert wurde). Wenn der DIP-1 auf ON steht, wird an beiden Eingängen die negative Flanke gezählt.

010000

DIP-Schalter 2 EIN. Mit der Einstellung wird der Relais-Ausgang der Schaltung aktiviert. Sobald der aktuelle Zählerstand den voreingestellten Sollwert erreicht, wird der Ausgang für 100 ms gesetzt (Impuls). Anschließend wird der Zähler genullt und beginnt mit 0 neu zu zählen.

001000

DIP-Schalter 3 EIN. STOP. Bei dieser Einstellung wird beim Erreichen des Sollwertes der Ausgang gesetzt und der Programmablauf angehalten. Zähler zählt nicht weiter. Funktionalität wird erst mit dem Reset wieder aktiviert und der Ausgang zurückgesetzt.

000100

DIP-Schalter 4 EIN. STOP. Bei dieser Einstellung wird beim Erreichen des Sollwertes der Ausgang des Zählers (Relais) getaktet. Ein- und Aus-Intervalle betragen 300 ms. Das Hauptprogramm wird angehalten. Keine weiteren Impulse werden gezählt. Der Modus wird mit dem Betätigen des Reset-Tasters beendet.

000010

DIP-Schalter 5 EIN. Mit der Einstellung wird der Impulseingang B aktiviert. Wenn keine weiteren Einstellungen vorliegen, werden die Impulse zum Hauptzähler addiert. Bei Soll reagiert der Ausgang wie davor eingestellt. Je nach Einstellung des DIP-Schalters DIP-1 werden an dem Eingang Signale mit positiver oder negativer Flanke registriert.

000001

DIP-Schalter 6 EIN. Impulseingang B wird aktiviert. Die gezählten Impulse werden von dem Zähler abgezogen. Ausgangsverhalten wie davor eingestellt.

Schaltplan

Die Schaltung verfügt über vier Taster. Taster S1 (Rot) ist ein Reset-Taster. Mit ihm kann der aktuelle Zählerstand genullt werden und die Schaltung zurückgesetzt werden.
Mit dem zweiten Taster S2 (Blau) werden die Impulse am Eingang A simuliert. Mit dem dritten Taster S3 (Gelb) werden Impulse am Eingang B simuliert. Der vierte Taster
S4 ermöglicht die Ansicht des aktuellen Sollwertes, der mit dem zweiten 5fach-DIP-Block eingestellt worden ist.
Am Pin 6 des Mikrocontrollers ist ein Relais-Modul angeschlossen. Eine rote Leuchtdiode, die über den Schließer-Kontakt des Relais geschaltet wird, visualisiert das Verhalten des Ausgangs.
Eine 4-Digit 7-Segmentanzeige zeigt den aktuellen Stand des Zählers. Mit der Betätigung des vierten Tasters S4 kann mithilfe der Anzeige der aktuell eingestellte Sollwert angezeigt werden.

Testschaltung

Programm

#include <TM1637Display.h>                                // Anzeige Bibliothek
#define CLK 13
#define DIO 12

TM1637Display display(CLK, DIO);

int DIPA [6] = {22, 23, 24, 25, 26, 27 };                  // DIP-Schalter für Parameter Einstellung
                        // DIPA [0]: Pin 22, Eingang A, Erkennung negative Flanke
                        // DIPA [1]: Pin 23, Ausgang aktiviert (Impuls 300ms), Zähler Reset
                        // DIPA [2]: Pin 24, Ausgang konstant aktiviert, Zähler Reset
                        // DIPA [3]: Pin 25, Ausgang aktiviert, Takten
                        // DIPA [4]: Pin 26, Eingang B wird aktiviert
                        // DIPA [5]: Pin 27, Subtraktion B von A
bool DIPA_ea [6];
int DIPB [5] = { 52, 51, 50, 49, 48 };                     // DIP-Schalter für Sollwert Einstellung
                        // DIPB [0]: Pin 52, Sollwert Wertigkeit 16
                        // DIPB [1]: Pin 51, Sollwert Wertigkeit 8
                        // DIPB [2]: Pin 50, Sollwert Wertigkeit 4
                        // DIPB [3]: Pin 49, Sollwert Wertigkeit 2
                        // DIPB [4]: Pin 48, Sollwert Wertigkeit 1
int Impuls_Eingang [2] = { 2, 3 };                         // Impulseingänge
int Taster_S4_Soll_Anzeige = 4;                            // Taster Soll-Anzeige aktivieren
int Relais = 6;                                            // Relais-Modul mit LED
int Zaehlerstand, Soll_Zaehlerstand, Zaehler_Anzeige;      // Zählervariablen
bool Positive_Flanke [2], Negative_Flanke [2];             // Flankenerkennung
bool Potenzial_alt [2];                                    // Hilfsvariable Flankenerkennung
int Wartezeit = 50;                                        // Prellzeit

// ************************************************************************************************
void setup() {

    for (int i=0; i<6; ++i) {                              // Parameter-Eingänge als PULLUP
        pinMode (DIPA [i], INPUT_PULLUP);
        DIPA_ea [i] = false;                       
        if (digitalRead (DIPA [i]) == LOW) {
            DIPA_ea [i] = true;
        }
    }
    for (int i=0; i<5; ++i) {                              // Sollwert-Eingänge als PULLUP
        pinMode (DIPB [i], INPUT_PULLUP);
    }                                                      // Impulseingänge mit 10k als PULLDOWN
    pinMode (Impuls_Eingang [0], INPUT);                   // Taster S2, Impulseingang A
    pinMode (Impuls_Eingang [1], INPUT);                   // Taster S3, Impulseingang B
    pinMode (Taster_S4_Soll_Anzeige, INPUT_PULLUP);        // Taster S4 für Anzeige des Sollwertes
    pinMode (Relais, OUTPUT);                              // Relais Ausgang

    byte Zahl = 0;                                         // Ermittlung des eingestellten Sollwertes
    for (int i = 0; i < 5; ++i) {
        if (digitalRead(DIPB [i]) == false) {              // DIP-Einstellungen abfragen
            Zahl |= (1 << i);                              // Bitweise ODER-Verknüpfung
        }
    }
    Soll_Zaehlerstand = Zahl;                              // Byte in Integer umwandeln
    display.setBrightness(10);
    display.clear();
}

// ************************************************************************************************
void Eingang_untersuchen (int Eingang_Nr) {
       
    Positive_Flanke [Eingang_Nr] = false;                  // Wert vorbelegen
    Negative_Flanke [Eingang_Nr] = false;                  // Wert vorbelegen
    bool Eingang = digitalRead (Impuls_Eingang [Eingang_Nr]);
    if (Eingang && !Potenzial_alt [Eingang_Nr]) {          // Erkennung Positive Flanke
        Positive_Flanke [Eingang_Nr] = true;
        Potenzial_alt [Eingang_Nr] = true;
        delay (Wartezeit);                                 // Prellzeit
    }
    if (!Eingang && Potenzial_alt [Eingang_Nr]) {          // Erkennung negative Flanke
        Negative_Flanke [Eingang_Nr] = true;
        Potenzial_alt [Eingang_Nr] = false;
        delay (Wartezeit);                                 // Prellzeit
    }
}

// ************************************************************************************************
void Zaehlerstand_anzeigen (int Anzeige_Wert) {            // Display -Anzeige
    String Ausgabe = String (Anzeige_Wert);
    display.showNumberDecEx(Ausgabe.toInt(), 0b00000000, false, 4, 4);
}

// ************************************************************************************************
void loop() {

    Eingang_untersuchen (0);                               // Eingang A untersuchen
    Eingang_untersuchen (1);                               // Eingang B untersuchen    
                                                           // Positive Flanke A auswerten 
    if (!DIPA_ea [0] && Positive_Flanke [0]) {             // positive Flanke Eingang A zählen
        ++Zaehlerstand;
        Positive_Flanke [0] = false;
    }
    if (DIPA_ea [0] && Negative_Flanke [0]) {              // negative Flanke Eingang A zählen
        ++Zaehlerstand;
        Negative_Flanke [0] = false;
    }                                                      // positive Flanke Eingang B addieren
    if (!DIPA_ea [0] && DIPA_ea [4] && !DIPA_ea [5] && Positive_Flanke [1]) {
        ++Zaehlerstand;
        Positive_Flanke [1] = false;
    }                                                      // negative Flanke Eingang B addieren
    if (DIPA_ea [0] && DIPA_ea [4] && !DIPA_ea [5] && Negative_Flanke [1]) {
        ++Zaehlerstand;
        Negative_Flanke [1] = false;
    }                                                      // positive Flanke Eingang B subtrahieren
    if (!DIPA_ea [0] && DIPA_ea [4] && DIPA_ea [5] && Positive_Flanke [1]) {
        --Zaehlerstand;
        Positive_Flanke [1] = false;
    }                                                      // negative Flanke Eingang B subtrahieren
    if (DIPA_ea [0] && DIPA_ea [4] && DIPA_ea [5] && Negative_Flanke [1]) {
        --Zaehlerstand;
        Negative_Flanke [1] = false;
    }    
    if (Zaehlerstand > 9999) {                             // Zählerstand Maximalwert prüfen
        Zaehlerstand = 9999;
    }
    if (Zaehlerstand < -999) {                             // Zählerstand Minimalwert prüfen
        Zaehlerstand = -999;
    }
    Zaehler_Anzeige = Zaehlerstand;                        // Zählerstand aktuell
    if (digitalRead(Taster_S4_Soll_Anzeige) == LOW) {
        Zaehler_Anzeige = Soll_Zaehlerstand;               // Wert für die Anzeige des Sollwertes
    } 
    Zaehlerstand_anzeigen(Zaehler_Anzeige);                // Anzeige Display aktualisieren
                                                           // Sollwert erreicht: Impuls + Weiterzählen
    if (DIPA_ea [1] && Zaehlerstand == Soll_Zaehlerstand) {  
        digitalWrite (Relais, HIGH);
        delay (100);
        digitalWrite (Relais, LOW);
        Zaehlerstand = 0;
    }                                                      // Sollwert erreicht: Ausgang EIN + Stop
    if (DIPA_ea [2] && Zaehlerstand == Soll_Zaehlerstand) {   
        while (true) {
            digitalWrite (Relais, HIGH);
        }
    }                                                      // Sollwert erreicht: Ausgang takten + Stop
    if (DIPA_ea [3] && Zaehlerstand == Soll_Zaehlerstand) {   
        while (true) {
            digitalWrite (Relais, HIGH);
            delay (300);
            digitalWrite (Relais, LOW);
            delay (300);
        }
    }     
}
// ************************************************************************************************      
        

Kurzvideo

Kurzvideo

Weitere Themen: