Prototypen Archive • Seite 2 von 4 • FabMo

Tooli ist da

05.07.2016 Marcus Klütmann Prototypen

Heute ist ein mittelgroßes Paket bei mir angekommen. Ein von mir unterstütztes Kickstarterprojekt hat geliefert. Tooli. Das Paket hat eine lange Reise hinter sich. Es ist von Australien bis Deutschland gekommen. Von Brisbane – Australien bis Leipzig – Deutschland hat es nicht mal 1,5 Tage gedauert. Dann ist es erst mal 8 Tage beim Zoll hängen geblieben.

Erst wollte DHL wissen, ob sie die Zollabfertigung für mich machen dürfen. Die Dame am Telefon sagte mir, dass man dies bei Privatpersonen normalerweise nicht machen würde, aber hier mache man es. Der Warenwert wäre so hoch. Naja, 2100 australische Dollar. Den Auftrag habe ich dann erteilt. Eine kurze Email hat da schon gereicht. Am nächsten Tag habe ich noch mal bei DHL angerufen und gefragt, welche Kosten dann auf mich zukommen. Zoll und Gebühren? Eine weitere Dame teilte mir freudig mit, dass bei ihr überall eine Null steht. Merkwürdig, warum fragt DHL dann, ob die meine Sendung abfertigen dürfen. Scheint ja schon alles bezahlt zu sein. Nun blieb das Paket weitere zwei Tage liegen, da kam dann eine Email mit der Frage, ob mein Paket eine Privatsendung wäre. JA ist es. Weiterwarten. Zwei Tage später hat der Zoll das Paket dann scheinbar abgefertigt. Ein Freitag. In den Versand ist es dann nicht mehr gegangen. Montag ganz früh war das Paket dann in Bremen. Am Dienstag früh wurde es dann per Kurier ausgeliefert.

Rechnung grob 280 Euro. Ein kleiner Unterschied zu den angekündigten 0 Euro. Wider besseren Wissens, denn mit 300 Euro hatte ich eigentlich gerechnet, hatte ich mich nicht auf diese bar zu bezahlende Rechnung eingestellt. Das Geld konnte zum Glück gerade noch so zusammengekratzt werden.

Kleinteile 3 — Kleinteile 1 mit Laserschutzbrille

Kleinteile 1 — Kleinteile 3 mit Befestigungsmaterial

Autodesk’s Project Escher on Vimeo

10.03.2016 Marcus Klütmann Prototypen

Ein FDM Drucker mit (wirklich) mehreren Druckköpfen. Wichtig ist die Software.

Ohne die passende Software könnte jeder Druckkopf einfach nur die anderen spiegeln. Das ist schon seit längerem möglich. Das Autodesk Projekt Escher hingegen teilt ein Objekt so auf, dass es ideal zwischen den Druckköpfen aufgeteilt ist.

Noch mehr kleine Symbole für die Wand

25.02.2016 Marcus Klütmann News, Prototypen

Ich finde, dass die meisten White Boards ein wenig mehr Pepp brauchen. So kleine oder auch große gedruckte Symbole machen da schon viel her.

Das „Geldsymbol“ hatte ich mit einem Objet 500 Connex 3 gedruckt. Ist leider nicht so ganz gut geworden. Wir haben zu dem Zeitpunkt gerade mit der Software rumgespielt.

Die beiden roten Zeichen sind recht klein. Nur ca 15 mm breit. Dafür lassen sie sich aber sehr schnell drucken und sind trotzdem gut auf dem Whiteboard sichtbar. Zettel können sie auch noch halten. Zweck erfüllt 🙂

ATtiny85 Ring Watch

19.02.2016 Marcus Klütmann 3D Drucker, Prototypen

Eigentlich total hässlich, aber die Idee finde ich toll.

Base on the previous Instructables – ATtiny Watch Core and more, I have made a real gadget, an ATtiny85 Ring Watch.

Quelle: ATtiny85 Ring Watch

Das elektronische Schaf

18.12.2015 Marcus Klütmann Prototypen

Lange ist es her, seit ich mich um das elektronische Schaf gekümmert habe. Mit dem Unterboden war ich nicht wirklich zufrieden. Nun habe ich mich endlich mal an einen neuen Versuch gewagt.

links: neue Version, rechts: alte Version

