3D-Druck, Raspberry PI und Schalten von Netzspannung

Heute stelle ich kurz ein Miniprojekt, das aus gegebenem Anlass enstanden ist, vor.  Zum Thema 3D-Druck mit dem Ultimaker 2 Drucker gibt es ja mittlerweile schon tonnenweise Informationen im Web. Auch die Steuerung über einen Webserver (octoprint) samt Webcameraüberwachung ist sehr gut dokumentiert und einfach zu realisieren. So haben es viele selbsternannte 3D-Drucker-Experten einfach, und können auf das umfangreiche Wissen aus dem Web zurückgreifen. An meinem Abeitsplatz im Labor ist seit kurzem auch ein Ultimaker 2+ Drucker im Einsatz und wird, da ja viele Druckaufträge oft mehrere Stunden bis zur Vollendung benötigen, per Webcam überwacht. Jetzt könnte man den Drucker unbeaufsichtigt drucken lassen und den Raum oder das Gebäude verlassen und den Fortschritt remote überwachen. Doch wenn jetzt etwas nicht nach Plan verläuft und der Druckkopf beispielsweise mit dem Druckobjekt kollidiert oder das Druckobjekt selbst nicht so gedruckt wird, wie es der Slicer vorsieht, dann kann der Drucker nicht per Remote not-abgeschaltet werden.

Da der Octoprint - Server nun aber auf einem Raspberry PI läuft, dessen GPIO Port - Pins einfach ungenutzt herumstehen :) , bieten sich diese an, ein Interface zu bauen, das im Falle des Falles die Stromversorgung des Druckers abschalten kann. Eine, in ein kleines Kunststoffgehäuse eingebaute Relaisplatine soll an die GPIOs angeschlossen werden. Die Relaiskontakte werden dann daran angeschlossene Schukosteckdosen schalten. Ich habe die Relaisplatine für vier Kanäle dimensioniert, um nicht nur den Drucker notabschalten zu können, sondern zukünftig auch ein Abluftventilator etc. damit zu schalten. Die Schaltbefehle werden dann direkt am Raspberry, über z.Bsp. Python-Scripten, oder einfach nur bash commandos ausgeführt.

Hier ist die supereinfache Schaltung für den Aufbau der Relaiskarte dargestellt:

Vom Papier zur fertigen Platine und diese dann in ein Gehäuse eingebaut und per 40poliger Stiftleiste und Flachbandkabel an den Raspberry PI angesteckt, ist im folgenden Bild zu sehen. Als Gerätebezeichung ist mir "Ultimaker Schukocontroller" eingefallen. Da die Aluminium-Frontplatte des Gehäuses wegen der Aussparung für das Flachbandkabel ohnehin in den Fräsbohrplotter musste, habe ich den Schriftzug "Ultimaker Schukocontroller" auch gleich dort verewigt. 

Die Hardware ist nun fertig und mit dem Raspberry verbunden. Als GPIO Pins habe ich, wie im Schaltplan zu erkennen, die GPIOs 08, 23, 24 und 25 verwendet. Als einfachen Test kann man die Relais jetzt über das Terminalfenster des Raspberry (entweder lokal, oder über einen Putty) ganz einfach ansteuern. Als Beispiel ist hier GPIO Pin8 angegeben:

sudo echo "08" > /sys/class/gpio/export
sudo echo "out" > /sys/class/gpio/gpio08/direction
Relais einschalten:
sudo echo "1" > /sys/class/gpio/gpio08/value
Relais ausschalten:
sudo echo "1" > /sys/class/gpio/gpio08/value

Aus der Nixie Ära, noch mehr VFD

