Benutzer-Werkzeuge

Webseiten-Werkzeuge


schule:hardwarekiste

Hardwarekiste

Für verschiedene Projekte werden immer wieder unterschiedliche Bauteile benötigt. Eine Auswahl aus meiner Hardwarekiste habe ich auf dieser Seite zusammengestellt.

Arduino Uno

Ein Klassiker unter den Microcontrollern.

BBC micro:bit

Der micro:bit ist ein Einplatinencomputer, der mit LEDs, GPIO Pins, zwei Buttons, Bluetooth, einem Kompass und einem Lagesensor ausgestattet ist.

Er lässt sich mit dem Editor Mu oder über die Webseite in Micropython programmieren. Mit uFlash existiert eine Möglichkeit, Programme von der Kommandozeile auf den microbit zu kopieren. Diese werden dann direkt ausgeführt, sobald der microbit mit Strom versorgt wird. Eine REPL (read eval print loop) für den microbit erhält man über das Projekt microrepl.

Die Dokumentation des micro:bit zeigt schöne Beispiele und beschreibt die wichtigsten Klassen und Methoden.

Hilfestellung gibt es über eine Mailingliste, ein Forum und den IRC-Kanal #microbit im Freenet.

Bus Pirate

Das Schweizer Taschenmesser für die Analyse von Leitungen, auf denen unterschiedliche Protokolle gesprochen werden. In einem Tutorial werden verschiedene Einsatzmöglichkeiten vorgestellt.

CHIP

Ein Kleincomputer für 9$. Weitere Informationen gibt es auf der Herstellerseite. Dort ist auch eine ausführliche Anleitung zu finden.

C1602A LCD-Modul

Ein Display für diverse Anzeigen. Eine Anleitung von Adafruit beschreibt die Verwendung. Das Display enthält den Controller HD44780, über den es angesteuert wird.

DS18B20 1-Wire Temperatursensor

Der DS18B20 ist ein günstiger Temperatursensor (~1€), der seine Daten über das 1-Wire-Protokoll ausgibt.

Die drei Pins an dem Sensor müssen mit einer Spannungsversorgung und Masse beschaltet werden. Der dritte Pin wird für die Datenübertragung benötigt.

Die Beschaltung mit einem Mikrocontroller oder dem Raspberry Pi ist in der folgenden Abbildung dargestellt.

Mit Hilfe der Python-Bibliothek w1thermsensor können die Daten ausgelesen werden.

Nach der Installation mit pip install w1thermsensor kann auf den Sensor zugegriffen werden.

from w1thermsensor import W1ThermSensor
 
sensor = W1ThermSensor()
temperature_in_celsius = sensor.get_temperature()
print(temperature_in_celsius) 

ESP8266

Mehr Informationen auf der Seite ESP8266.

Game Controller

LED Matrix (5x7)

Die LEDs werden mit einem Vorwiderstand von 220 Ohm betrieben. Jede LED ist über eine Zeile und Spalte ansteuerbar. Insgesamt werden 5+7=12 GPIO für die Ansteuerung benötigt.

LM75 Temperatursensor

Der LM75 ist ein Temperatursensor, der sich auch über I²C auslesen lässt. Hierfür wird der Raspberry Pi mit Pin 5 und 3 mit SCL bzw. SDA verbunden. Der I²C-Overlay kann mit raspi-config aktiviert werden.

Zuerst wird die Adresse mit i2cdetect ermittelt.

pi@cloudberrypi ~/lm75 $ i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --         

Der Sensor meldet sich unter der Adresse 0x48. Ein einzelner Wert kann mit i2cget aus dem Register 0x00 (dort liegen die aktuellen Temperaturen) ausgelesen werden. w liest ein Wort (2 Bytes) aus.

pi@cloudberrypi ~/lm75 $ i2cget -y 1 0x48 0x00 w
0x8018