Die Motoren sind nun um 5° nach unten geneigt. Das ergibt ein bisschen mehr Bodenfreiheit und die Drehungen sollten ein bisschen leichter gehen. Eine 10° Neigung müsste ich auch noch mal ausprobieren.

Da der Raum für den Motor zu eng war, ist beim Eindrücken des Motors das Gehäuse ein bisschen aufgeplatz (links zu sehen). Die Layerhafung ist bei diesem Versuch auch nicht so ganz gut. Gedruckt habe ich mit ABS.

Dafür war die Haftung am Druckbett zu gut.

Obwohl die Maße 170 mm x 128 mm betragen hat sich keine einzige Ecke des Modells vom Druckbett abgehoben. Leider haftete das Modell auch nach dem Abkühlen noch so stark am Druckbett, dass ich es nur mit Mühe runterbrechen konnte. Vor dem Drucken kippe ich ein wenig Aceton (Achtung gut lüften!) auf das Druckbett und schwenke ein paar mal etwas ABS darin herum. Das ABS löst sich im Aceton etwas auf und klebt dann nach dem Trocknen am Druckbett fest. Die Schicht ist dabei kaum zu sehen, aber es reicht vollkommen aus, um als Haftgrund zu dienen.

Ich werde nachher noch mal einen Druck starten. Mit veränderter Motoraufnahme (etwas weiter), dickeren Wänden (2mm auf 4 mm) und leicht erhöhter Drucktemperatur (234°C auf 237°C). Druckzeit ca. 6 Stunden.

DEFCON Ampel, die Zweite

03.09.2015 Marcus Klütmann News, Prototypen

Um den Kollegen anzuzeigen, dass man gerade nicht unbedingt gestört werden möchte, habe ich eine kleine Ampel in Anlehnung an die DEFCON Einteilung (Grün und Blau sind getauscht) gebastelt.

Zuerst hatte ich als Gehirn der Schaltung einen Arduino Mini Pro verwendet. Da ich nur die 5V Version besitze und das Ganze mit einem kleinen Lithium-Akku betreiben wollte, brauchte ich auch noch einen Step-Up Wandler auf 5V. Die Billigdinger, die ich hier rumliegen habe, taugen aber leider nicht viel. Sie machen zwar, was sie sollen und es funktioniert auch, aber sie geben einen fiesen Pfeifton von sich. So kann die Ampel dann nicht auf dem Schreibtisch stehen.

Also habe ich mir eine andere Möglichkeit überlegt. Mein Hundeblinklicht habe ich auch von Arduino Mini Pro auf ATTiny85 gewechselt. So wollte ich es nun auch machen. Hab zwar nur noch einen ATTiny 45 hier liegen, der ist aber auch nicht viel anders als der 85er. Der ATTiny45 hat insgesamt 8 Pins. Zwei dienen der Spannungsversorgung und ein weiterer kann nicht so ohne weiteres als Aus- oder Eingang verwendet werden. Der RESET Pin. Den brauche ich, so wie er ist, zum Programmieren des ATTiny. Bleiben also noch 8 minus 3 also 5 Pins über. 3 LEDs und zwei Taster wären dann auf traditionelle Weise möglich. Das war mir bedeutend zu wenig. Immerhin hatte ich bereits 5 LEDs und 6 Taster in der ersten Version eingebaut.

Der ATTiny 45 sitzt unter den Tastern; vorne links zu sehen.

Über Spannungsteiler kann man unterschiedliche Spannungen am Analogeingang anlegen und im Code auswerten. Das erfordert zwar ein bisschen mehr externe Beschaltung, dafür ist die Anzahl der Taster dann nicht mehr begrenzt (praktisch wird es bei > 20 Tastern schon schwierig). Das Ganze erfordert dann auch nur noch einen Pin.

Stümperhaft bemalt, aber für einen Prototypen reicht es

Dann sind nun noch 4 Pins frei. 3 LEDs mit PWM sind mit Bordmitteln machbar oder ich verzichte auf PWM und habe dann 4 LEDs. Dennoch habe ich erst mal mit 3 LEDs und PWM angefangen. So hatten wenigstens alle 6 Taster eine Funktion.

Danach ist mir dann eingefallen, dass man LEDs antiparallel schalten kann. Einfach die Polarität tauschen und schon leuchtet die eine oder die andere LED. So wie bei Charlieplexing. In dem Fall musste ich mich dann aber vom integrierten PWM verabschieden. Mit Charlieplexing und PWM wären nur 4 LEDs möglich gewesen (beim ATTiny 45).

