Fernsofagestell

Ein Multifunktionsmöbel. Ich wollte den Fernseher nicht immer sehen, wenn er aus ist. Darum kann man ihn nun im Gestell herunter lassen, so dass er vom Palett/Sofa verdeckt wird.

Neueste Version 2020: Ich habe das Palett rausgeschmissen, das war hässlich und zu breit und umständlich zum Bewegen (das Gestell stand im Palett drin, damit alles ein bisschen besser hält).

Nun habe ich einfach noch drei Bretter/Böden des selben Regalsystems vor die ganze Sache geschraubt. Dazwischen würde noch ein Plexiglas mit Spiegelfolie passen. Foto kommt, wenn ich eins hab. :) Hier die Fotos der Endversion, unten die Fotos des Originalaufbaus.

Und nun gehts los, also...erstmal die Originalfotos:

Teile

2 bis 3 Europallet: Neu: Schraube einfach 3 Böden von einem der Regale an die Vorderseite. Davor kannst du ein normales Sofa oder etwas anderes stellen...
1 Sofakissen in Palettgrösse: Neu: siehe oben.
2 LANDI Regale aus Holz für je c.a. 20.-, hier kann man evt. auch diese aus dem Hornbach nehmen.
1 Handwinde vom Hornbach und 3 M10 Schrauben und Muttern dazu (nicht dabei).
2mm Stahlseil
1 Scharnier in der Breite eines Brettchens der Regalbretter.
Holzschrauben (siehe Regale, solche. Und noch welche für das Scharnier)
ein paar Rollen und anderes Stahlseilbefestigungszeug (Todo)
1 (LG XYZ) Fernseher mit der Breite 75cm oder so, glaubs 82cm Diagonale..muss einfach reinpassen.
1 Backblech (hab ich gebraucht) für die Aufhängung am Fernseher.

Aufbau

--> Beim Backblech ein paar Löcher machen, damit es an die Löcher des Fernsehers passt, und anschrauben. Dabei darauf achten, dass die Anschlüsse frei bleiben.
     --> Zwei Karabiner dran machen.

Hier habe ich einfach in ein Blatt Papier die Löcher rein gedrückt und dieses dann auf das Backblech geklebt. Somit hatte ich die Löcher auf jeden Fall an der richtigen Stelle.



--> Ein Regal wird aufgebaut, und zwar mit dem obersten, zweitobersten und zweituntersten Boden
  Der Fernseher wird dann an die vorderen Beine gelehnt.

--> Der übrige Boden dieses Regals wird auseinander genommen.
--> Dann hat man vier lange Brettchen übrig (und zwei Kurze):

   Eines davon kommt seitlich unter den zweitobersten Boden an das vordere Bein. Ein Teil eines zweiten auch noch, damit die ganze Höhe ausgefüllt ist bis zum unteren Boden.

ACHTUNG: Das ist V1, mach die hintere Leiste NICHT dran, stattdessen oben noch ein Teil an die Seite!

Das dritte davon kommt auf der anderen Seite auf dieselbe Weise hin. ABER: Du musst ein Stück abschneiden und mit dem Scharnier wieder dran machen, damit du später den Fernseher rein- und rausnehmen kannst.  Dieses ist nur zum ein bisschen den Fernseher verschieben, um ihn schräg stellen zu können. Hier ist die hintere Leiste relativ egal, da oben eh nur ein Boden hinkommt. Da kannst du selbst entscheiden, was du nehmen willst (siehe unten).

Das ganze verschrauben...

Beim Teil mit dem Scharnier ein Loch von der Seite reinmachen und einen Nagel reinstecken oder so als Blockierung.

Das zweite Regal wird partiell auseinander genommen:
Ein Bein muss an das eine Brett ohne Scharnier, so dass man (wieder) kürzere Böden hinten rein machen kann. Dazu muss ein Stück oben und unten abgeschnitten werden, damit es auf den untersten Boden des ersten Regals gestellt werden kann und bis zum zweitobersten Boden kommt, und mit dem vorderen Bein und den Brettchen dazwischen eine Seitenlaufleiste für den Fernseher bildet.

Dieses Bein noch nicht verschrauben: Erst kommen die Böden an dieses Teil, dann das ganze Gestell in das erste Regal.

Zwei Beine des neuen Regals werden gleich neben den Anschlüssen des Fernsehers an das erste Regal gemacht. Das eine ist dann zwischen den ersten zwei langen Brettern der Böden von vorne gesehen und stützt den Fernseher (noch weiter) von innen. Das andere ist hinten aussen auf derselben Breite.

Nur mal angestellt...

Nun werden bei drei Böden des neuen Regals jeweils eines der langen Bretter weggeschnitten, so dass die Böden weniger breit sind und hinter den Fernseher passen.

Dann werden zwei dieser Böden noch seitlich gekürzt, und das kürzere (Haltungs-)Brettchen wieder an das Ende geschraubt, auf Breite der zwei neuen Beine, so dass die Anschlüsse des Fernsehers nicht an die Regale rankommen.

Der oberste Boden muss nicht gekürzt werden, da die Anschlüsse darunter sind, doch man kann durchaus noch ein drittes kurzes Brett ranmachen an der Position der zwei neuen Beine.

Erst das gekürzte Bein an der RICHTIGEN Stelle anmachen, dann das Ganze in das erste Regal einbauen.

Siehst du das fehlende Bein...nicht?
Das letzte Bein kann man ganz am Schluss dran machen...

Fernseher reinstellen....uuuund....

Aufhängung

Erst mal wird bei der Handwinde das fette Stahlseil heraus genommen. Dieses ist viel zu dick. Das kannst du ins Auto legen und zum Abschleppen benutzen. :) (Nein!)

Das 2mm Stahlseil wird erst am Fernseher an einen Karabiner angemacht. (Hier schon komplett)

Dann wird es gerade nach oben gezogen, dort über eine Rolle, wieder gerade herunter, über eine Rolle am Karabiner auf die andere Seite.

Die obere Rolle habe ich einfach mit einer Stahlschraube auf das oberste Brett "gelegt".

(Das Bild ist von einer anderen, schlechteren Konfiguration)

Nun wieder über eine Rolle am (anderen) Karabiner hoch und dann direkt an die Winde angemacht.

Die Winde kann einfach auf das zweitoberste Brett gelegt werden. Sie muss nicht mal angeschraubt werden zum Testen. Mit der einen Hand muss man einfach die Bremse (so ein Knubel) bedienen UND gleichzeitig noch die Winde halten und ausrichten. Das Kurbeln selber gibt fast keinen Widerstand. Die Kurbel müsste sogar noch gekürzt werden, damit es weniger anstrengend ist.

