X-Mas 2016

Frohe Weihnachten an die Besucher des Blogs!

Jetzt sind es doch schon zwei Jahre, in denen ich den  „Technik- und Retroblog“ mit Beiträgen füttere. Wer hätte das gedacht…

Es haben sich mittlerweile auch schon ein paar Leser hier her verirrt und angefragt, ob ich das eine odere andere Gerät hier vorstellen könne. Wenn es mir möglich ist, werde ich natürlich versuchen es zu realisieren. Die Rubrik mit den Computern der 80er ist leider immer noch leer. Hier fehlt mir noch der „Faden“, wie ich das ganze aufbereiten soll – es schwebt mir auch zu jedem Gerät ein kleines Video vor, in dem die Geräte im lebendigen Zustand gezeigt werden sollen. Wenn dazu jemand Ideen hat, … gerne.

Ein großes Dankeschön möchte ich meinem Kollegen Mario Wehr aussprechen, der mir die WordPress – Umgebung zur Verfügung stellt und so excellent serviciert!

In diesem Sinn:

Frohe Weihnachten und schöne Feiertage!

 

 

Homematic Zählersensor an S0-Ausgang

Mit dem von HomeMatic angebotenen Energiezähler-Erfassungssystem kann man mit Hilfe unterschiedlicher Zählersensoren die Anzeigen- bzw. Zähleinheiten der Energieversorger ablesen und für eigene Datenerfassungssysteme aufbereiten. Dies geschieht auf unterschiedliche Weise. Es kann die Drehscheibe (Ferrarisscheibe) eines Wirbelstromzählers abgetastet werden, oder der Led-Blinkimpuls von modernen elektronischen Zählern, sowie auch mittels Reedkontakt die Zählimpulse der mechanischen Gaszähler. Dies kann alles mit dem HomeMatic Funk-Zähler Erfassungssystem HM-ES-TX-WM bewerkstelligt werden. Für die unterschiedlichen Zählertypen sind unterschiedliche Sensoren erhältlich, die alle über eine 6polige Western-Modular-Steckverbindung angeschlossen werden können. Die Sensortype wird dabei vom Funksender automatisch erkannt und stellt in seinen Softwareeinstellungen die entsprechenden Umrechnungsoptionen (Impulse/kWh, Umdrehungen/kWh, m³/kWh) dar.

Hat man jetzt zum Beispiel einen eigenen elektronischen Subzähler verbaut, so kann natürlich auch mit dem LED-Sensor die Impuls LED abgefragt werden, um so zu den Daten des Zählers zu gelangen. Die meisten elektronischen Hutschienenzähler haben aber auch einen sogenannten S0-Ausgang, der einen potentialfreien (open-collector) Ausgang über Schraubklemmen zur Verfügung stellt. Wenn man die Schaltung des LED-Sensors ein wenig geändert neu aufbaut, so kann der S0-Ausgang des Hutschienenzählers anstelle der Fotodiode angeschlossen werden. Der Sensortyp wird dann weiterhin korrekt erkannt und am Funk-Zähler Erfassungssystem angezeigt.Mit dieser Schaltung erkennt der HM-Sender den LED-Sensor. Anstelle der Fotodiode wird die Kollektor-Emitter-Strecke des Hutschienenzählers angeschlossen. Die ganze Schaltung wird auf eine kleine Platine gebracht, diese dann geätzt und bestückt.

Mehrere Platinen direkt aus dem Ätzbad… Danach erfolgt der Zuschnitt und das Beschichten mit Lötlack.

Die Platinen sind nun zugeschnitten, lackiert und können jetzt bestückt werden.

Mit Bauteilen versehen, fehlen jetzt nur mehr die Zuleitungen.

Es sind nun alle Leitungen angelötet. Zum Schutz vor Kurzschlüssen wird die Platine mit einem Schrumpfschlauch überzogen. Jetzt kann alles angeschlossen und eingebaut werden.

An den S0-Ausgang des Hutschienenzählers angeschlossen, kann es dann gleich losgehen. Im Homematic-Funksender oder in den Geräteeinstellungen der CCU2 muss nur mehr die dem Zähler entsprechende Impulsanzahl pro kWh eingestellt werden. Diese Information sind in den Datenblättern des Zählers zu finden. Sie sind aber auch fast immer direkt auf den Zählern zu finden. In diesem Fall erzeugt der Zähler 1600 Impulse/kWh.