Dieser Wert muss nun in eine Temperatur umgewandelt werden. Hierzu werden die ersten beiden Bytes getauscht, die letzten 5 Bits herausgeschoben und das Ergebnis mit 0.125 malgenommen. Wir testen dies mal für den obigen Wert.

>>> 0x8018         # Die ersten Bytes tauschen
32792
>>> 0x1880
6272
>>> 0x1880 >> 5    # 5 Bits nach rechts raus schieben
196
>>> 196 * 0.125    # und mit 0.125 multiplizieren.
24.5
>>> (0x1880 >> 5) * 0.125 # Alles in einem Schritt
24.5

Es ergeben sich 24,5°C. Im Datenblatt wird der Prozess wie folgt beschrieben.

Ein kleines Python-Skript kann die Temperatur umrechnen.

import smbus    # sudo apt-get install python3-smbus                                                                                 
import time
 
iic = smbus.SMBus(1)    # initialisiert den I2C-Bus 1 (Pin 3: SDA, Pin5: SCL)                                                        
lm75 = 0x48             # Adresse des Tesmperautrsensors LM75                                                                        
 
# Ausgabe der Adresse im Dezimal und Hexadezimalformat                                                                               
print("Lese Sensor LM75 von Adresse {0} (0x{0:x})".format(lm75))
 
try:
    while True:
        rtwo = iic.read_word_data(lm75, 0x00)
                        # liest ein 16-Bit-Wort aus dem Register 0x00                                                                
        print("16 Bit-Wert gelesen  : {0} \t 0x{0:x} 0b{0:b}".format(rtwo))
 
        wort = ((rtwo << 8) & 0xFF00) + (rtwo >> 8)
                        # Vertauscht die Bytes des Wortes                                                                            
        print("16 Bit-Wert getauscht: {0} \t 0x{0:x} 0b{0:b}".format(wort))
 
        # Die letzten 5 Bits werden ignoriert und nach rechts rausgeschoben                                                          
        # Der Wert wird schließlich mit 0.125 multipliziert                                                                          
        temperatur = (wort >> 5) * 0.125
        print("Temperatur:", temperatur)
 
        # Alternative Berechnung                                                                                                     
        #temperatur = wort / pow(2, 8)                                                                                               
        #print("Temperatur:", temperatur, "°C")                                                                                      
 
        time.sleep(1)
 
except KeyboardInterrupt:
    print("Tschuess!")

Folgende Ausgabe wird erzeugt

pi@cloudberrypi ~/lm75 $ python3 temperatur.py 
Lese Sensor LM75 von Adresse 72 (0x48)
16 Bit-Wert gelesen  : 25        0x19 0b11001
16 Bit-Wert getauscht: 6400      0x1900 0b1100100000000
Temperatur: 25.0
16 Bit-Wert gelesen  : 24601     0x6019 0b110000000011001
16 Bit-Wert getauscht: 6496      0x1960 0b1100101100000
Temperatur: 25.375
16 Bit-Wert gelesen  : 49178     0xc01a 0b1100000000011010
16 Bit-Wert getauscht: 6848      0x1ac0 0b1101011000000
Temperatur: 26.75
^CTschuess!

MIDI Controller Korg nano Kontrol

Ein MIDI-Controller wird zwar primär zur Steuerung von Synthesizern und elektronischen Musikinstrumenten genutzt, kann aber auch für Bastelprojekte zum Einsatz kommen. Bei MIDI werden die Signale in Kanälen übertragen. Jede Note wird mit eine Anschlagstärke in einem Wert zwischen 0 und 127 übermittelt.

Mit der Bibliothek rtmidi lässt sich ein Device einfach auslesen.

Die Bibliothek kann z.B. mit pip installiert werden.

pip install python-rtmidi

Das folgende Script reagiert auf Aktionen am Controller und gibt den Wert aus.

class MidiInputHandler:
    def __init__(self, port):
        self.port = port
        self.vs = collections.OrderedDict()
 
    def __call__(self, event, data=None):    
        message, _ = event
        chan, note, val = message
        print("Channel", chan, "note", note, "value", val)
 