Statt die LED nun sanft ein und ausfaden zu lassen, blinken sie nun einfach. Mit zwei Tastern kann man die Blinkfrequenz verlangsamen oder beschleunigen. Mit übrigen zwei Tastern kann man nun das Tastverhältnis (Duty Cycle) zwischen An und Aus beeinflussen. Tja und wenn man nun die Blinkfrequenz ganz hoch setzt, hat man ein Software PWM 🙂 Ich könnte jetzt wieder das sanfte ein und ausfaden einbauen. Ich werd’s aber wohl lassen. Das Blinken und Blitzen hat auch was.

Hier der Code, den ich mit der Arduino IDE geschrieben habe. Wenn ich die Funktion analogRead(x) nun noch ersetzen kann, ist der Code auch mit anderen IDEs kompelierbar.

/*
  DEFCON, a little traffic light like application
  6 Buttons on one Pin
  and up to 6 LEDs on 4 Pins 
  driven by one small ATTiny45
  ---
  With the two big buttons you can switch from green to blue, orange, red and grey and back.
  With the little 4 way (actually 5 way) switch you can change blink speed and duty cycle of the blink. 
  When the blink frequency is high enough you can use it as PWM for all connected LEDs.
  The buttons are connecte to just one pin (A2/PB4). With different voltage dividers per button this 
  circuit measures different voltages on the conntected analogue pin. Depending on what voltage you measure 
  a different action is called. 
  
  @autor: Marcus Guin Kluetmann
*/

#define LED       PORTB
#define RED       B0000100
#define ORANGE    B0001101
#define GREEN     B0000111
#define BLUE      B0001011
#define GREY      B0000010
#define LEDOFF    B0000000
#define BUTTON    A2
#define LEDS      5
#define MAXPWMCYCLES  1024

int SelectedLED;  
int lastButtonValue;
int ButtonValue;
int ReadValue;
double PWMCycles;
double DutyCycle;
boolean RisingFallingFlag;
double z;
double y;
 
void setup() {
  DDRB = B00001111;
  LED = LEDOFF;;

  SelectedLED = 1;
  ButtonValue = LOW;
  DutyCycle = 1;
  PWMCycles = 512;
  RisingFallingFlag = 1;
  z = 1; 
  y = 1;
  ReadValue = 0;
}

void switchLED(int led){
  if(z>PWMCycles){
    RisingFallingFlag=false;
    y=1/DutyCycle;
  }else if(z<1){
    RisingFallingFlag=true;
    y=DutyCycle;
  }
  if(!RisingFallingFlag){
    LED = led;
    z-=y;
  }else if(RisingFallingFlag){     
    LED = LEDOFF;
    z+=y;
  }   
}

