Multiplexer-Board 74HC4067

Multiplexer-Board 74HC4067

Der IC 74HC4067 mit seinen 24 Pins ist ein analoger 16-kanaliger Multiplexer/Demultiplexer, der in diesem Fall der Bequemlichkeit auf eine kleine Platine aufgebracht wurde, damit man ihn leichter ins 2,54mm-Raster (z.B. für Breadboards) adaptieren kann.
Man kann ihn mit 2V bis zu 10V betrieben und somit ist er sowohl für ESP32/Raspberry Pi (3,3V) als auch für Arduino-Derivate (5V) gut geeignet, ohne dass besondere Vorkehrungen getroffen werden müssen.

Verwendete Bauteile

Anschlüsse

Anschlüsse (Pinout) des 74HC4067
Pin Nummer Funktion
Z (auch: COM oder SIG) 1 Gemeinsamer Eingang/Ausgang
Y7, Y6, Y5, Y4, Y3, Y2, Y1, Y0, Y15, Y14, Y13, Y12, Y11, Y10, Y9, Y8 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 23 Getrennte Eingänge/Ausgänge
S0, S1, S2, S3 10, 11, 14, 13 Adress-Eingänge
GND 12 Ground/0V
E (active LOW) 15 "Enable"-Eingang
VCC 24 Spannungsversorgung

Demultiplexing (Output)

In dem folgenden Schaltplan sind die 16 Ausgänge mit jeweils einer LED verbunden, um das Demultiplexing mit dem 74HC4067 zu veranschaulichen. Da immer nur an einem Ausgang gleichzeitig ein HIGH-Signal anliegen kann und damit immer nur eine der 16 LEDs leuchten wird, reicht hier ein einziger Vorwiderstand, den sich alle LED teilen.

Aufbau der Schaltung zum Demultiplexing

Durch das Demultiplexing können die vier digitalen Eingänge S0, S1, S2 und S3 auf die 16 Ausgangskanäle geschaltet werden. Dazu muss jedoch zusätzlich der Pin #1 (Z) auf VCC des Arduino gezogen werden, damit später an den Ausgängen die entsprechenden Signale anliegen.
Je nachdem, welche Signale an den vier Adress-Eingängen nun anliegen, wird jeweils einer der 16 Ausgänge geschaltet, wie folgende Wahrheitstabelle zeigt:

Wahrheitstabelle für S0-S3

1 = Signal "HIGH"
0 = Signal "LOW"
? = beliebiges Signal

Eingänge Kanal
E S3 S2 S1 S0
1 ? ? ? ? -
0 0 0 0 0 Y0
0 0 0 0 1 Y1
0 0 0 1 0 Y2
0 0 0 1 1 Y3
0 0 1 0 0 Y4
0 0 1 0 1 Y5
0 0 1 1 0 Y6
0 0 1 1 1 Y7
0 1 0 0 0 Y8
0 1 0 0 1 Y9
0 1 0 1 0 Y10
0 1 0 1 1 Y11
0 1 1 0 0 Y12
0 1 1 0 1 Y13
0 1 1 1 0 Y14
0 1 1 1 1 Y15

Sketch

Der folgende Sketch lässt nacheinander an jedem Ausgang für kurze Zeit ein HIGH-Signal anliegen und dabei leuchtet die entsprechende LED.

byte controlPins[] = {
    B00000000, B10000000, B01000000, B11000000,
    B00100000, B10100000, B01100000, B11100000,
    B00010000, B10010000, B01010000, B11010000,
    B00110000, B10110000, B01110000, B11110000
};

void setup()
{
    // set digital pin 4 to 7 as outputs
    DDRD = DDRD | B11110000;
}

void setOutput(byte index)
{
    PORTD = controlPins[index];
}

void loop()
{
    for (byte i = 0; i < 16; i++)  {
        setOutput(i);
        delay(100);
    }
}

Multiplexing (Input)

Der Aufbau ähnelt dem ersten Schaltplan, nur dass hier an jeden Ausgang (hier als Eingang genutzt) ein Schalter angeschlossen wird. Der Bequemlichkeit halber verwende ich hier sogannante DIP-Schalter, die sich auf engstem Raum auf dem Breadboard verstauen lassen. Außerdem wird Pin #1 (Z) mit einem analogen Eingang (hier A0) des Arduino Uno verbunden.

Aufbau der Schaltung zum Multiplexing
Abb.: Schaltplan zum Multiplexing
Aufbau auf dem Breadboard
Abb.: Bei Aufbau auf dem Breadboard ist mir aufgefallen, dass ich keine 8-Pin DIP-Schalter mehr vorrätig hatte und somit nur 12 der 16 Eingänge testen konnte.

Sketch

Der folgende Sketch liest alle 5000ms jeden Kanal ein, wobei hier wieder S0-S3 richtig adressiert werden müssen. Ist der Schalter an dem jeweiligen Kanal geschlossen (LOW), so wird an dem Eingang A0 des Arduino ebenfalls ein LOW gelesen. Ist der Schalter offen, so wird ein Wert weit über 100 ausgelesen.

const byte PIN_SIG = A0;
const byte CHANNEL[] = {
    B00000000, B10000000, B01000000, B11000000,
    B00100000, B10100000, B01100000, B11100000,
    B00010000, B10010000, B01010000, B11010000,
    B00110000, B10110000, B01110000, B11110000
};

void setup()
{
    // set digital pin 4 to 7 as outputs
    DDRD = DDRD | B11110000;
    Serial.begin(9600);
}

void loop()
{
    for (byte channel = 0; channel < 16; channel++) {
        Serial.print("Channel #" + String(channel) + ":\t");
        Serial.println(getSignal(channel));
    }
    Serial.println("");
    delay(5000);
}

int getSignal(byte channel)
{
    PORTD = CHANNEL[channel];
    return analogRead(PIN_SIG);
}
Ausgabe auf der seriellen Konsole
Abb.: Die gelesenen Werte werden nacheinander auf der seriellen Konsole der Arduino-IDE ausgegeben: Wird der Wert "0" angezeigt, so ist der entsprechende Schalter geschlossen.
zurück