if len(sys.argv) > 1:
    port = sys.argv[1]
else:
    print("Give me an input port")
    midi.list_input_ports()
    exit(1)
 
midiin, port_name = midi.open_midiinput(port)
midiin.set_callback(MidiInputHandler(port_name))
 
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    pass
finally:
    midiin.close_port()

Weitere Beispiele befinden sich im Verzeichnis examples bei github.

MCP23017 Portexpander

Der MCP23017 ist ein Portexpander, mit dem Anzahl der verfügbaren GPIOs an einem Raspberry Pi vergrößert werden kann. Das Datenblatt des MCSP23017 beschreibt die Belegung der Pins. Er wird über einen I²C-Bus angesprochen.

Über verschiedene Registeradressen können unterschiedliche Funktionen angesteuert werden.

Wichtig sind die mit einem roten Punkt markierten Register. Für Pins aus der Bank A bzw. B stehen jeweils eigene Befehle zur Verfügung. Mit den Registern IODIRA und IODIRB können die Pins als Eingabe- oder Ausgabe-Pins konfiguriert werden (0=out, 1=in). Mit den Registern OLATA und OLATB kann auf den Pins eine Ausgabe erzeugt werden. Die Register GPIOA und GPIOB können schließlich verwendet werden, um von den Pins zu lesen.

Zugriff mit i2ctools

Um den Baustein mit dem Raspberry Pi zu verwenden, muss zunächst der I²C-Overlay aktiviert werden in den Einstellungen von raspi-config. Evt. muss mit modprobe i2c-dev noch ein Kernelmodul geladen werden.

Nun wird das Paket i2c-tools installiert, um mit i2cdetect auf den Bus zugreifen zu können.

$ i2cdetect -y 1

scannt den Bus nach verfügbaren Geräten ab. Dort sollte der Baustein auftauchen - z.B. an Adresse 0x20. Diese Adresse werden wir in den folgenden Befehlen jeweils mitsenden.

$ i2cset -y 1 0x20 0x00 0xFE

konfiguriert mit i2cset den Pin IO0 (0xFE ist binär 1111 1110) als Ausgang. Nun können wir ein Signal senden.

$ i2cset -y 1 0x20 0x14 0x01

sendet eine 1 an den Pin IO0.

$ i2cget -y 1 0x20 0x12

liest mit i2cget die Eingänge in Bank A aus. Aus dem Hexwert lässt sich dann der Status eines Pins herauslesen, wenn man den Wert als Binärtwert betrachtet.

Zugriff mit Python

Für den Zugriff mit Python wird das Paket python3-smbus benötigt.

import smbus
 
bus = smbus.SMBus(1)
adresse = 0x20
 
bus.write_byte_data(adresse, 0x00, 0xFE)
 
bus.write_byte_data(adresse, 0x14, 0x01)
 
wert = bus.read_byte_data(adresse, 0x12)

MPU6050 Beschleunigungssensor und Gyrometer

Der MPU 6050 ist ein Beschleunigungssensor und Gyrometer, der sich über I²C auslesen lässt.

Philips Hue Bridge

Die Philips Hue Bridge kann Lampen ansteuern, die das ZigBee-Protokoll sprechen - also nicht nur Produkte von Philips. Die Bibliothek phue ermöglicht die Steuerung der Bridge mit einem Python-Programm. Sie lässt sich einfach mit pip install phue installieren. Danach muss das Programm mit der Bridge „gepaired“ werden. Dies wird auf der verlinkten Webseite beschrieben. Dann kann die Lampe leicht angesteuert werden.

from phue import Bridge 
 
b = Bridge("philips-hue")
# turn it on
b.set_light(1, "on", True)
# turn if off
b.set_light(1, "on", False)
# dim it - values 0..255
b.set_light(1, "bri", 110)
# dim it with transition time (in 1/10 seconds)
b.set_light(1, "bri", 255, transitiontime=10)

PirateBox

piratebox1.jpg