void loop()
{
    ReadValue = analogRead(BUTTON);
    if(ReadValue > 50 ) {
      if (ReadValue == lastButtonValue) {
        if (ReadValue < (ButtonValue-10) || ReadValue > (ButtonValue+10)) { // a little bit buffer so analogue value can shift a bit 
            ButtonValue = ReadValue;
            if (ReadValue > 300 && ReadValue < 340) { 
              if(SelectedLED > 1 ) SelectedLED--;
              _delay_ms(20);
            } 
            if (ReadValue > 200 && ReadValue < 280) {
              if(SelectedLED < LEDS ) SelectedLED++;
              _delay_ms(20);
            } 
        }
      }    
        
      if (ReadValue > 500 && ReadValue < 520) {
        if(PWMCycles < MAXPWMCYCLES ) PWMCycles+=0.1;
      } 
      if (ReadValue > 670 && ReadValue < 690) {   
        if(PWMCycles > 0.9 ) PWMCycles-=0.1; 
      } 
      if (ReadValue > 940 && ReadValue < 980) {
        if(DutyCycle > 0.09 ) DutyCycle-=0.001; 
      } 
      if (ReadValue > 850 && ReadValue < 900) {   
        if(DutyCycle < 4 ) DutyCycle+=0.001;
      } 
    }
    switch(SelectedLED){
    case 1: 
      switchLED(GREEN);
    break;
    case 2: 
      switchLED(BLUE);
    break;
    case 3:  
      switchLED(ORANGE);
    break;
    case 4:
      switchLED(RED);
    break;
    case 5: 
      switchLED(GREY);
    break;
    }  
    lastButtonValue = ReadValue;  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

DEFCON, a little traffic light like application

6 Buttons on one Pin

and up to 6 LEDs on 4 Pins

driven by one small ATTiny45

---

With the two big buttons you can switch from green to blue, orange, red and grey and back.

With the little 4 way (actually 5 way) switch you can change blink speed and duty cycle of the blink.

When the blink frequency is high enough you can use it as PWM for all connected LEDs.

The buttons are connecte to just one pin (A2/PB4). With different voltage dividers per button this

circuit measures different voltages on the conntected analogue pin. Depending on what voltage you measure

a different action is called.

@autor: Marcus Guin Kluetmann

#define LED PORTB

#define RED B0000100

#define ORANGE B0001101

#define GREEN B0000111

#define BLUE B0001011

#define GREY B0000010

#define LEDOFF B0000000

#define BUTTON A2

#define LEDS 5

#define MAXPWMCYCLES 1024

int SelectedLED;

int lastButtonValue;

int ButtonValue;

int ReadValue;

double PWMCycles;

double DutyCycle;

boolean RisingFallingFlag;

double z;

double y;

void setup() {

DDRB = B00001111;

LED = LEDOFF;;

SelectedLED = 1;

ButtonValue = LOW;

DutyCycle = 1;

PWMCycles = 512;

RisingFallingFlag = 1;

z = 1;

y = 1;

ReadValue = 0;

}

void switchLED(int led){

if(z>PWMCycles){

RisingFallingFlag=false;

y=1/DutyCycle;

}else if(z<1){

RisingFallingFlag=true;

y=DutyCycle;

}

if(!RisingFallingFlag){

LED = led;

z-=y;

}else if(RisingFallingFlag){

LED = LEDOFF;

z+=y;

}

void loop()

{

ReadValue = analogRead(BUTTON);

if(ReadValue > 50 ) {

if (ReadValue == lastButtonValue) {

if (ReadValue < (ButtonValue-10) || ReadValue > (ButtonValue+10)) { // a little bit buffer so analogue value can shift a bit

ButtonValue = ReadValue;

if (ReadValue > 300 && ReadValue < 340) {

if(SelectedLED > 1 ) SelectedLED--;

_delay_ms(20);

}

if (ReadValue > 200 && ReadValue < 280) {

if(SelectedLED < LEDS ) SelectedLED++;

_delay_ms(20);

}

if (ReadValue > 500 && ReadValue < 520) {

if(PWMCycles < MAXPWMCYCLES ) PWMCycles+=0.1;

}

if (ReadValue > 670 && ReadValue < 690) {

if(PWMCycles > 0.9 ) PWMCycles-=0.1;

}

if (ReadValue > 940 && ReadValue < 980) {

if(DutyCycle > 0.09 ) DutyCycle-=0.001;

}

if (ReadValue > 850 && ReadValue < 900) {

if(DutyCycle < 4 ) DutyCycle+=0.001;

}

switch(SelectedLED){

case 1:

switchLED(GREEN);

break;

case 2:

switchLED(BLUE);

break;

case 3:

switchLED(ORANGE);

break;

case 4:

switchLED(RED);

break;

case 5:

switchLED(GREY);

break;

}

lastButtonValue = ReadValue;

}

ArcadePi nächster Teil

19.05.2015 Marcus Klütmann Prototypen

Vor langer Zeit hatte ich mal damit angefangen, eine tragbare Spieleconsole mit einem RaspberryPi zu bauen. So eine Art PiGRRL – Raspberry Pi Gameboy. Mein zweiter Versuch war dann schon etwas aufwändiger. Das ganze Gehäuse habe ich selber entworfen und mehrere Versionen auf meinem 3D Drucker ausgedruckt.

Das Display ist ein 4,3 Zoll großer TFT Monitor, den man für Rückfahrtkameras nutzt. Im Gegensatz zu den Displays, die speziell für den RaspberryPi verkauft werden, ist so ein Monitor bei Amazon schon für um die 20 Euro zu haben.

Nachdem dann der ganze ArcadePi zusammengebaut war und funktionierte, schlief das Projekt wieder ein. Einige Dinge haben mit nicht gefallen und bei dem jetzigen Neuanfang habe ich die Chance, diese Dinge zu ändern.

Bei dem neuen ArcadePi wollte ich zuerst eines dieser RaspberryPi Displays nutzen, die man über die GPIO Pins anschließt. Dies Vorteile als auch neben dem Preis einige andere Nachteile:.

Vorteile

Digitale Übertagung
- Die Daten werden nicht Analog, sondern mit digitalen Signalen auf das Display geschoben
- Dadurch bleibt die Grafik frischer und wirkt nicht so verwaschen.
Es ist (gefühlt) stromsparender
- Einen genauen Beleg habe ich nicht. Es liegt sicherlich daran, dass ich einen 4,3 Zoll Monitor genutzt habe, der offensichtlicher Weise mehr verbraucht als ein 3,5 Zoll Monitor.

Nachteile

Das Display muss erst konfiguriert werden, damit es überhaupt etwas anzeigt.
- Wenn es dann erst mal läuft, ist das auch nicht weiter schlimm
Das Display ist langsam
- FPS
- Video Lag

Am störensten ist das Video Lag. Dieser liegt bei 20 bis 30 ms. Klingt erst mal nicht viel. Aber wenn man dann mal Super Mario Brothers spielt, ist das schon sehr deutlich zu spüren. Durch diesen Lag springt man immer zu spät und stirbt ständig. Ich bin zwar kein guter Mario Spieler, aber zumindest im ersten Level verliere ich kein Leben, wenn ich über einen VGA oder HDMI Monitor spiele. Bei 30 Milli-Sekunden Lag ist das schon frustrierend. Man könnte sich an den Lag anpassen, aber will man das wirklich?

Ich habe hier noch einen weiteren kleinen TFT Monitor im 3,5 Zoll rumliegen (auch ca 20 Euro bei Amazon). Diesen will ich diesmal verwenden. Der 4,3 Zoll Monitor verbraucht mir zu viel Strom und 3,5 Zoll sind ausreichend groß.

Bald soll es weitergehen.

Ein GPIO Display am Raspberry konfigurieren und andere Sachen

19.05.2015 Marcus Klütmann Prototypen

Hier in Kurz einmal meinen Weg, wie ich die Software (Retropie) auf dem RaspberryPi mit dem Raspberry Display eingerichtet habe.

Retropie hier runterladen und auf eine SD Karte „brennen“ (z.B. mit Win32 Disk Imager)
http://blog.petrockblock.com/retropie/retropie-downloads/

Eine Manuelle Installation ist auch möglich
http://blog.petrockblock.com/2012/07/22/retropie-setup-an-initialization-script-for-retroarch-on-the-raspberry-pi/

Nach dem ersten Einloggen über SSH dann erst mal

sudo raspi-config

1	sudo raspi-config

ausführen und das Dateisystem auf die gesamte Speicherkarte ausweiten (Punkt 1). Dies ist besonders dann notwendig, wenn man das Komplettimage runtergeladen und auf die Speicherkarte „gebrannt“ hat. Wenn man schon dabei ist, kann man auch gleich die Internationalisierungsoptionen (Punkt 4) auswählen und z.B. das Tastaturlayout (change keyboard layout) einstellen.

Danach dann gleich ein

sudo dpkg-reconfigure console-setup

1	sudo dpkg-reconfigure console-setup

Hier wählt man im ersten Schritt “UTF-8” aus. Im zweiten Schritt “Guess optimal character set”; im dritten “Terminus” und im vierten und letzten Schritt “6×12 (framebuffer only).”. Diese Einstellung sorgt dafür, dass wir die Konsole im kleinen Display besser lesen können.

Jetzt updaten wir einmal das System mit folgenden Befehlen

sudo apt-get update
sudo apt-get install -y git dialog
cd
sudo rm -rf RetroPie-Setup
git clone git://github.com/petrockblog/RetroPie-Setup.git
cd RetroPie-Setup
chmod +x retropie_setup.sh
sudo ./retropie_setup.sh

sudo apt-get update

sudo apt-get install -y git dialog

sudo rm -rf RetroPie-Setup

git clone git://github.com/petrockblog/RetroPie-Setup.git

cd RetroPie-Setup

chmod +x retropie_setup.sh

sudo ./retropie_setup.sh

Damit sollte Retropie auf dem neusten Stand sein.

Bisher bleibt das über die GPIO Pins angeschlossene Display noch schwarz. Das wollen wir nun ändern.

wget -N https://github.com/watterott/RPi-Display/raw/master/rpi-display.sh
sudo /bin/bash rpi-display.sh 270

1 2	wget -N https://github.com/watterott/RPi-Display/raw/master/rpi-display.sh sudo /bin/bash rpi-display.sh 270

Es wird ein kleines Skript runtergeladen und dann ausgeführt. Beim Ausführen bekam ich die Meldung, dass kein „FBTFT“ gefunden wurde und ob ich das System updaten wolle. Dieses habe ich mit Ja beantwortet.

Nun muss man noch ein bisschen in der Bootconfig von RaspberryPi rumfummeln.

sudo nano /boot/config.txt

1	sudo nano /boot/config.txt

Folgende Zeilen sollen in der config.txt am Ende eingefügt werden.

dtoverlay=rpi-display,speed=80000000,rotate=270,fps=60

hdmi_force_hotplug=1
hdmi_cvt=320 240 60 1 0 0 0
hdmi_group=2
hdmi_mode=87

dtoverlay=rpi-display,speed=80000000,rotate=270,fps=60

hdmi_force_hotplug=1

hdmi_cvt=320 240 60 1 0 0 0

hdmi_group=2

hdmi_mode=87

Jetzt muss SPI noch aktiviert werden.

sudo nano /etc/modprobe.d/raspi-blacklist.conf

1	sudo nano /etc/modprobe.d/raspi-blacklist.conf

Hier muss die Zeile mit „blacklist spi-bcm2708“ auskommentiert werden (mit # ).

Wenn man nun die Kommandozeile auf dem Display sehen möchte, muss man in cmdline.txt noch etwas anfügen.

sudo nano /boot/cmdline.txt

1	sudo nano /boot/cmdline.txt

Einfach am Ende der langen Zeile noch dies hier anhängen:

fbcon=map:10 fbcon=font:VGA8x8 logo.nologo

1	fbcon=map:10 fbcon=font:VGA8x8 logo.nologo

Natürlich nicht vergessen, alle Änderungen zu speichern.

Nach einem Reboot ( sudo reboot), sollte die Kommandozeile im Display zu sehen sein. Sobald jedoch EmulationStation (die grafische Oberfläche des Emulators) startet, bleibt das kleine Display schwarz. Hier ist noch ein bisschen Arbeit nötig.

Folgende Befehle nacheinander in der Kommandozeile eingeben:

# git clone https://github.com/paul70078/rpi-fbcp.git
git clone https://github.com/tasanakorn/rpi-fbcp
mkdir -p rpi-fbcp/build
cd rpi-fbcp/build
cmake ..
make
sudo install fbcp /usr/local/bin/fbcp
cd ../..
rm -r -f rpi-fbcp

# git clone https://github.com/paul70078/rpi-fbcp.git

git clone https://github.com/tasanakorn/rpi-fbcp

mkdir -p rpi-fbcp/build

cd rpi-fbcp/build

cmake ..

make

sudo install fbcp /usr/local/bin/fbcp

cd ../..

rm -r -f rpi-fbcp

Nun ist der FrameBufferKopierer installiert. Einfach mal „fbcp&“ in die Konsole eingeben. Schon sollte auch der Emulator nun auf dem Display laufen. Leider muss man bei jedem Neustart fbcp& eingeben, was bei einem Gameboy-Clone ohne Tastatur nur schwer möglich ist.

Es wird einfach ein neues keines Skript angelegt mit

sudo nano /etc/init.d/RPi-Display

1	sudo nano /etc/init.d/RPi-Display

Inhalt des Skriptes ist

#!/bin/sh
### BEGIN INIT INFO
# Provides:          fbcp Framebuffercopy
# Required-Start:    
# Required-Stop:    
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Kurze Beschreibung
# Description:       Längere Bechreibung
### END INIT INFO
sudo fbcp &
# Actions
case "$1" in
    start)
        # START
        ;;
    stop)
        # STOP
        ;;
    restart)
        # RESTART
        ;;
esac

#!/bin/sh

### BEGIN INIT INFO

# Provides: fbcp Framebuffercopy

# Required-Start:

# Required-Stop:

# Default-Start: 2 3 4 5

# Default-Stop: 0 1 6

# Short-Description: Kurze Beschreibung

# Description: Längere Bechreibung

### END INIT INFO

sudo fbcp &

# Actions

case "$1" in

start)

# START

;;

stop)

# STOP

;;

restart)

