Zum Inhalt springen
Arduino viele Potentiometer auslesen mit dem 74HC4051

Mit Arduino viele Potentiometer auslesen mit dem 74HC4051

    Bist du auch schon mal an die Grenzen des Arduino-Boards gestoßen? Besonders im Hinblick auf analoge Input-Pins wünscht man sich oft mehr Anschlussmöglichkeiten. Doch wie liest man mit Arduino viele Potentiometer gleichzeitig aus, wenn das Arduino UNO doch nur sechs analoge Pins hat? Die Antwort lautet 74HC4051!

    Leider verfügt das Arduino-Board nur über eine begrenzte Anzahl an analogen Inputs, doch mit dem Multiplexer 74HC4051 lassen sich die Inputs enorm erweitern. Ein Multiplexer kann man sich vereinfacht wie eine Telefonvermittlung vorstellen. Man gibt eine Telefonnummer an und wird mit ihr verbunden. Dort kann man sich nun z. B. nach einem analogen Wert erkundigen. Die Telefonnummer ist eine drei Bit lange Adresse, besteht also aus drei Stellen, die entweder 0 (aus) oder 1 (an) sein können. Realisiert wird das durch drei digitale Outputs, die mit dem 74HC4051 verbunden sind. Das klingt im ersten Schritt etwas verschwenderisch, aber man kann mehrere der 74HC4051 mit den gleichen drei Adresspins ansprechen.

    Der Multiplexer gibt den analogen Wert über einen Ausgangspin zurück, den man mit einem analogen Input-Pin verbinden kann. In dieser Betriebsart könnte man nun also sechs Multiplexer an jeweils einen der sechs analogen Inputs des Arduinos anschließen und somit gleichzeitig 48 analoge Inputs, z. B. Potentiometer, auslesen.


    Sieh dir jetzt meinen neuen Arduino-Videokurs an: Jetzt ansehen!


    Bauteile

    Schaltung 74HC4051

    74HC4051 mit Arduino – So liest man viele Potentiometer aus

    Sehen wir uns die Schaltung an. Ich habe sie hier auf einem Breadboard aufgebaut. Der Multiplexer wird mit 5V+ (16) und dem GND (8) versorgt, die Pins E (6) und VEE (7) sind ebenfalls mit dem GND verbunden. Die Adresspins (9,10,11) sind mit den Arduino Pins 2,3 und 4 verbunden und entweder HIGH oder LOW. Damit ergeben sich 8 unterschiedliche Adressen. Pin 3 am Chip ist der Ausgangspin, der mit dem analogen Input 0 des Arduinos verbunden wird. Hier kann man also nun nacheinander alle acht analogen Signale auslesen, die am Chip an den Pins 1,2,3,4,12,13,14 und 15 anliegen. Hier sind die acht Potentiometer angeschlossen, die jeweils mit 5V+ und GND versorgt werden. Die Reihenfolge der Pins ist übrigens vom Hardware-Layout des 74HC4051 vorgegeben und wie in der Schaltung dargestellt von 0 bis 7, die Potentiometer abbildend von links nach rechts sortiert. Hä? Das bedeutet, dass die Adresse 000 den Pin 13 abfragt, und Adresse 111 Pin 4 – das ist also ziemlich durcheinander.

    Zur Vollständigkeit hier noch mal der Pinout des Multiplexers

    Programm-Code

    Im Code werden zuerst die Adress-Pins in einem Array angelegt. Hier könnte man natürlich auch einfach drei int-Variablen verwenden.

    int addressPins[] = {2, 3, 4};

    Im Setup wird die serielle Kommunikation gestartet, dann werden die drei Adress-Pins als OUTPUT deklariert.

    void setup() {
      Serial.begin(115200);
      for (int j = 0; j <= 2; j++) {
        pinMode(addressPins[j], OUTPUT);
      }
    }

    Im Loop wird die Zählervariable i von 0 bis 7 durchgezählt. Diese Zahl wird in ihre Bits zerlegt und an den jeweiligen Adresspin (0 bis 2) ausgegeben. Der Befehl bitRead(bit-stelle, zahl) liefert ein Bit der angegebenen Stelle aus seiner Zahl zurück. Wenn j also 6 ist, wäre das in Bit-Schreibweise (binär) also 110. Die zweite Stelle der Zahl (Stelle 1, denn gezählt wird ab 0) wäre also 1. Da der Befehl digitalWrite neben HIGH und LOW auch 1 und 0 akzeptiert, kann dieses Bit also direkt genutzt werden, um den Pin an- oder auszuschalten. Nach dem Übertragen der Adresse geben wir dem Chip einen kleinen Augenblick, sich einzustellen (50µs), dann lesen wir den analogen Wert aus und senden ihn über die serielle Schnittstelle.

    void loop () {
      for (int i = 0; i <= 7; i++) {
        for (int j = 0; j <= 2; j++) {
          digitalWrite(addressPins[j], bitRead(i, j));
          delayMicroseconds(50);
        }
        Serial.print(analogRead(0)); Serial.print("\t");
      }
      Serial.println("");
    }

    Hier noch mal der Code zusammenhängend:

    int addressPins[] = {2, 3, 4};
    
    void setup() {
      Serial.begin(115200);
      for (int j = 0; j <= 2; j++) {
        pinMode(addressPins[j], OUTPUT);
      }
    }
    
    void loop () {
      for (int i = 0; i <= 7; i++) {
        for (int j = 0; j <= 2; j++) {
          digitalWrite(addressPins[j], bitRead(i, j));
          delayMicroseconds(50);
        }
        Serial.print(analogRead(0)); Serial.print("\t");
      }
      Serial.println("");
    }

    Im seriellen Monitor (Arduino IDE>Menü>Tools>Serieller Monitor) kann man nun die Werte der Potentiometer anzeigen lassen.

    Potentiometer im Seriellen Monitor

    Jetzt lassen sich mit diesem Programm relativ leicht bis zu 48 analoge Inputs auslesen. Dabei wird die aktuelle Schaltung einfach sechsmal wiederholt. Es ändert sich pro Instanz nur der analoge Input, der verwendet wird:

    Schaltung

    74HC4051 mit Arduino – So liest man sehr viele Potentiometer aus

    Code für sechs 74HC4051-Chips

    int addressPins[] = {2, 3, 4};
    
    void setup() {
      Serial.begin(115200);
      for (int j = 0; j <= 2; j++) {
        pinMode(addressPins[j], OUTPUT);
      }
    }
    
    void loop () {
      for (int i = 0; i <= 7; i++) {
        for (int j = 0; j <= 2; j++) {
          digitalWrite(addressPins[j], bitRead(i, j));
          delayMicroseconds(50);
        }
        Serial.print(analogRead(0)); Serial.print("\t");
        Serial.print(analogRead(1)); Serial.print("\t");
        Serial.print(analogRead(2)); Serial.print("\t");
        Serial.print(analogRead(3)); Serial.print("\t");
        Serial.print(analogRead(4)); Serial.print("\t");
        Serial.print(analogRead(5)); Serial.print("\t");
      }
      Serial.println("");
    }

    Noch mehr analoge Inputs auslesen!!

    Wenn man es nun so richtig übertreiben will, gibt es auch die Möglichkeit, die Multiplexer zu verschachteln. Dazu benötigt man drei weitere digitale Pins. Im Grunde nutzt man nun den ersten Multiplexer, um auszuwählen, mit welchem Multiplexer in der nächsten Hierarchieebene man sprechen will. Diesen liest man dann wie gewohnt aus.

    Schaltung

    74HC4051 mit Arduino – So liest man richtig viele Potentiometer aus

    Code (ungetestet)

    Falls du den Code in dieser Komplexität getestet hast, würde ich mich über Feedback freuen!

    int addressPins[] = {2, 3, 4, 5, 6, 7};
    
    void setup() {
      Serial.begin(115200);
      for (int j = 0; j <= 5; j++) {
        pinMode(addressPins[j], OUTPUT);
      }
    }
    
    void loop () {
      for (int k = 0; k <= 7; k++) {
        for (int l = 0; l <= 2; l++) {
          digitalWrite(addressPins[l], bitRead(k, l));
          delayMicroseconds(50);
        }
        for (int i = 0; i <= 7; i++) {
          for (int j = 0; j <= 2; j++) {
            digitalWrite(addressPins[j], bitRead(i, j));
            delayMicroseconds(50);
          }
          Serial.print(analogRead(0)); Serial.print("\t");
        }
        Serial.println("");
      }
    }

    Wenn dir das Projekt gefallen hat und du von weiteren interessanten Projekten inspiriert werden willst, sieh dir doch mal mein neues E-Book »Arduino Projekte Volume 1« an!

    • Die beliebtesten Arduino-Projekte von StartHardware
    • Inklusive Schaltplan, Beschreibung und Code
    • Arduino-Schnellstart-Kapitel
    • Kompakter Programmierkurs


    Ein Gedanke zu „Mit Arduino viele Potentiometer auslesen mit dem 74HC4051“

    1. Hallo,
      tolle Seite! Vielen Dank dafür.
      Kurzes Feedback zum letzten Sketch:
      Die Adresspins des “Verteiler-Multiplexers” sind 2,3 und 4. Die jeweils folgenden Multiplexer werden über die Pins 5, 6 und 7 angesprochen. Daher müsste hier beim digitalWrite-Befehl folgendes stehen:
      digitalWrite(adressPins[j+3], da “j” ohne die Addition in der Schleife die Werte 0 bis 2 annimmt und damit wieder die Pins 2,3 und 4 ansprechen würde.
      Ich habs nicht ausprobiert, wäre aber logisch.
      Ausserdem im Erklärungsteil des 1. Programmcodes heisst es “wenn j also 6 ist,…” – hier ist sicher i und nicht j gemeint.
      Nochmal Danke für die tolle Seite und ich hoffe, das der Kommentar nicht als Kritik ankommt.
      Viele Grüße,
      Frank

    Schreibe einen Kommentar

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

     

    Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.