Die PirateBox besteht aus einer angepassten Firmware für Router wie den TP-LINK TL-MR3020 (die Sticker sind beim Original nicht enthalten. :-)). Diese stellen ein WLAN zur Verfügung, über das auf einen Dateiserver und ein Forum, das auf dem Router läuft, zugegriffen werden kann.

Ein ähnliches Konzept verfolgt der Server Serviette, der jedoch eine leistungsfähigere Hardware voraussetzt.

Pi Zero

Der Pi Zero ist der kleine Bruder des Raspberry Pi. Es kostet mit ca. 6€ deutlich weniger als der große Bruder, hat dafür aber auch weniger Anschlüsse. Das oben abgebildete Essentials Kit wird mit einigen Adaptern geliefert, die Micro-HDMI und -USB auf größere Anschlüsse konvertieren. Mit einem Ethernet-USB-Adapter konnte ich tatsächlich via ssh auf den Pi zugreifen. Die GPIO-Leiste muss ebenfalls noch verlötet werden.

RFID

Ein RFID-Lesegerät, das die gelesene Seriennummer über die serielle Schnittstelle ausgibt.

Schrittmotor

Scrollbot

(Video bei archive.org)

Der Scrollbot ist ein Bastelset, das bei pimoroni bestellt werden kann und sich über sie python-Bibliothek scrollphathd ansteuern lässt. Es besteht aus einem Raspberry Pi Zero W und einer LED-Matrix. Eine Übersicht über die Befehle zeigt, wie sich das Modul ansteuern lässt.

SN74HC595N 8Bit Shiftregister

Ein Schieberegister, über das mehrere Werte gleichzeitig ausgegeben werden können, nachdem sie in das Register geschoben wurden.

Smartphone

Jedes Smartphone hat eine ganze Menge Sensoren, die sich über Apps anzeigen und auslesen lassen. Die App Sensor Node Free kann die Sensordaten einem MQTT-Broker übergeben. Clients, die sich dort registriert haben, können sodann auf die Ereignisse reagieren. Mit der Pro-Version können die Entwickler durch eine kleine Spende unterstützt werden.

Eine Suche nach "sensor mqtt" in Googles PlayStore liefert auch andere vergleichbare Apps zutage.

SSD1306 128x64 OLED-Display

Das Display kann über eine high-level Python-Bibliothek für den Raspberry Pi1) oder eine low-level Bibliothek für den ESP8266 angesteuert werden. Da die Displays auch von Adafruit vertrieben werden, gibt es dort eine ausführliche Anleitung.

Die Adresse auf der Rückseite des Displays zeigt zwar 0x78 an (vgl. das obige Bild), die I²C-Adresse ist jedoch 0x3C oder 0x3D. Eine Erklärung habe ich hier gefunden:

The back of the PCB shows that the 0x78 jumper has been soldered. The sheet says that the slave adress is a 7-bit code that can be either 0x3C (011-1100) or 0x3D (011-11001), based on the SAO bit (LSB of the adress). The SAO bit can be controlled by the D/C# pin of the SSD1306 (not to be confused with the D/C# bit of the control byte in the above image!). I guess, heltec must have soldered the pin to GND. Moreover, since, the OLED will always be interfaced in WRITE mode, the I2C First Byte will be the 7-bit SLA and the WRITE mode bit (0) - which becomes the byte, 0x78. Ha!

Bei Problemen mit Timeouts auf dem I²C-Bus hilft folgender Hinweis:

If you get I2C timeouts, you may need to add two 4.7 kOhm resistors, one from SDA to 3.3v, and one from SCL to 3.3v.
Quelle

Trinket Pro

Einfacher Kleincomputer für 9$. Viele Informationen liefert die Herstellerseite.

USB-Seriell Adapter

Für den Anschluss von seriellen Schnittstellen an einen USB-Port. Der Artikel Mit dem RaspberryPi über eine serielle Schnittstelle verbinden beschreibt, wie man sich mit einem Raspberry Pi über die serielle Schnittstelle verbinden kann.