In einem früheren Blogeintrag habe ich einen Uhrenbausatz vorgestellt, dessen Anzeigenelemente mit VFD-Röhren aufgebaut sind. Diese Vakuum-Fluoreszenz-Display Röhren stammen, wie auch die Nixieröhren, aus den 60iger, 70iger Jahren und wurden dann von den LED 7-Segment Anzeigen abgelöst. Doch der Reiz der glimmenden, in Glaskolben verpackten Leuchtziffern erobert heute wieder so manches Wohnzimmerregal. Über den damaligen Beitrag über den VFD – Uhrenabsatz von gr-projects, bin ich mit dem Konstrukteur und Hersteller dieses Bausatzes, Herrn Rother in Kontakt gekommen.  Herr Rother hat mir weitere Uhrenmodelle zur Verfügung gestellt, deren Auf- und Zusammenbau ich in Form kurzer Filme aufbereitet und dokumentiert habe. Die verwendeten Anzeigeröhren sind russische Röhren der Typen IV-11, IV-6 und IV-3.

 
IV-11:

•  Glaskolben mit einer Höhe von 55mm und einem Durchmesser von 22mm.
• Anzeigehöhe 20x13mm (HxB)
• Heizspannung 1,5V bei einem Strom von 50-70mA
• Gitterspannung ca 25-30V
• Lebensdauer ca. 5000h

IV-6:

• Glaskolben mit einer Höhe von 40mm und einem Durchmesser von 12mm.
• Anzeigehöhe 11x5mm (HxB)
• Heizspannung 0.85-1.15V bei einem Strom von 50mA
• Gitterspannung ca 25-30V
• Lebensdauer ca. 5000

Hier nun die Aufbauvideos zu den Uhrenmodellen:

Raspberry als Datenlogger - Teil.3 Arduino nano als I²C Converter

Raspberry Pi als Datenlogger

Im letzten Teil des Projektes "Raspberry Pi als Datenlogger" habe ich einen Raspberry Pi als Datenlogger für unterschiedliche Sensoren konfiguriert. Als Schnittstelle dient der I²C Bus und die RS232 Leitungen, an denen die Sensoren angeschlossen sind. Die Sensoren waren ein HYT939 (Luftfeuchtigkeit und Temperatur), ein BME280 (Luftdruck, Luftfeuchte und Temperatur) sowie ein Ultimate GPS Board an der seriellen Schnittstelle. Der Raspberry Pi ist dabei in eine Box eingebaut, wird mit einer Powerbank, die sich ebenfalls in der Box befindet, versorgt und stellt als Schnittstelle eine 8 polige RJ45 Buchse mit I²C und RS232 nach aussen zur Verfügung. An diese Buchse können dann die Sensoren angeschlossen werden.   Will man die Sensorik nun änderen, bzw. erweitern, so können einfach weitere I²C Bus - Sensoren angeschlossen werden. Es muß lediglich noch die Software (in diesem Fall Pythonscripten) angepasst werden und schon können die Daten des neuen Sensors empfangen und aufgezeichnet werden. Wie aber geht das System um, wenn der Sensor nicht über I²C spricht? Wenn zum Beispiel ein analoger Wert eingelesen werden soll? Ganz einfach: Soll die Hardware des Datenloggers nun nicht mehr modifiziert werden, so muß man einfach dafür sorgen, dass der neue Sensor, der beispielsweise analoge Spannungen ausgibt, diese an eine, nennen wir sie BlackBox weitergibt, die wiederum an ihrem Ausgang ein I²C Bussignal bereit stellt. Das kann dann wieder in das bestehende System integriert werden.

Arduino Nano als I2C Converter

Und genau diese Aufgabe erfüllt ein Microcontroller. Praktischer Weise habe ich diesmal einen Arduino Nano dazu verwendet. Der Arduino Nano mit dem Atmega 328 besitzt ja mehrere analoge und Digitale Eingänge, sowie zwei Interrupts. Über entsprechende Libraries ist einfach das I²C Bus Protokoll zu realisieren. Somit ist das geeignete Black-Box Gerät gefunden.

Der folgende Arduino Code stellt einen einfachen I²C Bus Slave dar. Die Busadresse soll beispielsweise 0x08 sein, von einer Messung haben wir den Messwert 1.3321 erhalten. Dieser Wert soll bei Anfrage an diese Busadresse gesendet werden. Das Beispiel sieht wie folgt aus:

