Raspberry Pi Pico als logisches Gatter

Logische Funktionen verarbeiten binäre Signale, indem sie zwischen zwei Zuständen unterscheiden und einen Ausgang einen definierten Zustand annimmt. Logische Funktionen gibt es als UND, ODER, NICHT, NICHT-UND, NICHT-ODER, EXKLUSIV-ODER und EXKLUSIV-NICHT-ODER.

In der Elektronik werden logische Funktionen meist mit integrierten Schaltkreisen realisiert, können aber auch diskret mit Dioden- oder Transistorschaltungen aufgebaut werden. Auf diese Weise lassen sich logische Gatter nachbilden.

Eine Alternative ist das Programmieren eines Mikrocontrollers. Wir verwenden hier beispielhaft denn Raspberry Pi Pico, den wir mit MicroPython programmieren.

Eine logische Funktion arbeitet mit Bedingungen und einem Operator, der die Eingangssignale vergleicht und je nach Ergebnis den Ausgang festlegt.
Bei einem Gatter mit zwei Eingängen A und B gibt es insgesamt 4 unterschiedliche Eingangszustände: LL, LH, HL und HH.

Übersicht

Raspberry Pi Pico als logisches UND (AND)
Raspberry Pi Pico als logisches ODER (OR)
Raspberry Pi Pico als logisches NICHT (NOT)
Raspberry Pi Pico als logisches NICHT-UND (NAND)
Raspberry Pi Pico als logisches NICHT-ODER (NOR)
Raspberry Pi Pico als logisches EXKLUSIV-ODER (XOR)
Raspberry Pi Pico als logisches EXKLUSIV-NICHT-ODER (XNOR)

Aufbau und Bauteile

Raspberry Pi Pico als logisches Gatter

GPIO-Belegung (Pinout)

Programmcode und Aufbau testen

In den folgenden Programmcodes sind die Eingänge mit einem Pulldown-Widerstand initialisiert, der den Zustand eines unbeschalteten Eingangs auf LOW (0) zieht. Erst wenn man einen Eingang mit dem Pin 3V3 OUT (Pin 36) verbindet, nimmt der Eingang den Zustand HIGH (1) an. Am einfachsten realisiert man den Zustand HIGH, in dem man den GPIO mit einem Verbindungskabel mit dem Pin 3V3 (Pin 36) verbindet.

Raspberry Pi Pico als logisches UND (AND)

Der folgende Programmcode simuliert ein logisches UND.

Eingang A: GPIO 16 (Pin 21)
Eingang B: GPIO 17 (Pin 22)
Ausgang X: Onboard-LED

Die Bedingung für das logische UND: Die LED leuchtet nur dann, wenn alle Eingänge gleichzeitig den Zustand HIGH haben.

# Bibliotheken laden
import machine
import time

# Eingänge und Ausgänge
PIN_IN_A  = 16
PIN_IN_B  = 17
PIN_OUT_X = 'LED' # GPIO 25

# Eingänge A und B
in_A = machine.Pin(PIN_IN_A, machine.Pin.IN, machine.Pin.PULL_DOWN)
in_B = machine.Pin(PIN_IN_B, machine.Pin.IN, machine.Pin.PULL_DOWN)

# Ausgang X
out_X = machine.Pin(PIN_OUT, machine.Pin.OUT, value=0)

# Hauptprogramm
while True:
    # Logisches UND
    if in_A.value() and in_B.value():
        out_X.value(1)
    else:
        out_X.value(0)
    time.sleep(0.1)

Raspberry Pi Pico als logisches ODER (OR)

Der folgende Programmcode simuliert ein logisches ODER.

Eingang A: GPIO 16 (Pin 21)
Eingang B: GPIO 17 (Pin 22)
Ausgang X: Onboard-LED

Die Bedingung für das logische ODER: Die LED leuchtet dann, wenn einer der Eingänge den Zustand HIGH hat. Sie geht aus, wenn alle Eingänge gleichzeitig den Zustand LOW haben.

# Bibliotheken laden
import machine
import time

# Eingänge und Ausgänge
PIN_IN_A  = 16
PIN_IN_B  = 17
PIN_OUT_X = 'LED'

