Keine Ahnung vom programmieren

Hallo zusammen,
ich bin der Jürgen, begeisterter Modellbauer, und habe jetzt ein riesiges Problem. Leider habe ich null Ahnung vom programmieren. Habe mir für ein Projekt ein Arduino Leonardo zugelegt. Mit dem Arduino möchte ich so eine Art Funktionsmodell realisieren. Folgendes soll geschaltet werden, LEDs, vier Motoren (nur eine Drehrichtung), und falls machbar, noch Motorsound von SD. Vorhanden sind Arduino, zwei Motortreiber L293D, Breadboard, Kartenlesegerät WTV020-SD Mini (16Pin) und der üblichen Kleinkram. Die Motoren sind Micromotoren aus Microservos (1,5 bis 3 Volt), und sollen lediglich einen kleinen Propeller antreiben.
Vorgestellt habe ich mir den Programmablauf so (gestartet soll das Programm mittels Schalter oder Taster):

  1. sechs LEDs werden gleichzeitig eingeschaltet, und bleiben an bis Programmende
  2. acht LEDs werden zugeschaltet, und bleiben an bis Programmende
  3. erster Motor wird gestartet (langsam zu schnell) und bleibt an
  4. zweiter Motor startet
  5. dritter Motor startet
  6. vierter Motor startet
    6a. Falls möglich, sollte mit dem Start des ersten Motors ein Soundfile abgespielt werden.
  7. zwei LEDs werden eingeschaltet und leuchten ca. 1 Minute
  8. drei LEDs werden nacheinander eingeschaltet (jeweils mit 10 Sek. Verzögerung) und bleiben 2 Minuten an
  9. alle Motoren fahren gleichzeitig runter (schnell zu 0)
  10. Das Programm endet ca. 20 Sek. nach Motorstillstand.
    Als Gesamtlaufzeit habe ich mir so ca. 10 Minuten vorgestellt.

Ist sowas überhaupt möglich?

Was das "handwerkliche" angeht, habe ich wie gesagt keine Probleme, aber an das Programmieren traue ich mich nicht so recht ran. Ich weiß, ich will da ne ganze Menge , aber vielleicht kann mir ja trotzdem jemand helfen?
In der Hoffnung auf Antwort
Jürgen

Weil die Reihenfolge genau festgelegt ist, kann man das sehr leicht umsetzen - auch ohne große Programmierkenntnisse.

Du brauchst die 4 PWM-Pins für die Motoren (die man auch über einen Transistor steuern kann), und wenn ich richtig gezählt habe 6 digitale Ausgänge für die LEDs. Nur Mut, das packen wir schon! :wink:

[edit] Sound abspielen könnte komplexer werden, das heben wir uns als krönenden Abschluss auf. :smiley:

Das ist möglich, und sogar sehr einfach :-).
Eigentlich ein gutes Beispiel zum lernen!
Ich würde an deiner Stelle langsam anfangen, z.B. mit den 6 und den 8 LEDs.
gruß
Bernward

Nasenbaer:
Ist sowas überhaupt möglich?

Ja, natürlich ist das möglich.

Um 6 oder 8 LEDs auf einmal zu schalten, würdest Du zwar noch einen Schalttransistor oder Relais benötigen. Und Dein Motortreiber ist ein Schrittmotortreiber und daher nicht zur Regelung von Gleichstrommotoren geeignet. Also die Hardware müßtest Du nochmal überdenken.

Sofern alle Schritte sequentiell nacheinander ablaufen und jeder nachfolgende Schritt erst dann startet, wenn der vorangegangene Schritt vollständig abgeschlossen ist, dann ist es softwareseitig sogar extrem einfach realisierbar: Dann kannst Du alle Schaltschritte nacheinander programmieren und zwischendurch hältst Du den Programmablauf mit "delay()" für eine bestimmte Zeit an.