// I2C Slave
#include
int address = 8;           //i2c busaddresse
float wert = 1.3321;       // testwert .... kommt zb aus sensorberechnung

char tmp[6];
void setup() {

Wire.begin(address);           // i2c adresse 0x08
Wire.onRequest(requestEvent);  // register event
}

void loop() {}

void requestEvent() {
dtostrf(wert,1,3,tmp);      // float "wert" in char array umwandeln
Wire.write(tmp);            // char array senden
}

Im script ist eine Funktion "dtostrf" zu sehen. Sie  wandelt den Inhalt einer Variable des Datentyps "floating point" in ein charakter Array um. Infos sind hier zu sehen. Im Python Interpretor des Raspberry können wir nun überprüfen, ob die Daten ankommen. Doch zuvor soll der gesamte Aufbau einmal schematisch dargestellt werden.

Schematische Darstellung des Systems

Sind alle Sensoren inklusive des Arduino angeschlossen, so kann das folgende Python-Script aus der Linux-Konsole des Raspberry aufgerufen werden:

# Reading data from arduino as sensor slave
# V0.1 by bihlo 09/2016

import smbus, time

bus = smbus.SMBus(1)    # Raspberry Rev. 2
address = 0x08          # Fixed default address of Arduino

# Initialize sensor to acquire measurements
#def MeasurementRequest():
# void = bus.write_quick(address)
#time.sleep(0.1)

# Read from bus
def ReadMeasurement():
void= bus.write_quick(address)

time.sleep(0.1)
# Acquire 6 byte from sensor
Readout = bus.read_i2c_block_data(address,0,6)

out=''.join(chr(i) for i in Readout) #byte array von ascii in string wandeln

print "Antwort vom Arduino: ", Readout, " ."
print "Antwort als String:  ", out

ReadMeasurement()

Partikeldetektor

Wenn der Python Interpretor jetzt keinen Fehler meldet und der Inhalt der Variable "wert" des Arduino in Ascii und im Klartext dargestellt wird, dann kann jetzt mit einem "richtigen" Messwert eines Sensors weiter gearbeitet werden.

Als Sensor soll an an den Arduino ein DSM501 Dust Sensor Module angeschlossen werden. Der DSM501A ist ein Staubsensor, der mit 5V bei einer Stromaufnahme von 90mA betrieben wird. Er erkennt Partikel ab einer durchschnittlichen Größe von 1µm bei einer Konzentration von 0 bis ca. 1.4mg pro Kubikmeter Raumluft. Laut Datenblatt und Herstellerinformationen wird die Luft im Bereich der Messkammer erhitzt, sodass eine Luftzirkulation entsteht. Die sich ständig bewegende Luft wird mit einem getakteten Lichtstrahl beleuchtet. Ein in einem Winkel zur Lichtquelle angebrachter Fotodetektor empfängt nun, im Falle dass sich Partikel im Licht befinden, dessen Streulicht. Die Intensität des Streulichtes ist von der Anzahl und Größe der Partikel abhängig und kann so erfasst werden. Als Ausgangssignal erzeugt der Sensor ein Puls/Pausensignal mit einer Periode von 100ms. Das Verhältnis von High- zu Lowtime stellt nun die Grundlage für die Berechnung der Partikelanzahl bzw. -dichte dar. Über einen Countereingang des Arduino werden die Impulse gemessen und der korrespondierende Partikelwert errechnet. Dieser Wert wird nun wie oben beschrieben als Busdatum für den I2C Bus herangezogen und bei Auslösen des Bus Events übertragen. Somit hat der Arduino die Aufgabe eines einfachen Protokollkonverters übernommen. Mit dieser Methode lassen sich alle möglichen Messwerte so aufbereiten, dass der Raspberry mit einer Schnittstelle damit umgehen kann.
Wie das im Detail funktioniert und wie der Code dazu aussieht, werde ich vielleicht später einmal posten.

Spielekonsole: Gameboy Color