# Eingänge A und B
in_A = machine.Pin(PIN_IN_A, machine.Pin.IN, machine.Pin.PULL_DOWN)
in_B = machine.Pin(PIN_IN_B, machine.Pin.IN, machine.Pin.PULL_DOWN)

# Ausgang X
out_X = machine.Pin(PIN_OUT, machine.Pin.OUT, value=0)

# Hauptprogramm
while True:
    # Logisches ODER
    if in_A.value() or in_B.value():
        out_X.value(1)
    else:
        out_X.value(0)
    time.sleep(0.1)

Raspberry Pi Pico als logisches NICHT (NOT)

Der folgende Programmcode simuliert ein logisches NICHT. Im Gegensatz zu allen anderen logischen Grundverknüpfungen hat das NICHT nur einen Eingang.

Eingang A: GPIO 16 (Pin 21)
Ausgang X: Onboard-LED

Die Bedingung für das logische NICHT: Die LED leuchtet dann, wenn der Eingang den Zustand LOW hat und leuchtet nicht, wenn der Eingang den Zustand HIGH hat. Der Ausgang verhält sich logisch umgekehrt zum Eingang.

# Bibliotheken laden
import machine
import time

# Eingänge und Ausgänge
PIN_IN_A  = 16
PIN_OUT_X = 'LED'

# Eingänge A und B
in_A = machine.Pin(PIN_IN_A, machine.Pin.IN, machine.Pin.PULL_DOWN)

# Ausgang X
out_X = machine.Pin(PIN_OUT, machine.Pin.OUT, value=0)

# Hauptprogramm
while True:
    # Logisches NICHT
    out_X.value(!in_A.value())
    time.sleep(0.1)

Raspberry Pi Pico als logisches NICHT-UND (NAND)

Der folgende Programmcode simuliert ein logisches NICHT-UND.

Eingang A: GPIO 16 (Pin 21)
Eingang B: GPIO 17 (Pin 22)
Ausgang X: Onboard-LED

Bedingung für das logische NICHT-UND: Die LED leuchtet, wenn mindestens einer der Eingänge LOW ist. Sie erlischt nur, wenn alle Eingänge gleichzeitig HIGH sind.

# Bibliotheken laden
import machine
import time

# Eingänge und Ausgänge
PIN_IN_A  = 16
PIN_IN_B  = 17
PIN_OUT_X = 'LED'

# Eingänge A und B
in_A = machine.Pin(PIN_IN_A, machine.Pin.IN, machine.Pin.PULL_DOWN)
in_B = machine.Pin(PIN_IN_B, machine.Pin.IN, machine.Pin.PULL_DOWN)

# Ausgang X
out_X = machine.Pin(PIN_OUT_X, machine.Pin.OUT, value=0)

# Hauptprogramm
while True:
    # Logisches NICHT-UND (NAND)
    if in_A.value() and in_B.value():
        out_X.value(0)
    else:
        out_X.value(1)
    time.sleep(0.1)

Raspberry Pi Pico als logisches NICHT-ODER (NOR)

Der folgende Programmcode simuliert ein logisches NICHT-ODER.

Eingang A: GPIO 16 (Pin 21)
Eingang B: GPIO 17 (Pin 22)
Ausgang X: Onboard-LED

Bedingung für das logische NICHT-ODER: Die LED leuchtet nur dann, wenn alle Eingänge LOW sind. Sobald mindestens ein Eingang HIGH ist, erlischt die LED.

# Bibliotheken laden
import machine
import time

# Eingänge und Ausgänge
PIN_IN_A  = 16
PIN_IN_B  = 17
PIN_OUT_X = 'LED'

# Eingänge A und B
in_A = machine.Pin(PIN_IN_A, machine.Pin.IN, machine.Pin.PULL_DOWN)
in_B = machine.Pin(PIN_IN_B, machine.Pin.IN, machine.Pin.PULL_DOWN)

# Ausgang X
out_X = machine.Pin(PIN_OUT_X, machine.Pin.OUT, value=0)

# Hauptprogramm
while True:
    # Logisches NICHT-ODER (NOR)
    if !in_A.value() and !in_B.value():
        out_X.value(1)
    else:
        out_X.value(0)
    time.sleep(0.1)