Sobald alerdings Aktionen verschiedener Schritte "gleichzeitig" ablaufen sollen, wird es kompliziert. Beispiele:

  1. sechs LEDs werden gleichzeitig eingeschaltet, und bleiben an bis Programmende
    ==> einfach
    Wird kompliziert, sobald auch nur eine einzige LED blinken soll, während nachfolgende Schritte ablaufen.

Oder:
7. zwei LEDs werden eingeschaltet und leuchten ca. 1 Minute
8. drei LEDs werden nacheinander eingeschaltet (jeweils mit 10 Sek. Verzögerung) und bleiben 2 Minuten an
==> einfach, wenn Schritte nacheinander ablaufen
Wird kompliziert, wenn die LEDs aus Punkt 8. bereits angeschaltet werden sollen, während die LEDs aus Punkt 7. noch leuchten.

Sobald Du eine "Not-AUS" Funktion per Schalter benötigst, um die Sequenz abbrechen zu können, würde es ebenfalls kompliziert. Man könnte alternativ als "Not-AUS" einen "Strom-Aus" Schalter vorsehen.

Wie gesagt, eine reine sequentielle Schritt-nach-Schrittsteuerung ist einfach mit delay() zwischen den Schaltschritten machbar.

Eine echte Programmsteuerung, bei der Aktionen "gleichzeitig" ablaufen, z.B. LEDs blinken während andere Schaltvorgänge stattfinden sollen, wird dagegen recht aufwändig in der Realisierung.

Erst mal vielen Dank für euere Antworten.
@Jurs
Darin liegt ja das Problem, dass es ebend nicht rein sequentiell ablaufen soll. Sequentiell würde ich ja zur Not auch noch selber hinkriegen, aber in meinem Projekt muß ich ja auf das DELAY verzichten, wie ich mich schon informiert habe. Was den L293D angeht, bist Du da sicher? Nach Datenblatt und Schaltbild beinhaltet der Chip nur zwei Motortreiber, also eigentlich nichts anderes als zwei Transistoren. Die LEDs werden natürlich eine eigene Stromversorgung bekommen. Ob über Relais oder Transistor ist noch nicht ganz klar, wobei ich aber eher zu Transistoren tendiere.
Gruß
Jürgen

Nasenbaer:
@Jurs
Darin liegt ja das Problem, dass es ebend nicht rein sequentiell ablaufen soll. Sequentiell würde ich ja zur Not auch noch selber hinkriegen, aber in meinem Projekt muß ich ja auf das DELAY verzichten, wie ich mich schon informiert habe.

Weil Du parallel zu anderen Aktionen noch WAV-Sound per Arduino von einer SD-Karte abspielen möchtest ohne ein autark abspielfähiges Sound-Shield zu verwenden?

Oder noch aus einem anderen Grund? Weswegen, welcher Schaltschritt erfordert das?

Aus dem von Dir oben gezeigten Ablauf ist es für mich nicht ersichtlich, dass es mit delay() nicht realisierbar weil kein rein sequentieller Ablauf ist.

Wenn es nur eine oder zwei Stellen sind, an denen zeitlich überlappend geschaltet werden muß, kannst Du den Ablauf ggf. durch Einfügen von Zwischenschritten doch noch sequentialisieren. Dazu müßte man aber genau wissen wo. Und Sound könnte man parallel abspielen, wenn man ein autarkes Sound-Shield verwendet, das nach dem Starten eines Sounds von alleine weiterspielt.

Wenn es komplexer werden soll, z.B. LEDs nicht entsprechend der Beschreibung dauernd "ein" sein sollen, sondern beispielsweise rhythmisch blinken sollen während andere Schaltvorgänge ablaufen, wird es dagegen vergleichsweise kompliziert.

Nasenbaer:
Was den L293D angeht, bist Du da sicher? Nach Datenblatt und Schaltbild beinhaltet der Chip nur zwei Motortreiber, also eigentlich nichts anderes als zwei Transistoren.

Ja klar, die Schrittmotoren brauchen auch Leistung und die muß geschaltet werden. Wenn ich die Angebote bei eBay durchgehe, wird der L293D jedenfalls nur als Schrittmotortreiber für Schrittmotoren kleinster Leistung angeboten.