Dieses mal habe ich wieder ein Stück für die Rubrik Nostalgie Technik aus meiner Altgerätesammlung ausgegraben. Ich bezeichne es zumindest als Nostalgie Technik. Den Game Boy Color. Dabei handelt es sich um eine "Handheld Spielekonsole" von dem Hersteller Nintendo. Der Game Boy Color wurde von Nintendo Ende des Jahres 1998 auf dem internationalen Markt veröffentlicht. Er ist der Nachfolger des legendären Game Boy mit dem monochromen Display. Der Game Boy Color bekam seinen Namen von seiner Eigenschaft, einen farbigen LCD-Bildschirm zu besitzen. Der Bildschirm hat auch hier, gleich wie sein Vorgänger, noch keine Hintergrundbeleuchtung.

Gleich wie der Ur-Game Boy rechnet in seinem Inneren ein 8-Bit Prozessor von Sharp (LR35902), der auf der Basis des Zilog Z80 aufgebaut ist. Der "color" wurde bis 2003 hergestellt und wiederum von seinem Nachfolger, dem Game Boy Advance ersetzt. Laut Online-Quellen sind vom Game Boy Color ca. 120 Millionen Stück verkauft worden.

Hier nun die technischen Details:

• CPU: Sharp LR35902 (8bit CPU auf Basis des Z80)
• CPU Geschwindigkeit 4MHz/8MHz (4.338 bzw. 8.338MHz)
• RAM: 32kB
• VRAM: 16kB (das Videoram ist in die CPU integriert)
• ROM: maximal 8 MB
• RAM auf dem Cartridge 128kB
• Bildschirmauflösung: 160x144 Pixel bei einer Farbtiefe von 15bit (32768)
• Gleichzeitig auf dem Bildschirm darstellbare Farben: 10, 32, 56
• Sprites: 40 max, 10 pro Zeile bei 4 Farben pro Sprite 8x8 bzw. 16x16 Pixel Spritegröße
• Tonerzeugung: 2 Rechteckgeneratoren, 1 Rauschgenerator, 1 Samplekanal
• Tonausgabe: Monolautsprecher und Stereo-Kopfhörerausgang
• Stromversorgung: 2 AA Batterien, externe Spannungsversorgung 3V 0.6W
• Steuerung: Digitalpad 8 - Way, 4 Tasten, Lautstärkeregler Aus/Ein Schiebeschalter
• Schnittstellen: Serial I/O Port mit 512kbit/s, Infrarot I/O, Partridge I/O zur Aufnahme der Spiele-ROMS
• Abmessungen: 133x75mm, 27 mm Dick

Gameboy Color Innenleben

Seitenansicht links

Rückseite

Mainboard Nahaufnahme

Nahaufnahme Bildschirm

Spielmodul (Cartridge)

Die Gameboy Spiele Cartridges sind sind auch im Gameboy Color spielbar. Die Module beherbergen einen ROM-Baustein mit dem Spiele-Code, einen SRAM-Baustein, sowie auch bei vielen Modulen eine Backup Batterie in (CR1616), die den Status des SRAM bei  stromlosem, oder ausgesteckten Modul aufrecht hält. Über den Cartridge Steckplatz lässt sich der Gameboy und Gameboy Color auch für andere Anwendungen, ausser Spielen, nutzen. Hier haben einige Entwickler und Bastler Module gebaut, mit denen der Gameboy zum Messgerät wird, die Software im Bereich Autotuning modifizieren kann, oder als programmierbare Steuerung fungiert. Es existieren hunderte Spieltitel für die Gameboy Serie. Der Boom und die Faszination der fernöstlichen Großaugen-Comics hat auch unsere Jugend erreicht und für die Epoche der 90er Jahre geprägt. So sind folgende Spieltitel auf der Liste der meist-verkauften Spiele gelandet. (Quelle: nintendo.wikia)

• Pokémon Gold und Silber
• The Legend of Zelda: Link's Awakening DX
• The Legend of Zelda: Oracle of Ages
• The Legend of Zelda: Oracle of Seasons
• Pokémon Kristall
• Pokemon Trading Card Game
• Super Mario Bros. DX
• Yu-Gi-Oh! Dark Duel Stories
• Pokémon Pinbal