Nun drehen wir den Fernseher mal hoch und stellen die Bremse. Unter dem Fernseher habe ich noch zwei Löcher gemacht und Stahlstifte rein gesteckt. Im hinteren Brett habe ich das Loch nicht ganz durch gemacht, so dass es den Stift hält und blockiert.

Die Stahlstifte habe ich vom Schlitten eines alten DVD-Gerätes. Die sind nur 3mm dick, recht lang und sehr stabil.

Also: Stifte raus, hochkurbeln, Stifte rein, Kurbel entspannen. Umgekehrt: Stifte raus, runterkurbeln, (Stifte rein) :)

 Vordergrund-Deko :)

Neu:

Siehe oben, schraube einfach drei Böden/Bretter desselben Regalsystems vorne dran. Darauf achten, dass das Loch vom Fernseh-Reinstell-Brettchen nicht blockiert wird. (Da hatte ich Glück, hui.) Das sieht dann besser aus und ist auch einfacher zum Verschieben und macht die ganze Sache auch ein bisschen stabiler.

Zwischen Fernseher und Bretter (also "hinten") kannst du auch ein Plexiglass-Brett mit Fenster-Spiegelfolie reinschieben. Wenn der Fernseher nicht läuft, dann spiegelt das einfach, ansonsten sieht man den Fernseher hinten durch leuchten. Leider hab ich gerade kein Plexi überig.

Alt:

Nun kann man bei einem Europalett zwei der hinteren Bretter wegnehmen und die zwei mittleren Klötze dazu auch. Das komplette Regal kann nun zwischen die untersten Palettbretter gestellt werden. Der Ferseher sollte nun hinter dem Palett sein und nur die Regale sichtbar...wenn der Fernseher unten ist.

Die anderen Paletts davor legen und das Sofakissen drauf.

Comics rein. (Leider passen nichtmal die LTBs von der Höhe her rein.)

Viel Spass, mir hats jedenfalls Spass gemacht.

;) Ohne Software :)

(: Wayne intressierts? :)

Raspi Music Server Tutorial

Die Intention hierbei war, dass ich von jedem Gerät aus Musik auf der [einen] Stereoanlage abspielen kann.

Es besteht aus mehreren "Teilen":

+ Musikserver Mopidy
+ Frontend RompR
+ Mein File-Upload-Frontend.

+ Eventuell dann noch ein paar Scripts um die Dateisystemscans zu automatisieren und...so...

First things first:

System

Wir installieren erstmal das Standard Raspian auf dem Raspi:
Hier herunterladen: https://www.raspberrypi.org/downloads/raspbian/
(Es braucht nur die Lite-Version, ohne Desktop)

...und mit Etcher auf die MicroSD-Karte gebrannt:
https://www.balena.io/etcher/

So, nun stopfen wir die microSD in den Raspi und schalten den mal an (inkl. Bildschirm und Tastatur).

Login: pi
Password: raspberry (Deutsche Tastatur: raspberrz)

Erstmal richten wir die Maschine richtig ein:

sudo raspi-config

Dort dann erstmal das WLAN einrichten und eventuell SSH aktivieren. Desweiteren ändern wir das Passwort.

SSH kann man unter "Interfacing Options" einrichten.

Unter "Advanced Options" wird dann noch die Option "Expand Filesystem" ausgewählt.

Danach rebooten wir mal:

sudo reboot

Webserver

Dann machen wir ein update und installieren erstmal Apache. Die Verzeichnisse von Apache benutzen wir dann auch für die Musik.

sudo apt-get update
sudo apt-get upgrade

sudo apt-get install apache2 php

mit "ifconfig" findet man die aktuelle IP heraus. Damit mal testen...Webseite sollte auftauchen.

Dateisystem-Interface

Nun laden wir mein Filesystem-Frontend in das Apache-Webverzeichnis.

Dazu brauchen wir git:

sudo apt-get install git

cd /var/www/html
sudo git clone https://github.com/ben0bi/ben0biUploader.git

Unter [IP]/ben0biUploader ist dieser dann zu finden. Du kannst das Verzeichnis auch umbenennen.
Wir müssen hier noch einiges einstellen:

Öffne die Konfigurationsdatei mit einem Editor:

sudo nano ben0biUploader/index.php

Unkommentiere dort die zwei Zeilen unter dem SHOW-Kommentar. Diese musst du später wieder ein-kommentieren. Damit siehst du auf der Webseite den SHA1-String des Passwortes, welches du eingibst. Speichere diesen String und schreibe ihn in

ben0biUploader/config/pageconfig.json

hinein. Schreibe dort auch den richtigen Pfad unter "REAL_UPLOAD_PATH" hinein.

Dieser Pfad muss nun noch dem www-data user zugehörig gemacht werden:

sudo chown www-data:www-data /var/www/html/ben0biUploader/FILESYS

Bei nano kannst du mit Ctrl-O speichern und mit Ctrl-X beenden.

Nun solltest du mit deinem Passwort reinkommen. Kommentiere die zwei Zeilen in index.php wieder ein. Du solltest eine Datei "empty.empty" sehen. Diese dient dazu, das Verzeichnis für git "sichtbar" zu machen. Mit dieser kannst du testen, ob alles geht (rename, delete). Erstellte neue Verzeichnisse kannst du auch wieder löschen.

Nun müssen wir höchstwahrscheinlich noch ein paar PHP-Variablen ändern:

Mache in /var/www/html eine Datei phpinfo.php und schreibe folgendes hinein:

<?php
phpinfo();
?>

Wenn du diese nun im Browser aufrufst, siehst du die PHP-Variablen deines Systems.

[IP]/phpinfo.php

Die Zahl bei upload_max_filesize ist vieeel zu tief. :)
Und zusätzlich müssen wir noch post_max_size verändern. Diese Zahl sollte ein bisschen höher als die upload_max_filesize sein.

Dazu öffnen wir das php-Konfigurationsfile:
In der PhpInfo steht ganz oben auch, wo das Konfigurationsfile zu finden ist. WARNUNG: Das System selbst gibt einen falschen Pfad an mit "php --ini". Die Datei in der phpinfo ist richtig.

Darin suchen wir mit CTRL-W nach den obigen Werten und schreiben was grösseres rein:
upload_max_filesize = 120M
post_max_size = 128M

Wieder speichern mit CTRL-O und Apache neu starten:

sudo apache2ctl restart

Mopidy Musik Server

Ich halte mich hier an folgende Artikel:
https://docs.mopidy.com/en/latest/installation/raspberrypi/#how-to-for-raspbian
http://blog.scphillips.com/posts/2013/01/sound-configuration-on-raspberry-pi-with-alsa/