Zum L293D:

Der L293D IC beinhaltet 4 Halb-H-Brücken Treiber. Damit lassen sich 2 DC-Motoren bidirektional betreiben (als 2-fach H-Brücke), oder 1 Schrittmotor birektional. Die Belastbarkeit pro Halbbrücke beträgt 600mA. Der L293D beinhaltet im Gegensatz zum pin-kompatiblen L293 und dem großen Bruder L298 die interne Freilaufdioden. Diesen schützen den IC vor den, vom Motor ausgehenden, Spannungsspitzen.

Quelle: http://wiki.ctbot.de/index.php/L293D

Grüßle Bernd

Nasenbaer:
Erst mal vielen Dank für euere Antworten.
@Jurs
Darin liegt ja das Problem, dass es ebend nicht rein sequentiell ablaufen soll.

Aber die Sequenz hast du doch vorgegeben? Inwiefern erwartest du Änderungen?
Die L293D sind komplette H-Brücken, eignen sich sowohl für kleine Schrittmotoren als auch für "normale" Gleichstrommotoren.

Wenn du 4 kleine DC-Motoren in nur 1 Richtung, aber mit drosselbarer Geschwindigkeit steuern willst, kannst du das wahlweise auch mit 4 einzelnen Transistoren und 4 PWM Pins machen. ( Freilaufdioden erforderlich )

Ströme unter 100 mA kann man mit bipolaren Transistoren steuern, auch wenn das erste was man liest immer "MOSFET" ist.

LED's werden über Transistoren, nicht Relais, gesteuert. ( Meine Meinung )
Redest du von kleinen Signal-LED oder von solchen zur Beleuchtung ?

Und eigentlich ist es einfach, mehrere Sachen gleichzeitig und wahlweise unabhängig von anderen zu machen, wenn jede von mehreren Funktionen immer nur kurz läuft und Zeitsteuerung nicht über delays macht.

Vor allem ist es viel besser erweiterbar, also auf Dauer sogar einfacher.

Hallo!
Vielleicht habe ich mich auch ein wenig verquerr ausgedrückt, was die Abfolge angeht. :~
Das Programm soll folgendes machen:
Die ersten 6 LEDs werden gleichzeitig eingeschaltet. Nach Ablauf einer Zeit X werden weitere 8 LEDs dazugeschaltet, so das nun 14 LEDs gleichzeitig leuchten. Während die LEDs leuchten werden nacheinander 4 Motoren eingeschaltet (am schönsten wäre es, wenn sie langsam hochlaufen würden) und bleiben genauso wie die LEDs eingeschaltet. Während die 14 LEDs und 4 Motoren in Betrieb sind, sollen noch zusätzlich für eine Zeit X 2 LEDs eingeschaltet, und auch wieder ausgeschaltet werden. Nach einer weiteren Zeit X sollen sich die Motoren ausschalten (wenn möglich langsam runterlaufend, und können das auch alle gleichzeitig machen), während die 14 LEDs noch weiterleuchten, und die sich erst nach einer Zeit X komplett auszuschalten, was auch gleichzeitig das Programmende bedeutet. Auf die Blinkfrequenz der unter 8. erwähnten LEDs könnte ich auch verzichten.
Zur Info: Die Schaltung ist für ein viermotoriges Flugzeugmodell mit Innenbeleuchtung Positionslichtern und Landescheinwerfern gedacht, und da es sich um ein altes Flugzeug handelt, müssen die Motoren auch mit einem gewissen zeitlichen Versatz starten.
Für mich ist ebend das Problem, dass sich die einzelnen Baugruppen zwar nacheinander einschalten, aber dann auch eingeschaltet bleiben müssen, speziell die Motoren. Und wie gesagt, auf die Schalterei der unter 8. erwähnten Dioden könnte ich verzichten, genauso, wie erst mal auf das Abspielen eines Sounds.
Zu den LEDs noch kurz. Es handelt sich durchweg um SMDs die mit max. 1,5 Volt betrieben werden, und nicht mehr als 20mA ziehen. Da die aber eh über Transistor angesteuert werden, ist das alles nicht so kritisch.
Gruss
Jürgen