tvheadend - Aufnehmen über´s Netzwerk

Diese kurze Anleitung beschreibt wie Fernsehaufnahmen, die mit dem tvheadend-Server empfangen werden, auf ein Share im Netzwerk aufgenommen werden können: (da in vielen Haushalten auch NAS Server zum Speichern der Familiendaten herumstehen, kann man sich einen USB Speicher am Raspberry sparen und auch die Fernsehsendungen auf dem gemeinsamen Speicher ablegen)

Voraussetzung:

Ein Netzwerk, in dem ein Share über ein NAS oder eine andere Netzwerkfreigabe existiert, die, wie im Beispiel hier das Sambaprotokoll  beherrscht. Nehmen wir als Beispiel an, die Netzwerkfreigabe lautet wie folgt:

//192.168.50.50/NAS/TV/record

dieser Netzwerkpfad muß von allen Clients in diesem Netz erreichbar sein. Dann haben wir die erste Bedingung erfüllt. Weiters benötigen wir einen tvheadend Server, im selben Netz (die Bedingung ist auch erfüllt, da der Anspruch, die Aufzeichnung zu konfigurieren ja aus dem tvheadend Projekt kommt ;) ). Nehmen wir an der tvheadend Server liegt auf 192.168.50.100 Dann testen wir im Browser durch Eingabe von:

http://192.168.50.100:9981

ob die tvheadend Weboberfläche erreichbar ist. Wenn ja, dann sind alle Grundbedingungen erfüllt. Jetzt muß am tvheadendserver die Konsole gestartet werden. (in diesem Fall ist der Server ein Raspberry auf dem xbian läuft)

Mit ssh xbian@192.168.50.100 in die Konsole einloggen.

das default Passwort lautet: raspberry
danach mit "nano" die folgende Datei ändern:

sudo nano /etc/fstab

dort die folgende Zeile hinzufügen:

//192.168.50.50/NAS/TV/record /home/xbian/record cifs defaults,username=name,password=pass

dann mit "CTRL"+"O" speichern und mit "CTRL"+"X" beenden. Anmerkung: Auf dem Raspberry muß der Ordner "record" im Verzeichnis /home/xbian/ angelegt sein bzw. mit mkdir record angelegt werden. Der Username bzw. das Password im obigen Eintrag bezieht sich auf das NAS, also die user/pass id mit der auf das NAS zugegriffen werden darf.

Jetzt mit sudo mount -a  die fstab neu ausführen. Jetzt in das Webinterface von tvheadend wechseln und dort bei den Aufnahmeeinstellungen bei Speicherpfad /home/xbian/record eintragen. Ab sofort landen alle Aufzeichnungen am Netzlaufwerk des NAS...

Geigerzähler - die Software

Wie vor längerer Zeit im Blog angekündigt, soll der Geigerzähler nun eine Software bekommen, die nicht nur die Pulse des Zählrohres zählt, sondern sie auch auf eine Einheit bezieht. Hierzu waren aber noch kleine Änderungen an der Hardware notwendig. (genauergesagt habe ich andere Pins des Arduino verwendet - was bedeutet: Leiterbahnen durchtrennen und mit Schaltlitzen neu verlegen). Hier eine Liste der Änderungen:

• die Leitung von Pin4 Arduino zu Pin D7 vom LCD unterbrechen
• die Leitung von Pin5 Arduino zu Pin D6 vom LCD unterbrechen
• D7 vom LCD an Pin12 vom Arduino verbinden
• D6 vom LCD an Pin13 vom Arduino verbinden
• der Zählimpuls wird von TP3 auf Arduino Pin4 geschaltet
• die Verbindung TP3 zu Arduino Pin23 wird getrennt