Ok, erstmal schalten wir den Sound auf den Audio-Jack anstatt auf HDMI. Später wird er dann noch auf die externe USB-Soundkarte geschaltet, doch erstmal den Jack:

sudo raspi-config

Hier findest du unter "Advanced Options" einen Eintrag "Audio". Wähle dort "Force 3.5mm headphone jack".

Unter "Memory Split" geben wir noch eine kleinere Zahl ein (RAM für die Graphik), damit die Musik mehr RAM hat. 16 sollte reichen, vielleicht geht es sogar mit 8.

Reboote nun die Maschine.

Mit "alsamixer" kannst du die Systemlautstärke erhöhen.

Um die Lautstäke bei jedem boot einzurichten, schreiben wir folgendes in die Datei
/etc/rc.local, und zwar VOR "exit 0"

amixer set PCM -- 100%

Mopidy installieren:
wget -q -O - https://apt.mopidy.com/mopidy.gpg | sudo apt-key add -
sudo wget -q -O /etc/apt/sources.list.d/mopidy.list https://apt.mopidy.com/stretch.list

sudo apt-get update
sudo apt-get install mopidy Nun müssen wir noch ein paar Variablen einstellen. Erstmal einfach Mopidy starten:

mopidy

Dies startet nicht nur den Server sondern legt auch die wichtigen Dateien an, welche wir noch konfigurieren müssen. Zumindest das Verzeichnis muss gesetzt werden. Also erst mal CTRL-C, um den Server zu unterbrechen, dann:

nano ~/.config/mopidy/mopidy.conf

Bzw. /etc/mopidy/mopidy.conf

Dort suchen wir die Einträge [local] und [file](?) und kommentieren das Wichtige aus:
enabled=true
media_dir = PFAD ZU DEINEM MUSIKVERZEICHNIS*


* der Pfad sollte derselbe sein, welcher für die Dateioperationen oben benutzt wird.
Also hier zum Beispiel: /var/www/html/ben0biUploader/FILESYS

Schliesslich noch für RompR weiter unten:

[mpd]
connection_timeout = 120

Nun richten wir mopidy ein, dass es beim booten startet:

sudo systemctl enable mopidy

Um den aktuellen status zu sehen, benutze:

sudo systemctl status mopidy

Andere wichtige Kommandos:
sudo systemctl start mopidy
sudo systemctl stop mopidy
sudo systemctl restart mopidy


Und vor allem:
sudo mopidyctl local scan

RompR Frontend

RompR ist das Web-Frontend für Mopidy.
https://fatg3erman.github.io/RompR/
https://fatg3erman.github.io/RompR/Installation-on-Linux-Alternative-Method

Für RompR braucht es mysql und anderes, also installieren wir das:

sudo apt-get install mysql-server mysql-client php-mysql php-curl php-gd php-json php-xml php-mbstring imagemagick

Um die datenbank besser zu administrieren installieren wir evt. noch Phpmyadmin:
sudo apt-get install phpmyadmin

Im Browser sollte nun phpmyadmin aufrufbar sein:
[IP]/phpmyadmin

Falls du nicht rein kommst, musst du noch(mal) phpmyadmin konfigurieren:

sudo dpkg-reconfigure phpmyadmin

Danach laden wir das release in das home directory:
wget https://github.com/fatg3erman/RompR/releases/download/1.23/rompr-1.23.zip

...und entzippen es:

unzip rompr-1.23.zip

Und machen schliesslich im Web-Verzeichnis einen Link darauf:

sudo ln -s /PATH/TO/ROMPR /var/www/html/rompr

und machen noch ein paar andere Sachen:

cd [rompr]
mkdir prefs
mkdir albumart
sudo chown www-data prefs
sudo chown www-data albumart

Aktiviere nun noch ein paar Apache-Module:

sudo a2enmod expires
sudo a2enmod headers
sudo a2enmod deflate
sudo a2enmod php7.0

Alles andere entnimmst du bitte dem zweiten Link oben. Da muss noch das Inet konfiguriert werden und MySql und Zeug und Sachen...

Externe USB-Soundkarte

Zu guter Letzt bauen wir noch eine externe USB-Soundkarte ein.
Der Raspi-Sound ist nämlich nicht wirklich brauchbar.

https://raspberry.tips/raspberrypi-tutorials/raspberry-pi-usb-soundkarte-unter-raspbian-einrichten

[Weiteres folgt, computer arbeitet...)

YAPS + Yet Another PC Shelf

YAPS ist kein Tischchen für den PC, YAPS ist ein Tischchen AUS PCs.

Da ein Computer immer recht lange braucht, bis er mal "da" ist, dachte ich mir, dass es mal etwas ohne komplizierte Elektronik sein sollte. Das YAPS hat deswegen "nur" eine eingbaute Lampe und einen einfahrbaren Aschenbecher.

[UPDATE: Ein YAPS mit einem wirklich laufenden PC, welchen ich ^ später gefunden habe.]
Dieses ist viel einfacher zu bauen, wenn man einen PC assemblieren "kann".

Hier musste ich nur bei der Fronthülle oben etwas weg dremeln.
Und natürlich die Löcher für die Tischplatte.

Zutaten

Dazu braucht es (obere Version):

(Tisch)
+ Ein komplettes PC-Gehäuse, bestenfalls von einem Server mit vielen Festplatten, wenn möglich mit möglichst vielen "Lüfter-Löchern" und das ganze aus Metall.
+ Eine flache ("hintere") Seitenwand eines weiteren PC-Gehäuses, wenn möglich aus Alu, mit umgefalzten Kanten für die Stabilität.
4x M3 Schrauben, und Muttern, doppelt soviele Unterlagsscheiben.
-------------------------------------------
(Licht)
+ Ein Stromkabel
+ Einen Fussdruckschalter von einer Ständerlampe
+ Eventuell eine Steckerleiste oder ähnliches. (Braucht es für den Aschenbecher)
+ Eine Lampenhalterung
+ Eine LED-Birne oder Partyleuchte, passend auf die Halterung
--------------------------------------------
(Aschenbecher)
+ Ein Handy-Ladegerät und ein USB-Kabel dafür (5v)
+ Ein paar Kabelchen (mindestens 6)
+ Ein altes DVD-Gerät für PCs, mit einem Einschub.
+ Noch ein DVD-Gerät oder etwas anderes, mit einer Hülle in der Grösse des ersten Gerätes.
+ Einen Druckknopf
+ Einen 2 Wege-Schalter mit 6 Pins (Luxus Version*)
+ Ein Stück Karton, biegbar aber fest, wenn möglich mit einer Kante im 90-Grad-Winkel als
"Federung".
+ Alufolie für um den Karton drum
+ gutes Klebeband
+ Ein bisschen Plexiglas