Na dann hatten wir eine unterschiedliche Auffassung des Wortes sequentiell. Ich bleibe dabei: Recht einfach realisierbar. :wink:

Du beschreibst es wie eine Filmhandlung, nicht wie einen Flugsimulator. Da passt sequentiell schon ganz gut.
Du willst ja nicht interaktiv eingreifen und mit einer Fernseher-Fernbedienung (sorry: heutzutage ist Smartphone angesagter) Teile des Programms von Hand kontrollieren.
Und am Ende des Programms wartet Arduino ewig (auf einen Reset) oder hat einen Pin übrig mit dem er sich selbst abschaltet ?

Ob delay oder millis(): Stell dir eine Liste auf wann was passiert, bis sie etwa so genau ist wie dies:

Zeit (ms) Pin  Wert  Kommentar
---------------------------------------
  1000,  LED_A ,  1   // 6 LED an
  3000,      0 ,  0   // nur warten ( 3 sek )
 -2000,   LED_B,  1   // zufällige Wartezeit ( 0 .. 2 sek ) ,  dann 8 LED an
   500,    M1 , 50      // Motor langsam hochfahren
   800,    M1 , 80      // in mehreren Stufen
   800,    M1 , 120
   300,    M1 , 160
   200,    M1,  120
   500,    M2 , 50
   800,    M2 , 80
   800,    M2 , 120
   300,    M2 , 160
   100,    M3,  50     // M3 startet  
   100,    M2,  120    // M2 Startphase Ende 
... ( alle Motoren starten )
  5000,  LED_X, 1    // Navigationslichter an
  3000,  M1, 255      // alle Motoren Vollgas
    20, M4, 255       // fast gleichzeitig
     0, M3, 255
    10, M2, 255
... das weitere ist mir zu mühsam, aber dir macht es sicher Spass, Nasenbaer.
...
 10000, LED_A , 0    // letzte 6 LED aus.

Jetzt fehlt nur noch , diese Tabelle in C-Syntax zu konvertieren, sie im Flash-Speicher abzulegen, und dann einen kleinen Interpreter su schreiben der sie Zeile für Zeile abarbeitet. :wink:

Alternativ schreibt man die Liste als Reihe von Funktionsaufrufen:

  Step(1, 1000,  LED_A ,  1);  
  Step(2, 3000,      0 ,  0);   // nur warten ( 3 sek )
  Step(3, -2000,   LED_B,  1);   // zufällige Wartezeit ( 0 .. 2 sek ) ,  dann 8 LED an
  Step(4, 500,    M1 , 50);
  Step(5, 800,    M1 , 80);
  ...

Ohne delay muss jeder Step-Aufruf wissen, wer er ist und die Steps koordinieren sich über eine globale Variable.
Mit delay bräuchte man tatsächlich den ersten Funktionsparameter ( 1, 2,3 ...) nicht und könnte leichter Schriite rausnehmen und einfügen...

Aber das geht schon viel zu sehr ins Detail, da will ich dem der's schlussendlich schreibt, nicht vorgreifen.

michael_x:
Ob delay oder millis(): Stell dir eine Liste auf wann was passiert, bis sie etwa so genau ist wie dies:
...
Jetzt fehlt nur noch , diese Tabelle in C-Syntax zu konvertieren, sie im Flash-Speicher abzulegen, und dann einen kleinen Interpreter su schreiben der sie Zeile für Zeile abarbeitet. :wink:

Genau, das sieht alles ganz einfach aus und der "Interpreter", der in der loop die Datenstruktur abarbeitet, kann auch recht einfach sein.

Ich würde übrigens in der abzuarbeitenden Liste noch einen vierten Parameter mit dazunehmen, ein einzelner Buchstabe reicht. Und zwar würde ich in diesem Buchstaben die auszuführende Funktion codieren.