3.2″ TFT Display an Raspberry PI

dsc_2944Der Raspberry Pi in seiner Anwendungsvielfalt wurde bisher immer als kleiner Server, oder Datenlogger, oder auch als TV-Frontend betrieben. Dabei wurde er über seinen HDMI-Ausgang an einen TV oder Monitor angeschlossen. Im Server- bzw. im Dataloggerbetrieb war kein externer Monitor notwendig. Sämtliche Einstellungen sind über die Konsole über das Netzwerk durchführbar. Will man den Raspberry aber einmal als – beispielsweise – mobiles, Akku betriebenes Gerät aufbauen, so gibt es eine Vielzahl an Anzeigenelementen und Displays. Von einfachen LC-Displays, die mehrzeilig Zeichen darstellen können, über monochrome Dot-Displays bis hin zu TFT-Farbdisplays in unterschiedlichen Größen ist hier alles erhältlich.

Ich stelle hier das 3,2 Zoll TFT 65k Farbdisplay von „joy-it.net“ vor. Das Display ist mit einem Touchscreen ausgestattet und wird über eine 26-polige Buchsenleiste direkt auf die GPIO-Pinheaderleiste des Raspberry gesteckt. Weitere Verbindungen sind nicht notwendig. Das Display hat die selben Abmessungen wie das Raspberry Pi Board und bildet so ein kompaktes, handliches PI-Paket…

dsc_2946Ist das Display aufgesteckt, und auf der SD-Karte ein Raspbian-Image mit graphischer Oberfläche installiert, dann kann es losgehen. Zur Einrichtung des Displays sind noch ein paar Schritte durchzuführen. Nach dem Einschalten wird erst einmal nur die Hintergrundbeleuchtung des Displays hell. Mehr passiert vorerst nicht. Darum verbindet man den Raspberry vorher noch einmal mit einem Monitor über HDMI oder über das Netzwerk mit einem Terminal. Hat man nun Zugriff so wird folgende Datei bearbeitet:

sudo nano /boot/config.txt

Hier sind die folgenden Zeilen am Ende einzufügen:

dtparam=spi=on
dtoverlay=waveshare32b:rotate=270

Dann die Datei speichern und den Editor wieder schließen. Jetzt die cmdline.txt bearbeiten:
sudo nano /boot/cmdline.txt

An das Ende der Zeile ist folgendes anzufügen:

fbcon=map:10

Und die Datei wieder speichern. Jetzt wird eine neue Datei erstellt:
sudo nano /usr/share/X11/xorg.conf.d/99-calibration.conf

Hier die folgenden Zeilen eintippen und die Datei wieder speichern:

Section „InputClass“
Identifier „calibration“
MatchProduct „ADS7846 Touchscreen“
Option „Calibration“ „160 3723 3896 181“ Option „SwapAxes“ „1“
EndSection

Jetzt ist noch die 99-fbturbo.conf zu editieren:

sudo nano /usr/share/X11/xorg.conf.d/99-fbturbo.conf

Hier ist in der Zeile:
Option „fbdev“ „/dev/fb0“  das fb0 in fb1 zu ändern. Das soll dann so aussehen:
Option „fbdev“ „/dev/fb1“  Und wieder speichern.

Jetzt in den tmp Ordner wechseln (cd /tmp) und folgende Datei herunterladen:
wget http://www.joy-it.net/anleitungen/rpi/tft32b/waveshare32b-overlay.dtb
und nach
sudo cp waveshare32b-overlay.dtb /boot/overlays/waveshare32b.dtbo
kopieren.

Das war´s dann schon. Mit sudo reboot und angestecktem Display dann neu starten.

dsc_2948Wenn alles geklappt hat, so sollte das Display jetzt arbeiten und der Touchscreen funktionieren.

3D-Druck: ein schneller Test und gleichzeitig praktisch