*Ohne Schalter muss der Einschub des DVD-Gerätes bei Strom ausfahren dann und manuell wieder eingeschoben werden.

Der Tisch

Der Tisch ist relativ einfach zu bauen:

+ Schlachte das Gehäuse komplett aus. Baue auch die Stromversorgung aus, es sollte möglichst nichts mehr drinnen sein ausser den Festplattenhalterungen.

+ Lege einfach die Seitenwand (von einem anderen Gehäuse) auf das Gehäuse, richte es ein bisschen aus, bohre 4x 3mm Löcher rein und schraube das Ganze zusammen. Tisch soweit fertig. :)

+ Ziehe das Stromkabel durch eines der PCI-Slot-Löcher oder sonst wo von aussen nach innen.
+ Lege eventuell die Steckerleiste auf den Boden des Gehäuses.
+ Montiere aussen den Fussdruckknopf an das Stromkabel oder die Steckerleiste
+ Montiere nun irgendwie die Lampenhalterung in das Gehäuse. Ich konnte oben eine Querstrebe vom "Dach" ein bisschen durch biegen und dann das Stromkabel dazwischen durch ziehen.

+ Ich habe von innen noch alle Löcher mit weissem Papier überdeckt. Dazu habe ich das Frontpanel komplett auseinander geschraubt, damit ich das Papier direkt auf das Netz machen konnte.

+ Beim Frontpanel müssen der oberste und der unterste Einschub für die grossen (5zoll) Geräte frei sein. Die Deckplatte für den untersten Einschub brauchen wir noch, die für den oberen nicht.

+ Schliesse das Gehäuse komplett und schalte die Lampe ein. Der Effekt sollte bombastisch sein. Wenn nicht, musst du die Birne noch besser ausrichten (vor allem mit Party-Effekt-Lampen), damit es schön durch die Lüfterlöcher hindurch leuchtet.

Der Aschenbecher

+ Schraube das DVD-Gerät auf.
+ Die untere Platte von der Hülle brauchen wir nicht mehr, denn die Asche fällt nach unten durch in den darunter stehenden Aschenkübel. Dazu muss das Gehäuse natürlich genug Platz haben.
+ Schlachte auch hier vorsichtig alles aus, bis nur noch der Einschub und der Motor dafür übrig ist. Natürlich sollte der Einschub noch funktionieren, doch der Rest ist egal.

Ich musste den Verschlussmechanismus ausbauen. Das Plastikteil davon musste ich an die hintere Wand machen, als Abstandshalter, damit der Einschub nicht komplett schliesst. Sonst würde das Zahnrad vom Motor nicht mehr greifen, dazu war das Verschlussteil (in dieser Phase) zuständig. Der Einschub steht nun geschlossen etwa einen Millimeter vor. Das sieht man nicht wirklich.

Auch musste ich diese Eck-Konstruktion aus Plastik weg machen weil der Karton dort nicht weiter
runterklappen konnte.

+ Löte nun zwei Kabel auf die Kontakte des Motors. Du kannst auch vorher das Board ablöten, es wird nur der Motor gebraucht.
+ Schneide das USB-Kabel durch und lege die Kabel auf der USB-Seite frei. Zwei davon sind für Daten, die anderen zwei sind für Strom. Wenn es nur zwei Kabel hat, führt das Kabel "nur" Strom.

Nun kommt die "Elektronik" dran.

+ Das USB-Kabel wird natürlich mit dem Handy-Ladegerät in der Steckerleiste betrieben.

+ Der Druckschalter kommt zwischen das USB-Kabel und den 2-Wege-Schalter. Das USB-Kabel wird in der Mitte des 2-Wege-Schalters angebracht (Pins 2 und 5). Die äusseren Pins werden auch mit Kabeln ausgerüstet, und zwar alle. Nun kann man jeweils die Kabel der äusseren Pins über Kreuz miteinander verbinden (Pin 1 mit Pin 6 und Pin 3 mit Pin 4). Die zwei daraus entstehenden Überkreuz-Kabel werden mit dem Motor verbunden.

Schalter Pins:
1 2 3
o o o
o o o
4 5 6

USB + --> Druckknopf --> SCHALTER (Pin 2) -> Geht zu Pin 1 oder 3
USB GND --> SCHALTER (Pin 5) -> Geht zu Pin 4 oder 6

Wenn nun der Schalter auf der einen Seite ist, wird der Strom nach "rechts" abgegegeben und wenn er auf der anderen Seite ist, wird der Strom nach "links" abgegeben. Somit kann man, ohne Elektronik, die Richtung des Motors und somit den Einschub steuern.

Das ist die Kleinversion eines echten Deponianischen Stromumkehrers. :)

+ Dremele den Einschub flach, es hat meist noch eine Laufleiste für den Sicherheitsmechanismus.
+ Beim "Eingang" muss man oben eventuell auch ein bisschen weg dremeln, damit die Zigaretten nicht hängen bleiben.

+ Damit die Asche nicht den Karton verbrennt, sollte er mit Alufolie umwickelt werden.

+ Der Karton muss durch die Öffnung des Gerätes geschoben werden und wird mit Klebeband am Einschub befestigt. Wenn das Gerät geschlossen ist, sollte das Ding innen herunter klappen, wenn es sich öffnet, sollte es sich wieder schliessen.

Geschlossen:
| --|
|  /|

Offen:
|  |==
|  |

+ Baue nun alles wieder zusammen und das Gerät in das PC-Gehäuse, an der obersten Stelle.
+ Bohre zwei Löcher in die Seitenwand für die "Elektronik"-Schalter.

+ Das Plexiglas sollte hinter die DVD-Einschübe um die Asche nach unten abzulenken. Ansonsten wird das gesamte Gehäuse dreckig. Du kannst natürlich auch etwas anderes nehmen, dann bringt jedoch die Lampe nicht mehr viel.
+ Die Hülle des zweiten Gerätes kommt auch in die Einschübe vom Gehäuse, und zwar unten und umgekehrt. Die Bodenplatte wird vorher weggenommen. Ich habe eine Kartonschachtel anstatt des (fehlenden) DVD-Gehäuses genommen.

Hier ist ein Filmchen mit dem Mechanismus:

Und hier noch ein Bild mit der geöffneten Asche-Schublade:

Viel Spass beim Nachbasteln. :)

Netzkaffeekasse

Es gibt ja diese Sparschweine mit eingebautem Münzzähler. Mein Ziel war es, so ein Ding im Internet verfügbar zu haben. Und es soll Fotos machen von den edlen Spendern und räuberischen Dieben. :)