# RESTART

;;

esac

Nun machen wir das neue Skript nach dem Speichern noch ausführbar mit

sudo chmod +x /etc/init.d/RPi-Display

1	sudo chmod +x /etc/init.d/RPi-Display

und fügen es der Gruppe und dem Besitzer „root“ zu

sudo chown root:root /etc/init.d/RPi-Display

1	sudo chown root:root /etc/init.d/RPi-Display

Damit unser kleines Skipt bei jedem Neustart ausgeführt wird, geben wir noch dieses in die Konsole ein

sudo update-rc.d RPi-Display defaults

1	sudo update-rc.d RPi-Display defaults

Nun sollte der Emulator auch bei jedem Neustart auf dem kleinen Display zu sehen sein.

Es kann sein, dass die Schrift im Emulator schwer zu lesen ist. Ein wenig Abhilfe könnte dies hier schaffen.

sudo nano /etc/emulationstation/themes/simple/simple.xml

1	sudo nano /etc/emulationstation/themes/simple/simple.xml

In dieser Datei runterscrollen bis zur „gamelist“ Sektion. Dort den Wert von „primaryColor“ auf 000000 ändern. Und dann noch die „fontSize“ von 0.03 auf 0.05 erhöhen.

Wer jetzt noch seine Buttons konfigurieren möchte, muss sich hier ein bisschen einlesen: https://learn.adafruit.com/retro-gaming-with-raspberry-pi/buttons Vermutlich muss das Programm „retrogame“ neu kompliert werden. Das ist aber nicht weiter schlimm und steht im eben genannten Link.