Daraus ergibt sich folgende I/O Port/Pin Belegung:
LCD Display:
RS - Ardunio PIN18 - Arduino  I12
EN - Arduino PIN17 - Arduino  I11
D4 - Arduino PIN11 - Arduino  I5
D5 - Arduino PIN6  - Arduino  I4
D6 - Arduino PIN13 - Arduino I7
D7 - Arduino PIN12 - Arduino  I6
Weitere Pins:
COUNT - Arduino PIN4 - Arduino I2
BUZZ - Arduino PIN14 - Arduino I9
STATUS - Arduino PIN3 - Arduino I1
SET - Arduino PIN2 - Arduino I1

Hier der Arduino Code:

 /* Geiger Vx.1 geändertes pinning  
 * Pinzuordnungen allgemein für LCD  
 * RS to IO12 (pin18)  
 * EN to IO11 (pin17)  
 * D4 to IO5 (pin11)  
 * D5 to IO4 (pin6)  
 * D6 to IO7 (pin13)  
 * D7 to IO6 (pin12)  
 * R/W to ground  
 * VSS to ground  
 * Pinzuordnungen für Counter  
 * count to IO2 (ic pin4) = INT0  
 * buzzer to IO9 (ic pin15)  
 */  
 // include libraries  
 #include <LiquidCrystal.h>  
 // interfacepins initialisieren  
 LiquidCrystal lcd(12,11,5,4,7,6);  
 // Dosiskobersionsfaktor - CPM to uSV/h  
 #define dconv 0.007 //(ca Umrechnung aus Diagramm Datenblatt des ZP1400 Zählrohrs)  
 // Konstanten Hardware I/Os  
 const int buzzerpin = 9;  
 const int geiger_input = 2;  
 const int keystat = 0;  
 const int keyset = 1;  
 // Variablen  
 long count = 0;  
 long countPerMinute = 0;  
 long timePrevious = 0;  
 long timePreviousMeassure = 0;  
 long time = 0;  
 long countPrevious = 0;  
 float radiationValue = 0.0;  
 void setup(){  
 pinMode(geiger_input, INPUT);  
 Serial.begin(19200);  
 //setup LCD und Begruessungsanzeige  
 lcd.begin(8, 2);  
 lcd.clear();  
 lcd.setCursor(0, 0);  
 lcd.print(" Geiger ");  
 lcd.setCursor(0,1);  
 lcd.print("Counter ");  
 delay(1000);  
 lcd.clear();  
 lcd.setCursor(0, 0);  
 lcd.print("V0.0 beta");  
 delay(1000);  
 lcd.clear();  
 lcd.setCursor(0,1);  
 lcd.print("ibiretro");  
 delay(500);  
 for (int i=0;i<8;i++){  
 delay(200);  
 tone(buzzerpin,i*100,100);  
 lcd.scrollDisplayLeft();  
 }  
 delay(500);  
 lcd.clear();  
 lcd.setCursor(0, 0);  
 lcd.print("CPM=");  
 lcd.setCursor(4,0);  
 lcd.print(6*count);  
 lcd.setCursor(0,1);  
 lcd.print(radiationValue);  
 attachInterrupt(0,countPulse,RISING);  
 }  
 void loop(){  
 if (millis()-timePreviousMeassure > 10000){  
 countPerMinute = 6*count;  
 radiationValue = countPerMinute*dkonv;  
 timePreviousMeassure = millis();  
 lcd.clear();  
 lcd.setCursor(0, 0);  
 lcd.print("CPM=");  
 lcd.setCursor(4,0);  
 lcd.print(countPerMinute);  
 lcd.setCursor(0,1);  
 lcd.print(radiationValue,4);  
 lcd.setCursor(6,1);  
 lcd.print(" uSv/h");  
 /* zum debuggen   
 Serial.print("cpm=");Serial.print(countPerMinute,DEC);  
 Serial.print("uSph=");Serial.println(radiationValue,4);  
 */  
 count = 0;  
 }  
 }  
 void countPulse(){  
 detachInterrupt(0);  
 count++;  
 tone(buzzerpin,1000,10);  
 while(digitalRead(2)==1){  
 }  
 attachInterrupt(0,countPulse,RISING);  
 }