Dieser Artikel hat drei grössere Kapitel:
1. Die Hardware.
2. Installation der Software
3. Funktionsweise der Software.
Übersichtlicherweise sollte man erst den RasPi vorbereiten (2.) bevor alles zusammengebaut wird.
Zur Info. Also wenn dich nur das Proggen interessiert, gleich nach zu unterst scrollen. ;)

Was braucht man:

1x Sparschwein mit elektronischem Münzzähler
1x Raspberry Pi v3 (mit WLAN) mit Raspian oder so + Strom.
1x Flachband-Kabel für den Pi (Flachstecker zu Female)
1x RasPi Kamera mit Kabel
1x Platine (oder Karton ;) ) und ein paar Pins und Widerstände (hier: 600 Ohm) zum drauf löten.
1x schatzige Truhe, wenn möglich Schatztruhe. :)
ein paar Kabel und Lüsterklemmen.

Lötkram und Dremel wären auch von Vorteil.

Zur Konfiguration brauchst du natürlich noch einen Bildschirm und eine Tastatur.

Die Software von mir findet sich auf diesem Repository:
https://github.com/ben0bi/Netzkaffeekasse

Die Installation wird weiter unten erklärt.

Die Hardware

Bitte richte dir dann erst den RasPi ein, bevor du alles zusammen baust. ;)
(Siehe unten.)

Ich habe mir also mehrere Sparschweine mit elektronischem Münzzähler im Interdiscount gekauft, um dies zu realisieren. (Du brauchst nur eines.) Also etwas in der Art hier, mit Schweizer-Zählwerk:

Dieses habe ich komplett auseinander genommen. Die Elektronik-Platine kannst du wegschmeissen, die brauchen wir nicht. Wir brauchen nur den Zähler selbst. Dabei kam raus, dass der "Zähler" nur eine kleine Platte mit Kontakten ist, auf welcher eine kleine Stange bewegt wird um den Kontakt zu geben. Die Stange wird von der Münze zur Seite gedrückt. Diese Platine wurde über ein Flachbandkabel mit der Elektronik-Platine verbunden. Also einfach das Flachband von der Elektronik-Platine ab- und an die eigene dranlöten. Total einfach, analog und ohne Probleme zu "verbasteln".

Den Münzschlitz oben habe ich aus dem Plastikdeckel herausgedremelt und in die Kiste eingebaut. Das Zählwerk selbst kann man nun einfach darunter anschrauben.

Ich habe das Flachband zu den Kontakten von der Elektronik weg- und an meine eigene Platine gelötet. Dort kommen die Kontakte (von der einen Seite) als Stift heraus und werden noch mit einem Widerstand jeweils zu GND geleitet. Die andere Seite wird an 3.3v gelegt und braucht kein GND. Bei mir hat die Strom-Seite drei (3) Kontakte auf dem Flachband. Desweiteren kommen noch vier weitere Kontakte dazu (jeweils zwei zusammen), welche den Türöffnungsmechanismus überwachen. Auch diese brauchen wir als Stift, und auch diese müssen jeweils noch mit einen Widerstand mit GND verbunden werden. Mehr braucht es auf "unserer" Platine jedoch nicht.

Nun wird das ganze per Flachband an ein Raspberry Pi (RasPi) Version 3 angeschlossen. Hierbei bitte darauf achten, dass 3.3v und GND richtig belegt sind. Die anderen (GPIO-Inputs) kann man dann in der Software anpassen.

Zusammengesetzt sieht die Elektronik dann etwa so aus:

Ich bin gerade zu faul, das noch mal auseinander zu nehmen. Da werden wirklich nur die Leitungen an das RasPi weiter gegeben, mehr ist da nicht ausser den Widerständen für GND jeweils.

Die grünen und roten Kabel kommen vom Türkontrollmechanismus. Dieser besteht einfach aus Kontakten, welche Strom führen, wenn die Tür zu ist.

Ein RasPi V3 brauchen wir, damit wir über WLAN Zugriff auf das (im Inneren der Kasse versteckte) Computerchen zu bekommen, ohne dass jemand einfach das Kabel durchschneiden könnte. Später wird eventuell noch eine Notfallbatterie eingebaut, damit man auch nicht einfach den Strom ausstecken kann.

Schliesslich habe ich den Münzzähler angeschraubt:

...und die Platine daneben angeklebt. Den Raspi habe ich mit einer Schraube befestigt:

Hier musste ich darauf achten, dass der Kamera-Port möglichst nah am "Türschlitz" ist. Schliesslich konnte ich einfach das Kamerakabel dazwischen durch schieben:

Zu der Kamera gab es noch eine Halterung. Diese kann man mit einem Cinch-Stecker verbinden.
Dazu habe ich aus einer beliebigen Stereoanlage alles ausgebaut, bis ich die Cinch-Stecker herausdremeln konnte:

Cinch-Stecker unten rechts...

...einfach so richtig brutal heraus gedremelt.

Achtung, das hat ziemlich gestunken und könnte giftig sein. Ich war im Keller und musste ein bisschen raus danach...

Hier solltest du einfach darauf achten, dass du das Ding auch irgendwie befestigen kannst. Bei mir hat es zwei Löcher für die Schrauben.

Schliesslich habe ich das Loch in die Truhe gedremelt. Es ist ein ganz klein bisschen breiter als gewünscht, damit das Stromkabel (und evt. HDMI) noch durch passt. Die Kabel muss man vor der Installation durchschieben, danach geht es nicht mehr.

Nachdem die Kamera befestigt wurde, ist die Hardware soweit fertig.

Die Software

Auf dem Pi brauchen wir nun folgendes:

0. Python (Version 3) und die RPi.GPIO und picamera-Bibliotheken.
Für RPi.GPIO gibt es folgende Befehle:
sudo apt-get install python{,3}-pip
sudo pip3 install RPi.GPIO

und für picamera:
sudo apt-get install python3-picamera

(Ich hoffe das ist richtig, ansonsten steht es noch im Sourcecode.)

1. Den Apache Webserver mit PHP5
sudo apt-get install apache2 php5

1.1 Das Web-Verzeichnis sollte /var/www/html sein oder in der Software unten
umgestellt werden.

2. Git brauchen wir, um die Software herunter zu laden:
sudo apt-get install git

3.  Screen brauchen wir, damit das Ganze im Hintergrund laufen kann:
sudo apt-get install screen

4. In /home/pi/Documents laden wir die Sofware herunter:
git clone https://github.com/ben0bi/Netzkaffeekasse.git