WS2811 LED-Controller

LED-Leuchtstreifen, bei denen jede LED ansteuerbar ist und in verschiedenen Farben leuchten kann. Auf dem Streifen ist ein WS2811 Controller verbaut. Für die Ansteuerung kann die Bibliothek rpi_ws281x verwendet werden.

  $ git clone https://github.com/jgarff/rpi_ws281x.git

Anschließend müssen die Module kompiliert und gemäß der Beschreibung in der README installiert werden. Das Testprogramm kann mit sudo ./test ausgeführt werden und sollte die LEDs zu leuchten bringen.

Verschiedene mögliche Probleme bzgl. HDMI und Audio des Pi werden auf der Projektseite von rpi_ws281x oder in #103 beschrieben. So muss das Soundmodul snd_bcm2835 ggf. deaktiviert werden, da es mit dem PWM-Pin konkurriert. Die erfolgt duch

  $ echo "blacklist snd_bcm2835" >> /etc/modprobe.d/raspi-blacklist.conf"
  

Neben den Streifen gibt es auch Lichterketten, die den LED mehr Spielraum geben.

Über die Klasse Adafruit_NeoPixel kann die Licherkette mit Python angesteuert werden.

|---------------------------------------------------------------------------|
| Adafruit_NeoPixel                                                         |
|---------------------------------------------------------------------------|
|                                                                           |
|---------------------------------------------------------------------------|
| __init__(num, pin, freq_hz, dma, invert, brightness, channel, strip_type) |
| begin(): void                                                             |
| show(): void                                                              |
| setPixelColorRGB(n, red, green, blue, white): void                        |
| setBrightness(brightness): void                                           |
| getPixels(): LED_Data                                                     |
| numPixels(): int                                                          |
| getPixelColor(n): Color                                                   |
|---------------------------------------------------------------------------|

Mit dem folgenden kleinen Programm kann ein roter Pixel über alle LEDs einer Lichterkette geschickt werden, so dass jede LED einmal kurz leuchtet.

import neopixel
 
LED_PIN = 18 # GPIO Daten pin (muss PWM unterstüzen).
LED_FREQ_HZ = 800000 # LED Signal Frequenz in Hertz (normalerweise 800khz)
LED_DMA = 5 # DMA Kanal, um das Signal zu erzeugen (default 5)
LED_BRIGHTNESS = 255 # 0 für dunkle und 255 für helle LEDs.
LED_INVERT = False # True, um das Signal zu invertieren (NPN Transistor für 3V->5V)
 
strip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, 
                                   LED_INVERT, LED_BRIGHTNESS)
strip.begin()
 
color = neopixel.Color(255, 0, 0)
for i in range(strip.numPixels()):
    strip.setPixelColor(i, color)
    strip.show()
    time.sleep(50/1000.0)

Shard

Der Shard von Gerber ist ein Schlüsselanhänger mit nützlichen Zusatzfunktionen. Er gehört in die Kategorie der sogenannten EDC (Every Day Carry): also nützliche Dinge, die man immer dabei haben sollte.

Der Shard ist mit einem Kreuz- und zwei Schlitzschraubenziehern ausgestattet. Es kann zum Abisolieren und durch den kleinen Winkel zum Anheben oder Öffnen von Dosen oder Büchsen genutzt werden. Ein Flaschenöffner ist auch noch dabei. Die Edelstahlausführung ist mit Titan beschichtet und hält hoffentlich ein Leben lang.

In Deutschland wird das simple aber nützliche Werkzeug viel zu teuer angeboten. Als Import aus Asien kostet er nur wenige Euro.

  • Dass man einen gewöhnlichen Kopfhörer auch als universelles Elektronik-Debug-Werkzeug benutzen kann, zeigt ein Lightning-Talk der GPN.
1) Leider liegt die Bibliotheken nur für Python2 vor.
schule/hardwarekiste.txt · Zuletzt geändert: 15.06.2017 18:40 von Marco Bakera