dsc_2935Einfach praktisch ist er schon, der 3D-Drucker. Ein Kunststoff-Filament bis zum flüssigen Zustand erwärmen und mit einem Drei – Achsen – Positionierer den Kunststoff schichtweise auftragen. Das ist ganz das grob beschriebene Prinzip eines 3D-Druckers.  Und mit genau so einem Drucker habe ich schlussendlich das hier beschriebene Objekt ausgedruckt. Bei dem verwendeten Drucker handelt es sich um einen Ultimaker 2+, der mit ABS-Filament mit 2.85mm Durchmesser als Druckmedium befüllt ist.

Doch vor dem Ausdrucken muss erst einmal ein Druckmodell her. Hier gibt es im Netz eine Vielfalt an fertigen herunterladbaren Modellen, die direkt gedruckt werden können. Eine Website ist hier zum Beispiel  thingiverse. Hier können die Community – Mitglieder ihre Designs und Objekte veröffentlichen und frei zugänglich machen. Doch ich wollte kein fertiges Modell nehmen, sondern den gesamten Designflow einmal von Beginn an durchmachen und testen, ob die, hier bei uns in der Arbeit verwendeten Tools auch zuverlässig funktionieren. Für dieses Testobjekt, einen Telefonaufsteller – oder „Handyhalter“ habe ich folgende Tools verwendet:

acadmodelDie 3D – Konstruktion habe ich mit AutoCad 2013 von Autodesk gezeichnet. Hier kamen einfach nur 3D Körper wie Quader und Zylinder zum Einsatz, die durch Addition, Subtraktion und extrudieren von Objekten das gewünschete Ergebnis liefern. Das fertige Objekt wird dann als Stereo-Lithografie-Datei (.stl) exportiert.

Jetzt kommt die sogenannte Slicer – Software zum Einsatz. Slicer bedeutet sinngemäß soviel wie zerscheneiden, aufscheiden. Und nichts anderes macht diese Software. Das dort geladene Druckmodell wird in Schichten zerlegt, so wie sie der Drucker später auch als Kunststoffebene schichtenweise auftägt. Auch hier gibt es einiges an open-source und freeware Software. Ich habe Cura verwendet. Dieses Slicer-Tool wird auch von Ultimaker angeboten und kann auch direkt mit deren Hardware arbeiten. Im Slicer werden dann einige Parameter festegelegt, die für den Druck dann wichtig sind. Das sind die Temperatur auf die das Filament erwärmt wird, die Plate Temperatur, die Materialvorschubgeschwindigkeit (ist abhängig von der Druckdüse und dem Material selbst), die Druckgeschwindigkeit usw. Hier sind etliche Dinge zu beachten und definieren, die schlussendlich erhebliche Auswirkung auf die Qualität, den Materialverbrauch und die Druckzeit haben…

dsc_2933
Der Ultimaker bei der Arbeit
curabild
Das Modell im Cura-Slicer

 

dsc_2937
Frisch aus dem Drucker

 

3D-Druck, Raspberry PI und Schalten von Netzspannung

dsc_2916Heute 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:

schematicgpio

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.

dsc_2918

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 „8“ > /sys/class/gpio/export
sudo echo „out“ > /sys/class/gpio/gpio8/direction

Relais einschalten:
sudo echo „1“ > /sys/class/gpio/gpio8/value

Relais ausschalten:
sudo echo „0“ > /sys/class/gpio/gpio8/value

 

 

Aus der Nixie Ära, noch mehr VFD

 

img_6297In 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 – Uhrenbausatz 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.

Hier die Infos zu den Röhren:

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

DSC_4790
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.

dsc_2872
Arduino Nano als I²C 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.

blockschaltbild
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()

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.

dsc_2873
Partikeldetektor

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

gb1Dieses 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. 50 Millionen Stück verkauft worden.

gb7

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: 160×144 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 8×8 bzw. 16×16 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
gb8
Gameboy Color Innenleben
Seitenansicht links
Seitenansicht links
Rückseite
Rückseite
Mainboard Nahaufnahme
Mainboard Nahaufnahme
Nahaufnahme Bildschirm
Nahaufnahme Bildschirm
Spielmodul (Cartridge)
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

IMAG1150Diese 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

DSC_2266Wie 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:

</pre>
/*  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);
}
<pre>