5. Nun wird die Software installiert:
cd /home/pi/Documents/Netzkaffeekasse
sudo ./install.sh
Damit werden eigentlich nur ein paar Dateien an die richtige Stelle kopiert.

Falls du Probleme mit den Berechtigungen der Dateien/Ordner hast, kannst du folgendes tun:
sudo chmod 777 dateiname gibt dateiname alle Rechte.
sudo chmod +x dateiname macht dateiname ausführbar.

6. Schliesslich stellen wir ein, dass das Ganze beim booten gestartet wird:
sudo nano /etc/rc.local

Und dort drin dann:

cd /home/pi/Documents/Netzkaffeekasse
sudo ./startbackground.sh

Diese Datei nun mit Ctrl-O speichern und mit Ctrl-X wieder in die Konsole zurück gehen. In der Software (RasPython/kassenkontroller.py) solltest du nun noch überprüfen, ob alle Pins richtig gelegt wurden und eventuell die Nummern anpassen bei den fX, rX und kontrollerX-Variablen.

frGND ist nicht GND sondern der Kontakt welcher im Ruhezustand gegeben wird (also wenn keine Münze im Schlitz ist)!

7. Nun müsstest du noch mit der Raspi-Config das WLAN einstellen.
sudo raspi-config
..und dort dann im Menü herumwuseln.

Mit ifconfig bekommst du die IP-Adresse deines RasPi heraus. Bitte stelle diese fest ein, denn mit dynamischer IP müsstest du jedesmal im Router nachgucken, da ja schliesslich am Ende kein Bildschirm mehr direkt am RasPi hängt*.

Nun sollte es laufen. Über die IP-Adresse sollte man nun eine Webseite sehen, welche das Total, Log und neueste Foto ausgibt.

*Autoboot mit Bildschirm

Um den Leuten auch ein bisschen Zucker zu geben, habe ich auch einen Bildschirm angehängt.

Damit der RasPi in den Desktop bootet, muss man in der raspi-config die Bootoption einstellen auf:

Boot into desktop with autologin.

Wenn du RetroPie benutzt, musst du das über retropie-setup machen, da er sonst zwar in den Desktop bootet, danach aber gleich die Emulationstation startet.

Hier findest du Informationen dazu, wie man Chromium direkt starten kann. Für die Netzkaffeekasse muss er natürlich auf localhost zeigen:

https://raspberrypi.stackexchange.com/questions/38515/auto-start-chromium-on-raspbian-jessie-11-2015

Damit der Bildschirm nicht nach einer Weile aus geht, habe ich xscreensaver installiert und dort dann alles ausgeschaltet:

sudo apt-get install xscreensaver

Damit sollte nun wirklich alles wie auf dem Foto oben funktionieren.

Funktionsweise der Software

Mit install.sh werden die start.sh, startbackground.sh und stop.sh ins Root-Verzeichnis (der Software) kopiert sowie die Ordner ALERT_IMAGES und EINWURF_IMAGES erstellt. Die Dateien von RasPython/html werden nach /var/www/html kopiert und dort noch der Ordner IMAGES erstellt.

stop.sh ist nur für den Zugriff auf den Screen, welcher mit startbackground.sh erstellt wird, konzipiert.
Beenden kann man die Software jeweils mit Ctrl-C.

Der Hauptbestandteil ist natürlich das Python-Script RasPython/kassenkontroller.py. Dieses macht ein Foto bei jedem Einwurf einer Münze sowie wenn man den Deckel öffnet. Dazu werden auch noch verschiedene *.nkk-Dateien angelegt.

TOTAL.nkk: Hier ist das aktuelle Total der Münzen in der Truhe angegeben.
LOG.nkk: Hier wird fein säuberlich jede Aktion hineingeschrieben.
ACTUALTEXT.nkk: Das ist der Text, der beim aktuellen Bild auf der Webseite angezeigt wird.
ACTUALTIMESTAMP.nkk: Dieser Zeitstempel wird benutzt, um das Bild auf der Webseite vom Server neu zu laden (anstatt vom Cache).

Jedes Bild wird entweder im Ordner EINWURF_IMAGES oder im Ordner ALERT_IMAGES abgelegt. Das jeweils neueste Bild wird auch noch in das /var/www/html/IMAGES-Verzeichnis kopiert als "latest.jpg" und dort von der Webseite geladen.

Das Script ist auf Schweizer Münzen ausgelegt, das heisst, die 50-Rappen Münze ist kleiner als die 10-Rappen Münze. Deshalb wird diese als 0.07 angegeben und später (weiter oben) wieder in 0.5 umgewandelt. Hier gilt nämlich, dass jeweils die grössere Nummer genommen wird wenn mehrere Kontakte gegeben werden.

Hier ist als Beispiel der Ablauf der Kontakte auf der Platine, wenn man ein 20 Rappen Stück einwirft:

GND -> 0.05 -> 0.07 -> 0.1 -> 0.2 -> 0.1 -> 0.07 -> 0.05 -> GND: Ah, es ist ein 20Rappen Stück.

Bei 0.07 wäre es ein 50Rappen Stück. Alle anderen Werte kann man direkt übernehmen.

Ich hoffe dieses Projekt hat dir gefallen und danke für die Aufmerksamkeit.

DIY: Emulator: TextGraphic Setup

Nun gut, das mit der Emulatorik wird wohl hinten angestellt, aber ich hoffe, ich kann trotzdem ein bisschen Wissen vermitteln mit meiner Serie hier.

Ok, nachdem wir nun eine sehr komplizierte Methode in dieser Serie kennengelernt haben, versuche ich nun eine einfachere Version zu generieren, welche den Bildschirm mit Text aufbaut. Ich hoffe, das ist dann auch schneller, wir werden sehen.

Vielleicht mache ich dies später auch mit WebGL direkt, doch erst muss ich herausfinden, wie man die verdammten Pixel auf einer Textur direkt bearbeiten kann. Das von vorher ^ kanns ja nicht wirklich sein. Also....

Kurz: Es ist zu langsam. Hier ist der Code:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>Emulator TextGraphic</title>

<style>
#canvas
{
font-size: 4pt;
}
#blocker
{
position: absolute;
top: 0px;
left: 0px;
background-color: rgba(1,1,1,0.01);
width: 100%;
height: 100%;
z-index: 10;
}
</style>

</head>

<body>
<div id="canvas"></div>
<div id="blocker"></div>
<script src="https://code.jquery.com/jquery-3.2.1.min.js" integrity="sha256-hwg4gsxgFZhOsEEamdOYGBf13FyQuiTwlAQgxVSNgt4=" crossorigin="anonymous"></script>

<script>