Raspberry Pi Pico als logisches EXKLUSIV-ODER (XOR)

Der folgende Programmcode simuliert ein logisches XOR bzw. exklusives ODER (Ungleichheit/Antivalenz).

Eingang A: GPIO 16 (Pin 21)
Eingang B: GPIO 17 (Pin 22)
Ausgang X: Onboard-LED

Bedingung für das logische XOR: Die LED leuchtet nur dann, wenn genau einer der beiden Eingänge den Zustand HIGH hat. Sind beide Eingänge gleich (beide HIGH oder beide LOW), ist die LED aus.

# Bibliotheken laden
import machine
import time

# Eingänge und Ausgänge
PIN_IN_A  = 16
PIN_IN_B  = 17
PIN_OUT_X = 'LED'

# Eingänge A und B
in_A = machine.Pin(PIN_IN_A, machine.Pin.IN, machine.Pin.PULL_DOWN)
in_B = machine.Pin(PIN_IN_B, machine.Pin.IN, machine.Pin.PULL_DOWN)

# Ausgang X
out_X = machine.Pin(PIN_OUT_X, machine.Pin.OUT, value=0)

# Hauptprogramm
while True:
    # Logisches XOR (Ungleichheit / Antivalenz)
    if in_A.value() != in_B.value():
        out_X.value(1)
    else:
        out_X.value(0)
    time.sleep(0.1)

Raspberry Pi Pico als logisches EXKLUSIV-NICHT-ODER (XNOR)

Der folgende Programmcode simuliert ein logisches XNOR bzw. exklusives NICHT-ODER (Gleichheit/Äquivalenz).

Eingang A: GPIO 16 (Pin 21)
Eingang B: GPIO 17 (Pin 22)
Ausgang X: Onboard-LED

Bedingung für das logische XNOR: Die LED leuchtet nur dann, wenn beide Eingänge den gleichen Zustand haben (beide HIGH oder beide LOW). Wenn die Eingänge unterschiedlich sind, ist die LED aus.

# Bibliotheken laden
import machine
import time

# Eingänge und Ausgänge
PIN_IN_A  = 16
PIN_IN_B  = 17
PIN_OUT_X = 'LED'

# Eingänge A und B
in_A = machine.Pin(PIN_IN_A, machine.Pin.IN, machine.Pin.PULL_DOWN)
in_B = machine.Pin(PIN_IN_B, machine.Pin.IN, machine.Pin.PULL_DOWN)

# Ausgang X
out_X = machine.Pin(PIN_OUT_X, machine.Pin.OUT, value=0)

# Hauptprogramm
while True:
    # Logisches XNOR (Gleichheit/Äquivalenz)
    if in_A.value() == in_B.value():
        out_X.value(1)
    else:
        out_X.value(0)
    time.sleep(0.1)

Weitere verwandte Themen:

Frag Elektronik-Kompendium.de

Hardware-nahes Programmieren mit dem Raspberry Pi Pico und MicroPython

Das Elektronik-Set Pico Edition ist ein Bauteile-Sortiment mit Anleitung zum Experimentieren und Programmieren mit MicroPython.

LED: Einschalten, ausschalten, blinken und Helligkeit steuern
Taster: Entprellen und Zustände anzeigen
LED mit Taster einschalten und ausschalten
Ampel- und Lauflicht-Steuerung
Elektronischer Würfel
Eigene Steuerungen programmieren

Elektronik-Set jetzt bestellen Online-Workshop buchen

Online-Workshop: Programmieren mit dem Raspberry Pi Pico

Gemeinsam mit anderen und unter Anleitung experimentieren? Wir bieten unterschiedliche Online-Workshops zum Raspberry Pi Pico und MicroPython an. Einführung in die Programmierung, Sensoren programmieren und kalibrieren, sowie Internet of Things und Smart Home über WLAN und MQTT.

Online-Workshop buchen

Besuchen Sie unser fast monatlich stattfindendes Online-Meeting PicoTalk und lernen Sie uns kennen. Die Teilnahme ist kostenfrei.

Termine und Newsletter-Anmeldung