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.

Carrduino Startampel Abbildung 1
3,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.

Carrera Startlicht 30354 Abbildung 2
Das 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.

Die LED Reihe am Carrera Startlicht 30354 Abbildung 3
Detailansicht 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.

Datenwort Befehl 16 Abbildung 4
Der 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.

Steckbrett Ansicht der einfachen Startampel Abbildung 5
Testaufbau 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.

Schaltplan der Carrera Style Startampel Abbildung 6
Schaltplan 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                                          
}                                
Der Sketch ist nicht gerade elegant, die vielen digitalWrite Befehle und for-Schleifen blähen den Code unnötig auf. Mit Hilfe von Bitoperationen, Masken und direkter Adressierung der Ports kann die Switch-Case Anleitung deutlich kürzer gestaltet werden. Allerdings leidet darunter die Verständlichkeit des Codes, was gerade für Einsteiger und Nicht-Programmierer unschön ist. Außerdem ist der Code nicht mehr auf alle Arduino-Plattformen übertragbar, weil er hardwareabhängig geworden ist. Don Cross schreibt in seinem Arduino Bit Math Tutorial treffend zu dieser Programmierweise:

"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                                          
}                                
Diese Version ist natürlich deutlich kürzer, aber auch nicht ganz sauber. So setze ich beispielsweise mit dem PORTB-Befehl jedes Mal ungewollt den Port 13 mit, obwohl dieser nicht gebraucht wird. Warum? PORTB wirkt immer gleichzeitig auf die Pins 8 bis 13. Soll Pin 13 nicht mit gesetzt werden, müsste man mit Masken und einer bitweisen UND und ODER Anweisung arbeiten, wie es im Port Manipulation Tutorial ausführlich beschrieben wird. Das habe ich an dieser Stelle einfach geschlabbert.

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.

Bauteile für die Startampel Abbildung 7
Das 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:

Schaltplan der Carrduino Startampel Abbildung 8
Schaltplan 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.

Schaltplan der Carrduino Startampel Abbildung 9
Platinendesign 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.

Testaufbau des LED-Treibers Abbildung 10
Erster 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.

Breakout-Stiftleiste 10-polig Abbildung 11
Zehnpolige 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.

Die aufgebaute Ampel soll verkleidet werden Abbildung 12
Der 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.

Cordwood Aufbau der Ampelbrücke Abbildung 13
Detailansicht 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.

Größenvergleich zwischen dem Arduino Nano und dem Mini Abbildung 14
Links 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.

Schaltplan der Basiseinheit mit Spannungsversorgung und Signal Abbildung 15
Schaltplan 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:

Layout der Basiseinheit mit Spannungsversorgung und Signal Abbildung 16
Layout 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.
DIL/DIP-SMD Bauweise des Startampel Baismoduls Abbildung 17
Das 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.
Montage des Minis und des Basismoduls unter einer Schiene Abbildung 18
Einbau 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.
Schablone für die Bodenplatte der Startampel Abbildung 19
Schablone 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.
Bodenplatte der Startampel Abbildung 20
Fertig 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...
Fertige Startampel Abbildung 21
Die 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

  1. Fritzing Steckbrett Image des B250D, Scalable Vector Grafics, svg
  2. Fritzing Platinen Image des B250D, Scalable Vector Grafics, svg
  3. Fritzing Schaltplan Image des B250D, Scalable Vector Grafics, svg
  4. Fritzing Icon des B250D, Scalable Vector Grafics, svg
  5. Fritzing Bauelement Gleichrichter B250D, Fritzing Datei, fzpz
  6. Fritzing Datei des Decodierers, Fritzing Datei, fzz
  7. Programmierdatenwort Befehl Nr. 16, Open Dokument Datei, ods
  8. Programmierdatenwort Befehl Nr. 16, Portable Document Format, pdf
  9. Steckplatine des Carrera Style Startlichts, Portable Network Graphics, png
  10. Schaltplan des Carrera Style Startlichts, Portable Network Graphics, png
  11. Arduino Sketch Startampel Carrera-Style, ASCII Text, ino
  12. Arduino Sketch Startampel Carrera-Style Kurze Version, ASCII Text, ino
  13. Schaltplan des LED-Treibers, Portable Network Graphics, png
  14. Schaltplan des LED-Treibers, gEDA Datei, sch
  15. Schaltplan des LED-Treibers, Portabel Document Format, pdf
  16. Platinenlayout des LED-Treibers, Portabel Network Graphics, png
  17. Platinenlayout des LED-Treibers, Open Document Datei, odg
  18. Platinenlayout des LED-Treibers, Portable Document Format, pdf
  19. Schaltplan der Versorgungsplatine, Portable Network Graphics, png
  20. Schaltplan der Versorgungsplatine, eEDA Datei, sch
  21. Schaltplan der Versorgungsplatine, Portable Document Format, pdf
  22. Layout der Versorgungsplatine, Portable Network Graphics, png
  23. Layout der Versorgungsplatine, Open Document Datei, odg
  24. Layout der Versorgungsplatine, Portable Document Format, pdf
  25. Bodenplatte 1:43 der Startampel, Open Document Datei, odg
  26. Bodenplatte 1:43 der Startampel, Portable Document Format, pdf
  27. Verkleidung 1:43 der Startampel, Open Document Datei, odg
  28. 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