var RGB = function(red, green, blue) {return ((red << 16) & 0xFF0000) | ((green<<8) & 0x00FF00) | (blue & 0x0000FF);}
var RED = function(color) {return (color>>16) & 0x0000FF;}
var GREEN = function(color) {return (color>>8) & 0x0000FF;}
var BLUE = function(color) {return color & 0x0000FF;}
var HEXT = function(value) {return '#'+value.toString(16);}; // return hex string of a value with preceding #.

var c_Screen = function(xsize, ysize)
{
var blockChar='&#9600';
if(xsize<=0)
xsize=1;
if(ysize<=0)
ysize=1;

// ysize must be dividable by 2 because of the block chars.
if(ysize%2==1)
ysize+=1;

var m_width = xsize;
var m_height = ysize;
var m_screenArray = new Array();

// create a randomly coloured screen.
this.randomScreen = function()
{
m_screenArray = new Array();
for(var i=0;i<m_width*m_height;i++)
{
m_screenArray.push(RGB(Math.random()*255, Math.random()*255, Math.random()*255));
}
}
// initialize with a random screen.
this.randomScreen();

this.setPixel = function(x,y,color) {m_screenArray[x*y+x]=color;}

// build the html text from the screen array.
this.buildText=function()
{
var txt='<nobr>';
for(var y=0;y<m_height;y+=2)
{
for(var x=0;x<m_width;x++)
{
var color=HEXT(m_screenArray[x*y+x]);
var subcolor=HEXT(m_screenArray[x*(y+1)+x]);
txt+='<span style="color:'+color+'; background-color:'+subcolor+';">'+blockChar+'</span>';
}
txt+='<br />';
}
txt+='</nobr>';
return txt;
}
}

var done=false;
var scr = new c_Screen(160,160);

function loop()
{
scr.randomScreen();
var txt = scr.buildText();
$('#canvas').html(txt);
window.setTimeout(loop,20);
}

$(document).ready(function()
{
$('body').keydown(function(e){done=true;});
loop();
});
</script>

</body>

</html>

Mit setPixel kann man einen Pixel setzen, und mit buildText bekommt man den HTML-Text dazu.. Ich habe es mit verschiedenen Geschwindigkeiten versucht, es kommt nicht unter 50ms und ist somit ungeeignet. Jedoch könnte man dies für ein Rundenbasiertes Spiel benutzen, mal sehen...der ANSI-Zeichensatz ist noch geil...

Hier ist der Source-Code dazu (im Ordner HTMLVersion):
https://github.com/ben0bi/EmulatroniX/releases/tag/Blog_Series_TextGraphic_1

Danke für die Aufmerksamkeit.

RetroPie Screen Orientation

Deutsch 

(click here for the english version.)

Um auf dem RetroPie-System die Bildschirm-Orientation zu ändern, muss man einfach in /boot/config.txt die Variable display_rotate hinzufügen oder ändern.

Aufgrund meiner speziellen Konfiguration habe ich die Kompassrichtungen gewählt, wobei ich bei Nord im Norden sitze und gegen Süden schaue.

Wenn der Bildschirm vor dir steht ist Nord die normale Orientation, Süd ist um 180°, Ost um 90° nach links und West um 90° nach rechts gedreht.

Da ich den Bildschirm nach oben spiegle, braucht es manchmal eine vertikale Spiegelung anstatt einer Drehung. Hier gebe ich euch nun die Zahlen dafür (horizontal spiegeln weiss ich grad nicht mehr, brauchts aber auch nicht wirklich). Für die Spiegelung kann man einfach den Orientation-Wert mit dem Spiegelungs-Wert binär ODER-verknüpfen:

0 = Nord
1 = Ost
2 = Süd
3 = West
0x20000 = Nord vertikal gespiegelt.
0x20001 = Ost vertikal gespiegelt.
0x20002 = Süd vertikal gespiegelt.
0x20003 = West vertikal gespiegelt.

Um ganz schnell die Orientation zu ändern, habe ich mir einfach für jeden Wert eine config.txt und ein .sh-Script geschrieben und die .sh-Scripts dann in ein Menu von EmulationStatin kopiert, welches .sh-Scripts "versteht".

Hier ein Beispiel:
/home/pi/orientation/Config_East_Flipped.txt

...

display_rotate = 0x20001

/home/pi/RetroPie/MyMenu/Orientation_East_Flipped.sh

#!/bin/bash
sudo cp /home/pi/orientation/Config_East_Flipped.txt /boot/config.txt
sudo shutdown -r now

Nach dem Kopieren wird einfach der RasPi neu gestarted und gut ist.

Viel Spass damit!

English 

(Klicke hier für die deutsche Version.)

For changing the display orientation on a RetroPie-System, you just have to add or change the display_rotate-variable in /boot/config.txt

Because of my special configuration I have choosen the compass directions. In the North-orientation, I sit North and look to South.

If the display stands before you, North is normal, South is turned 180°, East is turned 90° to the left and West is turned 90° to the right.

Because I mirror the screen up like in an old arcade cabinet, I need to flip the screen vertically instead of turning it. Here you get the values for that (I don't know the value for a horizontal flip right now, but we don't really need it here). You can just binary OR the orientation value with the flipping value like here:

0 = North
1 = East
2 = South
3 = West
0x20000 = North vertically flipped.
0x20001 = East vertically flipped.
0x20002 = Süd vertically flipped.
0x20003 = West vertically flipped.

I created a config.txt for each of this values and an .sh-script which copies that config.txt to the /boot-directory. This .sh-scripts reside in a menu directory of the EmulationStatin which "understands" .sh-scripts.

Example:
/home/pi/orientation/Config_East_Flipped.txt

...

display_rotate = 0x20001

/home/pi/RetroPie/MyMenu/Orientation_East_Flipped.sh

#!/bin/bash
sudo cp /home/pi/orientation/Config_East_Flipped.txt /boot/config.txt
sudo shutdown -r now

After copy we just restart the RasPi.

Hope that helps.

DIY: Emulator Teil 2: Setup Basisgerüst (JavaScript)

Im vorigen Artikel (Part 1) haben wir uns damit befasst, was ein Emulator ist. Nun kommen wir zum Programmieren selbst.

Wir brauchen für unser Grundgerüst verschiedene JavaScript-Bibliotheken.

• jQuery -> Vereinfacht viele Dinge.
• PixiJS -> Die Grafikbibliothek.
• RUNPIXI -> Diese Bibliothek habe ich geschrieben, um PixiJS ganz einfach zu initialisieren.