Also mehr in der Art:

 F  Zeit (ms) Pin  Wert  Kommentar
---------------------------------------
'D',  1000,  LED_A ,  1   // 6 LED an
'W', 3000,      0 ,  0   // nur warten ( 3 sek )
'W', -2000,   LED_B,  1   // zufällige Wartezeit ( 0 .. 2 sek ) ,  dann 8 LED an
'A',  500,    M1 , 50      // Motor langsam hochfahren
'A',   800,    M1 , 80      // in mehreren Stufen

Wobei der Buchstabe dann codiert, was für eine Funktion jeweils gestartet wird:
'D' ==> Eine Funktion mit "digitalWrite()" und warten auf die nächste Aktion
'W' ==> Eine reine Warten-Funktion
'A' ==> Eine Funktion mit "analogWrite()" und warten auf die nächste Aktion

Und weitere Aktionen könnte man mit zusätzlichen Buchstaben codieren. Mal angenommen, jemand programmiert eine Waschmaschine und zwischendurch soll eine Heizung die Waschlauge auf Waschtemperatur bringen. Dann würde man einfach eine neue Funktion, sagen wir 'T' in die Liste schreiben, und dazu eine Arduino-Funktion erstellen, die vom Interpreter aufgerufen werden kann:
'T' ==> Eine Funktion, die die Heizung einschaltet und bis auf gemessene Sensortemperatur=60°C wartet
(zum Beispiel)

Es gibt ja auch Programmsteuerungen, die nicht nur zeitgesteuert sind, sondern bei denen auch zwischendrin Sensoren auszuwerten sind, und der Fortgang des Schaltprogramms ist davon abhängig, dass vorher zuerst bestimmte Sensorwerte erreicht werden.

Ich habe mal ein bisschen durch das Forum gesucht: Schrittsteuerungen werden hier zwar nicht besonders oft explizit nachgefragt, aber gelegentlich kommt es doch vor. Oder der Fragesteller fragt nach etwas, das mit einer Schrittsteuerung zu lösen ist, ohne dass ihm das so klar ist.

Da sowas nicht besonders viel Code erfordert und im Grunde auch an keine spezielle Hardware gebunden ist, mache ich bei Gelegenheit vielleicht mal eines meiner berüchtigten "erweiterten Demoprogramme" für eine "universelle Schrittsteuerung mit Arduino", mit dem solche Schaltlisten bequem als Daten vorgegeben werden können und die loop arbeitet die Schaltbefehle und Wartezeiten ab.

eines meiner berüchtigten "erweiterten Demoprogramme"

Ich habe mich schon gewundert wo es bleibt ... :wink:

Die Schönheit kommt natürlich dadurch, dass die Liste aus Elementen vom Typ ** class Schaltschritt;** besteht und im Flash liegt,
und als leicht schreib/lesbare Include.h oder Steuerung.cpp Datei definert wird.

oder als Text von SD Card gelesen wird ...

Nasenbaer wartet sicher auch schon.

Den soundfile kann man doch sicher mit einem Digital-Pin, der einen mp3 player aktiviert, realiseren.


Alternativ kam mir in den Sinn, nicht so sehr die Sequenzierung zu betonen, sondern jedem Element eine absolute Startzeit und Dauer zu geben, mit dem es aktiviert wird. ( D.h. jedes Element wartet, startet, läuft, stoppt )
So lassen sich "beliebig viele" Aktionen parallel beschreiben. Dann braucht man keinen Schrittfolgen-Interpreter,
sondern jedes Element ist eine Funktion in loop(), die in quasi beliebiger Reihenfolge dort aufgelistet sind.
(Auch recht änderungsfreundlich)

michael_x:

eines meiner berüchtigten "erweiterten Demoprogramme"

Ich habe mich schon gewundert wo es bleibt ... :wink:

Hehe. Vielleicht hat jemand anderes ja schon was in der Schublade liegen. Oder kennt einen Link auf einen passenden Sketch, in dem sowas bereits realisiert ist. Dann kann ich mir die Mühe vielleicht sparen. Oder ich sehe mir erstmal an, was es gibt und poste dann meinen Sketch als Alternative. Bei der "Leuchtturm-Karte" gab es hier im Forum auch zwei komplett unterschiedliche Lösungen, die gepostet wurden.

michael_x:
Die Schönheit kommt natürlich dadurch, dass die Liste aus Elementen vom Typ ** class Schaltschritt;** besteht

Bei mir im Vorab-Entwurf steht: struct schaltFunktion
:wink:

michael_x:
und im Flash liegt, und als leicht schreib/lesbare Include.h oder Steuerung.cpp Datei definert wird.

oder als Text von SD Card gelesen wird ...

Nun mal nicht übertreiben, bei einem kleinen Demoprogramm!

michael_x:
Nasenbaer wartet sicher auch schon.

Keine Ahnung. Kommt mir fast vor, als wenn er sich ausgeklinkt hat und mit der Antwort zufrieden ist, dass es relativ einfach machbar ist.

michael_x:
Den soundfile kann man doch sicher mit einem Digital-Pin, der einen mp3 player aktiviert, realiseren.

Ja, das denke ich auch. Das Abspielen von Sound ist mit Sicherheit mit einem autarken Abspieler, der nur per Pin aktiviert werden braucht, am einfachsten hinzubekommen. Insbesondere für jemanden, der sich den Threadtitel "Keine Ahnung vom programmieren" ausgesucht hat.

michael_x:
Alternativ kam mir in den Sinn, nicht so sehr die Sequenzierung zu betonen, sondern jedem Element eine absolute Startzeit und Dauer zu geben, mit dem es aktiviert wird. ( D.h. jedes Element wartet, startet, läuft, stoppt )
So lassen sich "beliebig viele" Aktionen parallel beschreiben. Dann braucht man keinen Schrittfolgen-Interpreter,
sondern jedes Element ist eine Funktion in loop(), die in quasi beliebiger Reihenfolge dort aufgelistet sind.
(Auch recht änderungsfreundlich)

Es gibt ja bekanntlich immer verschiedene Möglichkeiten.
Und das nicht nur beim Leuchtturm-Sketch.
:wink:

Huhu,
ne, der Nasenbär hat sich noch nicht ausgeklinkt. Hatte nur die letzten Tage voll mit meinem kranken Hund zu tun. Was bedeutet, jeden Tag 2-3 Stunden Tierarzt, und dann Krankenwache. (Alleine von den Kosten hätte ich Microsoft beauftragen können, mir ein Programm zu schreiben. $))
Trotzdem verfolge ich jeden Tag das Forum, und versuche aus den Sketchen anderer zu lernen, um z. Bsp. meine Vorstellungen klarer definieren zu können. Für mich ist es eben sehr schwerr mir "abstrakte" Vorgänge in der Programmierung zu verinnerlichen. Man ist ja leider mit 58 auch nicht mehr der Jüngste. Und ich muß zu meiner Schande gestehen, obwohl ich Fachinformatiker bin, habe ich Programmierung noch nie gerafft. Das hätte mich damals schon fast um den Abschluss gebracht. :blush:

Gruß
Jürgen

obwohl ich Fachinformatiker bin, habe ich Programmierung noch nie gerafft. Das hätte mich damals schon fast um den Abschluss gebracht

Na, da ist das doch jetzt prima Gelegenheit, dies auf die Liste "was ich in diesem Leben noch machen will" zu setzen und sich (mit der gebotenen niedrigen Priorität) ganz entspannt einzuarbeiten.

C/C++ für Arduino ist recht überschaubar, und auf verschiedenen Ebenen mit Erfolgserlebnissen realisierbar.
C ist noch fast das gleiche wie damals ...