Nun noch die richtigen ROMs auf die Speicherkarte kopieren und schon kann der Spaß losgehen.

Wer nun noch einen kleinen WLAN Stick am Raspberry nutzen möchte, kann dies einfach machen. In „interfaces“ müssen nur die richtigen Daten eingetragen werden.

sudo nano /etc/network/interfaces

1	sudo nano /etc/network/interfaces

auto lo
iface lo inet loopback
iface eth0 inet dhcp
auto wlan0
allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-ap-scan 1
wpa-scan-ssid 1
wpa-ssid "WLAN-NAME"
wpa-psk "WLAN-SCHLÜSSEL"

auto lo

iface lo inet loopback

iface eth0 inet dhcp

auto wlan0

allow-hotplug wlan0

iface wlan0 inet dhcp

wpa-ap-scan 1

wpa-scan-ssid 1

wpa-ssid "WLAN-NAME"

wpa-psk "WLAN-SCHLÜSSEL"

Bei meiner Bluetooth Tastatur hapert es noch ein wenig. Bisher schaffe ich es nicht, dass die Tastatur nach einem Neustart verwendet werden kann. Bisher habe ich folgendes versucht. http://elinux.org/RPi_Bluetooth_keyboard_setup

sudo apt-get install bluez python-gobject
hcitool scan
sudo echo 0000|sudo bluez-simple-agent hci0 AA:00:00:00:8A:F7
sudo bluez-test-device trusted AA:00:00:00:8A:F7 yes
sudo bluez-test-input connect AA:00:00:00:8A:F7 yes

sudo apt-get install bluez python-gobject

hcitool scan

sudo echo 0000|sudo bluez-simple-agent hci0 AA:00:00:00:8A:F7

sudo bluez-test-device trusted AA:00:00:00:8A:F7 yes

sudo bluez-test-input connect AA:00:00:00:8A:F7 yes

Den letzten Befehl muss ich immer erst manuell ausführen, damit die Bluetooth Tastatur verunden wird. Eigentlich sollte der vorletzte Befehl genau dieses erübrigen.

Hier noch unsortiert die Links, die ich bei der Einrichtung studiert habe:

http://www.forum-raspberrypi.de/Thread-gameboy-pi-a
http://www.forum-raspberrypi.de/Thread-bitte-um-hilfe-bei-display?page=3
https://github.com/notro/fbtft/wiki/Framebuffer-use#framebuffer-mirroring
https://learn.adafruit.com/running-opengl-based-games-and-emulators-on-adafruit-pitft-displays/adding-controls
http://seite360.de/2013/10/12/retroppie-schritt-fur-schritt-zur-retrogame-emulationstation-mit-dem-raspberry-pi/
https://github.com/watterott/RPi-Display/blob/master/docu/FAQ.md
http://elinux.org/RPiconfig