Ich werde diese Bibliotheken nicht herunterladen, sondern einen direkten Link dazu angeben. Somit hat man erstens immer die aktuelle Version und zweitens wird Zeit gespart, wenn andere (fremde) Webseiten denselben Link benutzen. Der Browser hat die Datei dann schon im Cache gespeichert.

Ordnerstruktur

Generieren wir erst mal die generelle Ordnerstruktur und die ersten Dateien:

• ./  --> Das ist das root/Basis-Verzeichnis.
• js/  --> enthält alle JavaScript-Dateien.
• css/ --> enthält alle CSS-Dateien.

[weitere werden folgen]

Ich benutze immer diese Ordnerstruktur für meine Web-Projekte, du kannst natürlich auch eine andere Struktur anlegen.

Nun legen wir ein paar verschiedene Dateien an:

• ./index.html
• ./css/base.css

css/base.css

Die Datei css/base.css enthält die grundlegenden Layout-Einstellungen:

html, body
{
width: 100%;
max-width: 100%;
height: 100%;
min-height: 100%;
overflow-x: hidden;
overflow-y: hidden;
}

div, html, body
{
padding: 0;
margin: 0;
}

#wrapper
{
position: absolute;
top: 0px;
left: 0px;
width: 100%;
height: 100%;
}

#pixiscreen
{
position: relative;
margin: 0 auto;
max-height: 100%;
min-height: 100%;
}

Der BODY und HTML Bereich wird auf die Fenstergrösse angepasst. Mit overflow-x: hidden wird alles versteckt, was breiter als das Fenster ist. Dasselbe wird mit der Höhe gemacht. Irgendwie ist das Div beim Chrome immer 0.2 Pixel grösser als das Fenster oder so, was zur Folge hatte, dass Scrollbalken auftauchten, welche dann sowieso noch ein bisschen mehr vom Fenster verdeckt haben. Overflow bräuchte es nicht, wenn das div zum Beispiel 99% Grösse hätte, doch ich will einen randlosen Bildschirm.

Das Padding- und Margin-Attribut wird auf 0 gesetzt, damit kein Rand übrig bleibt. Der #wrapper muss eine absolute Position haben, damit der #pixiscreen mit Margin horizontal zentriert werden kann. Dies hier nur zur Sicherheit, da der Pixi-Screen sowieso das ganze Fenster ausfüllt.

index.html

In die index.html kommt erstmal das HTML-Grundgerüst:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>EmulatroniX</title>
<link rel="stylesheet" type="text/css" href="css/base.css">
</head>
<body>
<div id="wrapper">
<div id="pixiscreen"></div>
</div>

<script src="https://code.jquery.com/jquery-3.2.1.min.js" integrity="sha256-hwg4gsxgFZhOsEEamdOYGBf13FyQuiTwlAQgxVSNgt4=" crossorigin="anonymous"></script>
<script src="https://pixijs.download/v4.5.2/pixi.min.js"></script>
<script src="http://cdn.rawgit.com/ben0bi/RUNPIXI.js/v0.6.4/RUNPIXI/RUNPIXI.js"></script>

<script>
function mainLoop() {}

$(document).ready(function()
{
RUNPIXI.initialize('pixiscreen', mainLoop);
console.log("Ready.");
});
</script>
</body>
</html>

Mit dem DOCTYPE-Tag wird dem Browser mitgeteilt, dass wir HTML 5 benutzen.
Das Meta-Tag stellt das Characterset auf UTF-8. Somit ist immer klar das gleiche Characterset definiert. Die CSS-Dateien werden im Header eingebunden, da sie vom Browser gebraucht werden, um das Layout aufzubauen. Die JavaScript-Dateien werden jedoch am Ende des Bodys hereingeladen, so dass das Layout im Aufbau nicht blockiert wird.

Das #pixiscreen-div ist im #wrapper-div, damit man es horizontal zentrieren kann.

jQuery ist eine Bibliothek, um viele Sachen in JS zu vereinfachen.
Den jQuery-Link bekommt man hier in dieser Form.

PixiJS ist eine JavaScript 2D-Graphikbibliothek, welche auf Geschwindigkeit ausgelegt ist.
Sie benutzt wenn möglich WebGL, ansonsten wird die DOM-Struktur benutzt.
Hierin werden wir die Textur erstellen, auf welcher dann der Bildschirm des Emulators gerendert wird (sogenannte RTT-Technik: Render-To-Texture - wobei hier nicht wirklich eine Szene auf die Textur gerendert wird, sondern nur die Pixel der Textur "direkt" ausgetauscht/verändert werden).
Den Link zu Pixi habe ich selbst aus den Releases von PixiJS herausgesucht.

Schliesslich ist RUNPIXI.js eine kleine Bibliothek, welche ich geschrieben habe, um den Initialisierungsprozess von PixiJS zu vereinfachen. Man braucht nun nur noch ein Kommando auszuführen, nämlich RUNPIXI.initialize(DOMContainerID, loopFunction), alles Andere macht RUNPIXI.

Wenn die Fenstergrösse geändert wird, merkt RUNPIXI das und passt automatisch den Pixi-Renderer an.

Schliesslich wird der Pixi-Bildschirm in dem kleinen Script am Ende initialisiert. Dazu muss es eine mainLoop-Funktion haben, welche nach jedem Frame aufgerufen wird. Diese benutzen wir gerade noch nicht. Man beachte, dass beim Namen des pixiscreens in der Initialisierungsfunktion kein # davor steht: RUNPIXI verzichtet auf jQuery.

Du kannst dem Pixiscreen deine eigene Hingergrundfarbe geben oder ihn sogar transparent machen, indem du die Farbe in der Initialisierungsfunktion als Parameter angibst. Die Farbe kann hexadezimal so angegeben werden: 0xRRGGBB wobei R für Rot, G für Grün und B für Blau steht.

RUNPIXI.initialize('pixiscreen', mainLoop, 0x111133); <-- Schönes dunkles Blau.
RUNPIXI.initialize('pixiscreen', mainLoop, 'transparent'); <-- Transparent. Man sieht nur, was du auch zeichnest.

Fertig!

Wenn du nun die Index.hmtl-Datei im Browser öffnest, sollte dein gesamter Browserbildschirm türkisblau sein (ausser du hast eine andere Farbe angegeben). Damit haben wir die Basis-(Graphik-)Engine initialisiert - das war ja noch ganz einfach. :)

Ich werde für jeden Part/Artikel auf GitHub ein Release vom jeweils aktuellen Master machen.

Das ist das Release für diesen Artikel:
https://github.com/ben0bi/EmulatroniX/releases/tag/Blog_Series_Part_2

Weiter gehts mit [Bitte warten, komplett neuer Aufbau] DIY: Emulator Teil 2.1: Der Emulator Bildschirm.