Das Ganze klingt ein wenig nach FSM (Finite State Machine).
Dazu gibt es für den Arduino eine Lib und auch einiges an Text zu lesen:
http://playground.arduino.cc/code/FiniteStateMachine
Hier eine sehr gute Beschreibung der Thematik
http://www.mathertel.de/Arduino/FiniteStateMachine.aspx

FSMs sind natürlich deutlich mächtiger, als reine "Schrittfunktionen", stellen aber sicher den am besten abstrahierten Ansatz für solche Probleme dar.
Mario.

So, ich habe mich mal ein wenig versucht. Aber bitte nicht lachen, ist halt alles nicht so einfach. Habe den Sketch mal so gebaut, wie ich es mir vorstelle. Ist allerdings erst 1 Motor eingebunden (Motorpart aus einem anderen Sketch geklaut und angepasst) Da habe ich allerdings noch das Problem, daß der Motor nur in eine Richtung drehen soll. Denn so wie es jetzt geschrieben ist, könnte er durch die zwei Pins ja vor und zurückdrehen, und belegt natürlich auch zwei PWM-Plätze. Momentan stehe ich aber auf dem Schlauch, wie ich das umschreiben sollte. Wie gesagt, ist mein erster Sketch.

// Saved by Simulator for Arduino V0.98D refer to vitronics.com.au
int led1 = 8; // Positionslichter
int led2 = 9; // Innenbeleuchtung
int led3 = 10; // Landescheinwerfer
int led4 = 11; // Kennungslicht Rot
int led5 = 12; // Kennungslicht Weiss
int led6 = 13; // Kennungslicht Grün
int motorPin1 = 2;
int motorPin2 = 3; // PWM-Signal

int del = 300;

void setup() {
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);
pinMode(motorPin1,OUTPUT);
pinMode(motorPin2,OUTPUT);
}

void motorStop() {
digitalWrite(motorPin1,LOW);
digitalWrite(motorPin2,LOW);
delay(100);
}

void loop()
{
digitalWrite(led1, HIGH);
delay(16000);
digitalWrite(led2, HIGH);
delay(32000);
motorStop();
digitalWrite(motorPin1,LOW);
for (int i=55; i<180; i++) {
analogWrite(motorPin2, i);
delay(50);
}
digitalWrite(led3, HIGH);
delay(16000);
digitalWrite(led3, LOW);
delay(100);
digitalWrite(led4, HIGH);
delay(500);
digitalWrite(led5, HIGH);
delay(700);
digitalWrite(led6, HIGH);
delay(500);
digitalWrite(led4, LOW);
delay(100);
digitalWrite(led5, LOW);
delay(100);
digitalWrite(led6, LOW);
delay(100);
motorStop();
digitalWrite(led2, LOW);
delay(1000);
digitalWrite(led1, LOW);
delay(1000);

while(1);
}

Probiert habe ich den Sketch mit der Pro-Version des Simulator for Arduino, und soweit lief es auch schon ganz gut. Habe auch festgestellt, daß ich erstmal tatsächlich mit DELAYS leben kann, wie ja schon einige vermutet haben.
So, nun bin ich auf eure Anmerkungen gespannt.
Gruß
Jürgen

Denn so wie es jetzt geschrieben ist, könnte er durch die zwei Pins ja vor und zurückdrehen, und belegt natürlich auch zwei PWM-Plätze. Momentan stehe ich aber auf dem Schlauch, wie ich das umschreiben sollte.

Wenn du genau hinguckst, siehst du dass nur
  digitalWrite(motorPin1,LOW); vorkommt. Also kannst du das auch ganz weglassen und die Leitung, die bisher zum MotorPin1 führt, mit GND verbinden.
Dann kannst du motorPin2 in motorPin umbenennen und fertig.

Sonst bleibt nur noch den Variablen led1 usw. bessere Namen (z.B. "Positionslichter" ) zu geben, damit man im code besser sehen kann, was passiert.

z.B. würde mir besser gefallen:

const byte Positionslichter = 8;
...
 pinMode(Positionslichter, OUTPUT);
...
 digitalWrite(Positionslichter, 1);