Die Carrduino Startampel
Der Arduino erstmalig im realen Einsatz an der Carrera Bahn als Startampel
Die erste reale Anwendung des Carrduino Dekoders ist eine Startampel. Da es für die D143 bisher keine eigene Startampel zu kaufen gibt und ich ausschließlich im Maßstab 1:43 unterwegs bin, hat mich der Eigenbau einer solchen Ampel schon eine ganze Zeit gereizt.
Abbildung 13,2,1...das Endergebnis dieser Anleitung, eine 1:43 Carrera Startampel
Meine Ampel soll in der ersten Ausbaustufe wie das Carrera Startlicht 30354 funktionieren. Das bedeutet, die Startsequenz wird über fünf doppelte rote LEDs angezeigt. Im normalen Betrieb ist die Ampel aus. Die Ampel soll wie das Original über die Bahn mit Energie und den notwendigen Schaltsignalen versorgt werden. In den weiteren Versionen möchte ich dann Ampeln entwickeln, die der Startampel beim Formel-1 näher kommen, z.B. soll der normale Rennbetrieb durch ein grünes Licht angezeigt werden und so weiter. Da die dafür notwendigen Signale von der CU nicht übertragen werden, müssen diese Zustände von der Ampel selber erkannt werden, was sicher nicht ganz leicht sein wird.
Abbildung 2Das original Carrera Startlicht 30354. Nur die Startsequenz wird angezeigt, ansonsten ist die Ampel aus.
Die Informationen zur Steuerung der LEDs werden von BB und CU im Programmierdatenwort an die externen Geräte übertragen. Der Aufbau des Programmierdatenworts unterscheidet sich zwischen BB und CU, daher sind die Systeme leider nicht kompatibel. Um mir die Sache zu vereinfachen, konzentriere ich mich nachfolgend ausschließlich auf die CU. Ein Anpassung an die BB ist nachträglich jederzeit möglich, die Hardware kann weiter verwendet werden, lediglich die Erkennung der Zustände müsste per Software angepasst werden. Mit Hilfe der Dokumentation von Stefan Heß sollte das kein großes Problem sein.
Abbildung 3Detailansicht der LED-Reihe am Carrera Startlicht 30354.
Zur Steuerung der 5 Doppel-LEDs ist im Programmierdatenwort der Befehl Nr. 16 vorgesehen. Wird die Start-Taste gedrückt, gehen alle 5 LEDs der CU an. Nach erneutem Drücken der Start-Taste wird die Startsequenz eingeleitet. Im Rennbetrieb ist das Startlicht aus, an der CU leuchtet die mittlere LED. Bei jeder Zustandsänderung der LEDs wird der Befehl 16 mit den entsprechenden Werten für die Anzahl der leuchtenden LEDs übertragen.
Abbildung 4Der Aufbau der 13 Bits des Befehls Nr. 16 im Programmierdatenwort der CU
Die minimale Software für den Arduino ist damit schon vorgegeben. Als Grundlage dient das Carrera Hacking Skeleton welches ich im Zusammenhang des Carrera Protokoll Decodierers vorgestellt habe. Eine einfache Switch-Case Anweisung innerhalb des Skeletons steuert die LED-Zustände je nach empfangenen Programmierdatenwort. Der zugehörige Testaufbau der Hardware auf dem Protoboard ist ebenfalls überschaubar, er würde auch auf ein halbes "Frühstücksbrettchen" passen.
Abbildung 5Testaufbau der Startampel im Carrera Style auf einem Steckbrett mit einem Arduino nano.
In dieser Schaltung kommt ein Arduino Nano zum Einsatz, dieser ist nach meinen Erfahrungen ideal für das Steckbrett geeignet und sorgt für kompakte Testaufbauten. Der Arduino wird über einen Gleichrichter und einen 5 Volt Festspannungsregler versorgt. Der Anschluss über den Gleichrichter hat den Vorteil, dass man die Schaltung beliebig an die Bahn anschließen kann, man braucht sich nicht um Polaritäten zu kümmern. Die spätere Startampel kann also in beliebiger Richtung in die Bahn eingebaut werden. Die Decodierung der Carrera Daten erfolgt analog zum Protokolldecodierer über einen einfachen Widerstands-Spannungsteiler.
Abbildung 6Schaltplan für den Testaufbau der Startampel im Carrera Style
Der Spannungsteiler wird, wie gehabt, aus den beiden Widerständen R1 = 22 kΩ und R2 = 1,5 kΩ gebildet und füttert den Pin 2 des Arduinos. Die LEDs werden an einem Vorwiderstand von jeweils 220 Ω betrieben. Der Rest der Schaltung bedarf keiner weiteren Erklärung. Der erste funktionstüchtige Arduino Sketch zur Ansteuerung des Testaufbaus sieht nach den oben ausgeführten Vorüberlegungen wie folgt aus:
const int dataInPin = 2;
const int red1Pin = 8;
const int red2Pin = 9;
const int red3Pin = 10;
const int red4Pin = 11;
const int red5Pin = 12;
boolean wordChange = false;
long Word = 0;
long currentWord = 0;
unsigned long intervalMicros = 0;
unsigned long previousMicros = 0;
unsigned long currentMicros = 0;
void setup() {
int ledPin;
pinMode(dataInPin, INPUT);
attachInterrupt(0, manchesterDecode, CHANGE);
for (ledPin=red1Pin; ledPin<=red5Pin; ledPin++){
pinMode(ledPin, OUTPUT);
digitalWrite( ledPin, LOW);}
}
void loop() {
int ledPin;
if( wordChange == true ){
wordChange = false;
switch ( Word ) {
case 4111: // Binary: 1000000001111 programming data word: command 16, value 0
for (ledPin=red1Pin; ledPin<=red5Pin; ledPin++)
digitalWrite( ledPin, LOW );
break;
case 6159: // Binary: 1100000001111 programming data word: command 16, value 1
for (ledPin=red1Pin; ledPin<=red5Pin; ledPin++)
digitalWrite( ledPin, LOW );
digitalWrite( red1Pin, HIGH );
break;
case 5135: // Binary: 1010000001111 programming data word: command 16, value 2
for (ledPin=red1Pin; ledPin<=red5Pin; ledPin++)
digitalWrite( ledPin, LOW );
digitalWrite( red1Pin, HIGH );
digitalWrite( red2Pin, HIGH );
break;
case 7183: // Binary: 1110000001111 programming data word: command 16, value 3
for (ledPin=red1Pin; ledPin<=red5Pin; ledPin++)
digitalWrite( ledPin, LOW );
for (ledPin=red1Pin; ledPin<=red3Pin; ledPin++)
digitalWrite( ledPin, HIGH );
break;
case 4623: // Binary: 1000100001111 programming data word: command 16, value 4
for (ledPin=red1Pin; ledPin<=red5Pin; ledPin++)
digitalWrite( ledPin, LOW );
for (ledPin=red1Pin; ledPin<=red4Pin; ledPin++)
digitalWrite( ledPin, HIGH );
break;
case 6671: // Binary: 1101000001111 programming data word: command 16, value 5
for (ledPin=red1Pin; ledPin<=red5Pin; ledPin++)
digitalWrite( ledPin, HIGH );
break;
}
}
}
void manchesterDecode(){
// for more see: http://www.wasserstoffe.de/carrera-hacks/manchester-decode/index.html
}
"The code is much more difficult for you to debug and maintain, and is a lot harder for other people to understand. It only takes a few microseconds for the processor to execute code, but it might take hours for you to figure out why it isn't working right and fix it! Your time is valuable, right? But the computer's time is very cheap, measured in the cost of the electricity you feed it. Usually it is much better to write code the most obvious way."
Die reduzierte Version möchte ich hier dennoch nicht vorenthalten.
const int dataInPin = 2;
boolean wordChange = false;
long currentWord = 0;
long Word = 0;
unsigned long intervalMicros = 0;
unsigned long previousMicros = 0;
unsigned long currentMicros = 0;
void setup() {
pinMode(dataInPin, INPUT);
attachInterrupt(0, manchesterDecode, CHANGE);
DDRB = B00011111; // set digital pins 12,11,10,9,8 as output
PORTB = B11100000; // set digital pins -,-,13,12,11,10,9,8 to LOW
}
void loop() {
if( wordChange == true ){
wordChange = false;
switch ( Word ) {
case 4111: // Binary: 1000000001111 programming data word: command 16, value 0
PORTB = B00000000; // set digital pins -,-,13,12,11,10,9,8 to LOW
break;
case 6159: // Binary: 1100000001111 programming data word: command 16, value 1
PORTB = B00000001; // set digital pins -,-,13,12,11,10,9 to LOW and pin 8 to HIGH
break;
case 5135: // Binary: 1010000001111 programming data word: command 16, value 2
PORTB = B00000011; // set digital pins -,-,13,12,11,10 to LOW and pins 8,9 to HIGH
break;
case 7183: // Binary: 1110000001111 programming data word: command 16, value 3
PORTB = B00000111; // set digital pins -,-,13,12,11 to LOW and pins 8,9,10 to HIGH
break;
case 4623: // Binary: 1000100001111 programming data word: command 16, value 4
PORTB = B00001111; // set digital pins -,-,13,12 to LOW and pins 8,9,10,11 to HIGH
break;
case 6671: // Binary: 1101000001111 programming data word: command 16, value 5
PORTB = B00011111; // set digital pins -,-,13, to LOW and pins 8,9,10,11,12 to HIGH
break;
}
}
}
void manchesterDecode(){
// for more see: http://www.wasserstoffe.de/carrera-hacks/manchester-decode/index.html
}
Nachdem die grundsätzliche Funktion geklärt ist widmen wir uns nun dem Hardware Aufbau einer Ampel. Zum 1:1 Nachbau der Carrera Ampel 30354 werden pro Ausgang am Arduino zwei rote LED's benötigt. Die roten LED's haben eine Durchlassspannung von 1,8 V bei einem Strom von 25 mA. Die Leerlaufspannung an den digitalen Ausgängen des Arduinos beträgt 4,5 V, bei leichter Belastung bricht die Spannung bereits auf 4,25 V ein. Es bietet sich also an, jeweils zwei rote LEDs an einem Port zu betreiben. Die Gesamtspannung über den LEDs beträgt dann 3,6 V. Die Restspannung von ca. 0,6 bis zu theoretischen 0,9 V kann über einen Vorwiderstand von 33 Ω vernichtet werden. Risikobereite Bastler verzichten auf den Vorwiderstand und betreiben die beiden in Reihe geschalteten Dioden ohne Vorwiderstand am Arduino. Ich habe das während meiner Startampelbastelei selber so gemacht, als Dauerlösung für den Rennbetrieb würde ich das aber nicht empfehlen.
Abbildung 7Das erste Bastelmaterial ist angekommen, der Lötkolben kann schon mal warm laufen, mir kribbelt es bereits in den Fingern....
Meine Ampel soll von zwei Seiten sichtbar sein, das heißt pro Arduino Port müssten 4 LEDs angesteuert werden. Die Arduino Pins sind für jeweils maximal 40 mA ausgelegt, zwei LED Stränge parallel würden mit 50 mA den Pin definitiv überlasten. Daher verwende ich das Transistor Darlington Array des ULN2003 als Schalter zur Entlastung der Arduino Pins. Die Schalter werden direkt an den LEDs der Ampel eingebaut und separat über einen 12V Gleichspannungsregler aus der Bahn mit Strom versorgt. Damit müssen zwischen Arduino und Ampel nur noch schwache Schaltsignale übertragen werden und die Verkabelung zwischen Arduino und Ampelbrücke kann dünn und lang ausfallen ohne die Helligkeit der LED zu beeinflussen. Auch unterschiedliche Netzteile mit 14,8 V oder 18 V haben damit keinen Einfluss auf die Helligkeit der LED's. Hier die notwendige Treiberschaltung:
Abbildung 8Schaltplan des LED Treibers für die Carrduino Startampel
Die Diode D1 dient zur Entkopplung der Treiberschaltung vom Arduino, ohne diese Diode kann der Arduino die Daten nicht mehr sauber decodieren. Für die Verbindung zwischen der Treiberschaltung und dem Arduino verwende ich 10-adriges Flachbankkabel und für J1 kommt ein entsprechender Pfostenverbinder zum Einsatz. Für die Spannungsversorgung und Masse werden jeweils zwei Adern des Flachbandkabels parallel verwendet. Zusätzlich zu diesen vier Versorgungsleitungen werden fünf Adern für die Ansteuerung benötigt, womit eine Ader frei bleibt. Über diese könnte man in nachfolgenden Versionen beispielsweise einen Summer oder einen sechsten Diodenstrang schalten. Jeweils vier Dioden werden in Reihe an einem Eingang des Darlignton Arrays geschaltet, als Vorwiderstand kommt bei 12 V Versorgungsspannung ein 100 Ω Widerstand pro Strang zum Einsatz.
Abbildung 9Platinendesign des LED Treibers. Die Bestückungsseite ist nicht erkennbar, da die Platinen durchsichtig dargestellt werden, bitte den Text beachten.
Die LEDs werden auf zwei Platinen aufgelötet und in der sogenannten Cordwood Bauweise miteinander verbunden. Hierzu braucht man keine Platine ätzen oder fräsen, das funktioniert mit doppelseitig beschichteten Lochrasterplatinen ganz hervorragend. Blau gezeichnet sind in Abbildung 8 alle Drahtverbindungen, die von Hand verlegt werden müssen. Mit den Buchstaben A-E sowie Z sind alle Cordwood Verbindungen zwischen den beiden Platinen gekennzeichnet. Die Zahlen 1-10 bezeichnen die Verlötungen des Flachbandkabels. An dem türkis gezeichnete Punkt 6 ist die unbelegte Ader Nr. 6 des Flachbandkabels verlötet, damit sie nicht frei zwischen den Platinen hängt und somit keinen Schaden anrichten kann. Achtung! Damit alle Verbindungen sichtbar werden, sind die Platinen in Abbildung 8 durchsichtig gezeichnet. Das kann zu Verwirrung führen, weil die Bauelemente entweder in der Draufsicht oder in der Durchsicht und damit jeweils spiegelverkehrt dargestellt sein können. In der Layoutgrafik betrifft das hauptsächlich den ULN2003 sowie den 7812. Bitte nicht verunsichern lassen, was in Abbildung 8 auf den ersten Blick noch sehr kompliziert aussieht, ist in der Praxis ist das halb so schlimm. Auf dem nachfolgenden Foto kann man sehr schön erkennen, wo die Reise hingehen soll.
Abbildung 10Erster Testaufbau des LED-Treibers, die Platinen sind noch provisorisch an den ungekürzten LED-Beinchen verlötet
In diesem Stadium kann die komplette Ampel an dem in Abbildung 4 gezeigten Testaufbau getestet werden. Die Versorgungsspannung des LED-Treibers wird nach dem Gleichrichter abgenommen. Die Verbindung zwischen Steckbrett und Flachbandkabel erfolgt über den Pfostenverbinder und Drahtlitzen. Ich hatte mir für diese Zwecke extra eine zehnpolige Breakout-Stiftleiste gebaut. Die Steuerleitungen 1-5 des Treibers können parallel zu den LEDs auf dem Steckbrett betrieben werden.
Abbildung 11Zehnpolige Breakout-Stiftleiste für Testverbindungen zwischen Steckbrett und LED-Treiber
Wenn alles soweit funktioniert, kann mit dem mechanischen Aufbau begonnen werden. Um es mir einfach zu machen, verwende ich für das Gestell schwarze Plastikrohre aus dem Baumarkt mit einem Durchmesser von 7 mm. Die Stützen haben eine Höhe von 10 cm und die Ampelbrücke wird 20 cm breit. Diese Werte passen für die 1:43 Bahn sehr gut, bei anderen Bahnen müssen die Maße natürlich entsprechend angepasst werden.
Abbildung 12Der LED-Treiber ist erstmalig an der Ampelbrücke montiert und soll testweise verkleidet werden
Vor der endgültigen Verschraubung werden die Beinchen der LEDs auf der einer Platine komplett gekürzt. Auf der anderen Seite bleiben die Beinchen für die Verbindungen A-E in voller Länge stehen. Für die Verbindung Z verwende ich ein kurzes Stück flexible Litze, damit ich die Position der Platinen während des Zusammenbaus noch anpassen kann. Erst wenn alles soweit passt, werden die beiden Treiberplatinen final miteinander verlötet. Dazu werden die stehen gebliebenen Beinchen der LEDs auf die richtige Länge gekürzt und auf der Gegenseite verlötet.
Abbildung 13Detailansicht der fertig zusammen gelöteten LED-Platinen
Die Brücke ist jetzt soweit fertig, als nächstes muss nur noch der Arduino, die Decoderwiderstände und die Spannungsversorgung soweit verkleinert werden, dass die Bauteile unter eine D143 Schiene passen. Anstelle des in den bisherigen Testaufbauten verwendeten Arduino Nano verbaue ich in der echten Ampel den Arduino Mini. Der Mini hat den Vorteil, dass er auch ohne verlöteten Stecker ausgeliefert wird (without headers). Er ist damit wesentlich flacher als der Nano und passt perfekt unter die D143 Schienen. Achtung! Einige Anbieter verkaufen den Mini nur mit verlöteten Steckerleisten, also bitte unbedingt darauf achten, dass man eine "headless" Version erhält.
Abbildung 14Links der Arduino Nano, rechts der Mini ohne Verbindungsstecker.
Der Mini besitzt allerdings keine 12 digitalen Ein-/Ausgabepins, die Pin-Definition im Sketch muss also entsprechend angepasst werden. Zur Ansteuerung der LEDs verwende ich die Pins 3-7, Pin 2 bleibt wie bisher als Eingangspin für die Bahndaten erhalten. Der reduzierte Sketch mit den PORTB Befehlen funktioniert auf dem Mini nicht, die PORT- und DDR-Befehle müssten an die verfügbaren Pin Nummern des Mini angepasst werden. Auf dem Mini ist wegen der fehlenden Pins nur der PORTD Befehl verfügbar, dieser wirkt immer gleichzeitig auf die Pins 0 bis 7. Die Pins 0 und 1 sind die TX und RX Ports für die Programmierung des Arduinos und der Pin 2 wird bei mir ausschließlich als Eingang für die Decodierung verwendet. Damit diese Ports nicht jedes Mal mit gesetzt werden, müssten wie im Port Manipulation Tutorial beschrieben, entsprechende UND/ODER Operationen eingebaut werden. Das ist, wie ich bereits oben beschrieben habe, ein klassisches Beispiel dafür, dass der Code hardwareabhängig und unverständlich wird. Der Mini besitzt auch keinen USB Anschluss und muss daher über den zusätzlichen USB Serial Light Adapter programmiert werden. Zwischen dem USB Adapter und dem Mini wird gemäß des Arduino Mini Guides noch ein kleines Adapterkabel mit einem Kondensator benötigt. Dieses Kabel habe ich fest mit dem Mini verlötet und mit einem 5-poligen Stecker versehen, so dass ich den Arduino in der fertigen Startampel jederzeit neu programmieren kann. Das Progammierinterface ist in Abbildung 17 zu sehen.
Abbildung 15Schaltplan des Carrduino Startampel Basismoduls zur Spannungsversorgung und Signalaufbereitung
Die restlichen Bauteile für die Spannungsversorgung und den Spannungsteiler für die Dekodierung habe ich in einer separaten Platine zu einem eigenständigen Modul zusammengefasst. Dieses Modul ist universell einsetzbar, ich verwende es bereits für erste Tests an der Carrduino Weiche und dem Carrduino Fahrzeugdecoder. Das Platinen Layout sieht wie folgt aus:
Abbildung 16Layout des Carrduino Startampel Basismoduls zur Spannungsversorgung und Signalaufbereitung
Das Basismodul muss ebenfalls unter die D143 Schiene passen. In der klassischen, diskreten Bauweise ist das nicht möglich. Durch die Verlötungen auf der Rückseite der Platine und die Bauteile auf der anderen wird die Platine leider zu hoch und passt nicht mehr unter die 1:43 Carrera Schiene. Eine kleine Modifikation schafft Abhilfe. Die DIL/DIP Bauteile werden einfach auf der kaschierten Platinenseite verlötet. Die Beinchen auf der anderen Seite werden bündig mit der Platine abgekipst. Damit passt die Platine wieder perfekt unter die 1:43 Schienen.
Abbildung 17Das Startampel Basismodul in DIP/DIL-SMD Bauweise um die Bauhöhe möglichst gering zu halten
Jetzt ist es an der Zeit die Einzelbausteine zusammen zu setzen. Das Basismodul wird zusammen mit dem Arduino Mini auf der Rückseite einer Carrera 1:43 Schiene mit ein paar Klecksen Heißkleber fixiert. Hier sieht man auch erstmalig den Kontaktstecker zum USB-Serial-Adapter. Die Verbindung zum 10-Ploligen Pfostenverbinder erfolgt nicht über einen entsprechenden Pfostenstecker. Dieser ist wegen seiner Umrandung zu dick für die Montage unter der Schiene. Ich verwende einfach 10 Pole einer doppelten Stiftleiste, die ebenfalls mit Heißkleber in eine Auspaarung der Schiene geklebt wird.
Abbildung 18Einbau des Arduino Mini und des Basismoduls unter eine Carrera 1:43 Schiene
Jetzt fehlen nur noch ein paar mechanische Bastelarbeiten bis zur endgültigen Fertigstellung. Die Ampelbrücke wird auf eine Bodenplatte aus Sperrholz gesteckt. Die notwendige Schablone im Maßstab 1:1 liegt im Open Document Format im Experimentierkasten.
Abbildung 19Schablone der Bodenplatte der Startampel
Mit der Schablone werden zwei 5 mm Sperrholzstücken ausgesägt. Sie werden auf ein Stück 1mm dickes Flugsperrholz aufgeleimt. Damit die Dicke stimmt, leime ich oben auf die Sperrholzstücke noch eine weitere Schicht Flugsperrholz in der Form der Schablone. Wenn alles verleimt ist, die Kanten schleifen. Zur Halterung der Brücke werden vier M4 Senkkopfschrauben von unten in die fertige Bodenplatte geschraubt. Mit einer Laubsäge wird noch schnell die Aussparung für den Stecker erzeugt, dann kann die gesamte Platte mit matter, schwarzer Farbe lackiert werden.
Abbildung 20Fertig aufgebaute und lackierte Bodenplatte der Startampel
Die Verkleidung der Ampel wird auf Fotopapier ausgedruckt. Die Löcher stanzt man mit einem 5 mm Locheisen. Auch hier findet ihr die Vorlage im Open Dokument Format im Experimentierkasten. Damit kann sich jeder das Aussehen der Ampel an seine Wünsche anpassen. Ich bin schon ganz gespannt auf kreative Ideen und würde mich über Einsendung eurer Designs freuen. Damit ist es geschafft, das Rennen kann beginnen...
Abbildung 21Die fertige aufgebaute D143 Carrduino Startampel
Ich wünsche viel Spaß und Erfolg beim Nachbauen.
Experimentierkasten
Alle Dateien für eigene Experimente zum Download auf einen Blick
- Fritzing Steckbrett Image des B250D, Scalable Vector Grafics, svg
- Fritzing Platinen Image des B250D, Scalable Vector Grafics, svg
- Fritzing Schaltplan Image des B250D, Scalable Vector Grafics, svg
- Fritzing Icon des B250D, Scalable Vector Grafics, svg
- Fritzing Bauelement Gleichrichter B250D, Fritzing Datei, fzpz
- Fritzing Datei des Decodierers, Fritzing Datei, fzz
- Programmierdatenwort Befehl Nr. 16, Open Dokument Datei, ods
- Programmierdatenwort Befehl Nr. 16, Portable Document Format, pdf
- Steckplatine des Carrera Style Startlichts, Portable Network Graphics, png
- Schaltplan des Carrera Style Startlichts, Portable Network Graphics, png
- Arduino Sketch Startampel Carrera-Style, ASCII Text, ino
- Arduino Sketch Startampel Carrera-Style Kurze Version, ASCII Text, ino
- Schaltplan des LED-Treibers, Portable Network Graphics, png
- Schaltplan des LED-Treibers, gEDA Datei, sch
- Schaltplan des LED-Treibers, Portabel Document Format, pdf
- Platinenlayout des LED-Treibers, Portabel Network Graphics, png
- Platinenlayout des LED-Treibers, Open Document Datei, odg
- Platinenlayout des LED-Treibers, Portable Document Format, pdf
- Schaltplan der Versorgungsplatine, Portable Network Graphics, png
- Schaltplan der Versorgungsplatine, eEDA Datei, sch
- Schaltplan der Versorgungsplatine, Portable Document Format, pdf
- Layout der Versorgungsplatine, Portable Network Graphics, png
- Layout der Versorgungsplatine, Open Document Datei, odg
- Layout der Versorgungsplatine, Portable Document Format, pdf
- Bodenplatte 1:43 der Startampel, Open Document Datei, odg
- Bodenplatte 1:43 der Startampel, Portable Document Format, pdf
- Verkleidung 1:43 der Startampel, Open Document Datei, odg
- Verkleidung 1:43 der Startampel, Portable Document Format, pdf
Erstveröffentlichung: Februar 2013
Home /
Carrera-Hacks
-
CC BY-NC-SA
-
Impressum
-
Kontakt
Powered by: bluefisch, Arduino, Fritzing, LibreOffice, Inkscape, gEDA and the gimp
Powered by: bluefisch, Arduino, Fritzing, LibreOffice, Inkscape, gEDA and the gimp