Im Dritten Teil des Kamera Sliders auf Basis eines Arduino geht es nun endlich um die Programmierung. Mein Quelltext nicht sonderlich lang (nur knapp 500 Zeilen), dafür erfüllt es eigentlich jeden Wunsch :)
Da die meisten nicht die Zeit und Motivation haben, sich in die Programmierung einzuarbeiten und es anfangs sehr frustrierend ist bis man ein lauffähiges Programm geschrieben hat, biete ich den Arduino Sketch zum Download an. Den Link maile ich euch zu. Bitte vorab einen Betrag eurer Wahl auf mein Paypal Konto überweisen: https://www.paypal.me/dahansi
In Dieser Anleitung gebe ich nur wieder Denkanstöße und verweise auch Teilweise auf die Programmierung der Brausteuerung, da vieles analog läuft.
Die Slider-Steuerung besteht aus nur 5 Teile:
Um überhaupt etwas sehen zu können, müssen wir das Display ansteuern. Das geht genauso wie auch bei der Brausteuerung: Arduino LCD-Display ansteuern
Mit dem Encoder möchten wir rauf / runter und bestätigen. Mit dem Potentiometer wollen wir die Größe der Schritte bestimmen (oder wollt ihr 10.000 Schritte mit dem Encoder drehen ;) ).
Zu erst fangen wir mit der PIN-Belegung an und setzen ein paar Variablen:
// Drehknopf #define DIR_CCW 0x10 #define DIR_CW 0x20 int Rotary1 = 10; // Rotary Drehknopf PIN int Rotary2 = 11; // Rotary Drehknopf PIN int RotaryButton = 12; // Rotary Button PIN int rAlt = 0; // Rotary PressStatus Alt int rWert = 0; // Rotary DrehWert //in die void setup() Funktion: void setup(){ // Rotary Encoder: pinMode(Rotary1, INPUT); // Drehknopf initialisieren pinMode(Rotary2, INPUT); // Drehknopf initialisieren digitalWrite(Rotary1, HIGH); digitalWrite(Rotary2, HIGH); pinMode(RotaryButton, INPUT); // Button initialisieren digitalWrite(RotaryButton, HIGH); // Button aktivieren }
Falls der Knopf später "falschrum" dreht, tauscht einfach die PIN-Belegung 10 und 11. Falsch gar nichts geht, habt ihr vermutlich die ganze PIN-Belegung verhauen, prüft daher nochmal genau, wo Button und die Dreh-Impuls Kabel hingehen.
Dann prüfen wir mit dem folgender Funktion, ob er gedrückt wurde. Wir machen später immer eine While-Schleife um diese Funktion im Menü. Solange diese "false" ist wird sie ausgeführt, wird der Button gedrückt, gibt die Funktion "true" zurück und die Schleife bricht ab:
/* * Knopfdruck abfragen */ boolean pushed(){ int rStatus = digitalRead(RotaryButton); if (rStatus != rAlt) { rAlt = rStatus; if(rStatus == HIGH) return true; } return false; }
Der Code für die Drehrichtung ist etwas komplizierter, sollte aber 1:1 übernommen werden können. Gibt die Funktion 1 zurück, wurde nach rechts, bei -1 nach links gedreht. Wird "false" zurückgegeben, wurde gar nicht gedreht:
// Drehimpuls abfragen const unsigned char ttable[7][4] = { {0x0, 0x2, 0x4, 0x0}, {0x3, 0x0, 0x1, 0x10}, {0x3, 0x2, 0x0, 0x0}, {0x3, 0x2, 0x1, 0x0}, {0x6, 0x0, 0x4, 0x0}, {0x6, 0x5, 0x0, 0x20}, {0x6, 0x5, 0x4, 0x0}, }; volatile unsigned char stateR = 0; int getRotary() { unsigned char pinstate = (digitalRead(Rotary2) << 1) | digitalRead(Rotary1); stateR = ttable[stateR & 0xf][pinstate]; unsigned char result = (stateR & 0x30); if(result) return (result == DIR_CCW ? -1 : 1); return false; }
Das Potentiometer ist recht simpel. Hier wird einfach ein Wert zwischen 0 und 1023 zurückgeben - je nach dem wie weit er gedreht wurde. Anhand dessen kann man deutlich schneller zu hohen Zahlen kommen.
// Poti int potPin = 2; int stepSize = 0; // zum Abfragen des Wertes einfach diesen Befehl aufrufen: stepSize = analogRead(potPin);
stepSize wäre z.B. der Wert 23 und dann zählt er immer 23 auf die aufzunehmenden Bilder dazu: 23, 64, 87, usw.
Es gibt viele Methoden ein Menü zu erstellen. Ich habe mir das ganze so überlegt:
Zu erst lade ich das Hauptmenü, dort gibt es die Auswahl zwischen "Setup Starten" und "Manueller Modus". Im Manuellen Modus kann man einzelne Bilder aufnehmen und den Slider bewegen. Im Setup kann man die Zeitrafferaufnahme starten und alles Schritt für Schritt einstellen (Anzahl Bilder, Zeit Interval, Richtung, usw).
Fangen wir mit der Funktion an, die die einzelnen Menüs lädt. Das kommt in die Void-Loop() Funktion:
//Die 2 Variablen werden zu Beginn festgelegt: /* * 0 = Hauptmenü * 1 = Setup * 2 = Manuell */ int state = 0; // Aktueller Programmteil int stateAlt = -1; // Alter Status // unter die setup-Funktion: int menuAkt = 0; // Aktueller MenüPunkt int menu[] = {0,1,2}; // Mögliche Menüs int menuSize = sizeof(menu) / sizeof(int); void loop() { if(state != stateAlt){ // Falls sich etwas ändert stateAlt = state; switch(state){ case 1: state = loadSetup(); break; // Setup Starten case 2: state = loadManuell(); break; // Manueller Modus default: state = loadMenu(); break; // Hauptmenü } } delay(1000); }
Im Prinzip sind alles einzelne Endlosschleifen, die mit dem Klick eines Buttons ausgeführt werden. Die Funktion für das Hauptmenü ist etwas komplizierter, da wir hier einen Pfeil rauf und runter bewegen der zeigt welchen Menüpunkt wir ausgewählt haben Die Funktion loadMenu() wird im Schritt zuvor aufgerufen:
boolean menuTrigger = false; int loadMenu(){ // 0: Setup starten // 1: Manueller Modus int menuAlt = 0; changeMenu(0); // Updated das Menü und zeigt die neue Pfeil Position an while(1){ int rotary = getRotary(); // Ruft ab ob der Encoder bewegt wurde if(rotary){ // Falls ja, Menü neuladen -> Pfeilposition ändern changeMenu(rotary); } if(pushed() && menuTrigger){ // Falls Button gedrückt wurde menuAkt++; return menuAkt; //Gibt die ID des neuen Menüs zurück } menuTrigger = true; } return 0; } void changeMenu(int s){ if(!s) showMenu(0); // Einfach nur Menü anzeigen -> beim ersten Aufruf else{ if(s < 0) menuAkt--; // Linksrum gedreht else menuAkt++; // Rechtsrum gedreht if(menuAkt > menuSize) // Falls Pfeil mehr als Anzahl der Menüpunkte, fängt er wieder von vorne an menuAkt = 0; else if(menuAkt < 0) // Falls kleiner 0, fängt er beim letzten Menüpunkt an menuAkt = menuSize; showMenu(menuAkt); //Neues Menü laden } } /* Pfeil */ byte arrow[8] = { B00000, B11000, B01100, B00110, B01100, B11000, B00000, }; void showMenu(int s){ lcd.createChar(0, arrow); // Pfeil anzeigen lcd.clear(); // LCD löschen lcd.setCursor(2,0); lcd.print("Setup starten"); lcd.setCursor(2,1); lcd.print("Manueller Modus"); switch(s){ case 1: lcd.setCursor(0,1); lcd.write(byte(0)); break; //Pfeil anzeigen default: lcd.setCursor(0,0); lcd.write(byte(0)); break; //Pfeil anzeigen } menuAkt = s; }
Wählt man jetzt das Manuelle Menü, wird die Funktion loadManuell über die Grundfunktion aufgerufen. In loadManuell() soll man ein Foto auslösen und den Motor bewegen können. Mir fällt gerade auf, dass ich die Motorsteuerung und den Auslöser vielleicht hätte vorher zeigen sollen, aber dann kommt das halt danach ;).
boolean loadManuell(){ setRes(16); // Geschwindigkeit des Motors digitalWrite(motorEnable,LOW); // Motor aktivieren lcd.clear(); // LCD löschen myTxt = String("Manueller Modus"); lcd.print(myTxt); int stepSize = 10; // Schrittgröße des Motors while(1){ rotary = getRotary(); stepSize = analogRead(potPin); // Motorgeschwindigkeit über das Potentiometer auslesen if(stepSize < 5) // Kleiner 5 macht mein Motor nicht mit, daher mindestens 5 möglich stepSize = 5; if(rotary){ // Wenn Rotary Encoder gedreht wird, bewegt sich der Motor vor bzw. zurück if(rotary > 0){ digitalWrite(motorDir,HIGH); steps += stepSize; }else{ digitalWrite(motorDir,LOW); steps -= stepSize; } Move(stepSize); float prozent = ((float) steps / float(maxSteps)) * 100; myTxt = String("Distanz: ") + prozent + String("% "); // Zurückgelegt Entfernung lcd.setCursor(0,1); lcd.print(myTxt); } if(pushed()){ // Wenn gedrückt wird, macht er ein Foto Serial.println("Bild!"); delay(500); shutter(); delay(500); myTxt = String("# Fotos: ") + pictureCounter; // Anzahl der Fotos zählen lcd.setCursor(0,2); lcd.print(myTxt); } } digitalWrite(motorEnable,HIGH); // Motor deaktivieren return 0; }
Das war soweit der Code für das Menü. Die Funktion fürs Timelapse ist genauso aufgebaut. Ihr müsst lediglich in einzelnen Schritten die Anzahl der Bilder, das Zeitinterval und die Laufrichtung des Sliders abfragen. Ich habe noch eine "Kann es losgehen?"-Seite gemacht, damit nicht sofort gestartet wird.
Klickt man dann, lädt es die doTimelpase Funktion. Dort wird in einer while-Schleife geprüft ob die maxBilder Anzahl bereits erreicht ist. Solange das nicht ist, wird der Slider bewegt und ein Foto geschossen. Die Distanz die der Motor zurücklegt, müsst ihr natürlich immer berechnen. Also ob er 20 Bilder auf die ganze Distanz macht oder 200 Bilder, ist ja ein erheblicher Unterschied.
Das bekommt aber jeder selber hin, der bis jetzt noch durchblickt ;) Vorher schauen, wie viele Schritte der Motor braucht, um den ganzen Slider entlang zu fahren. Bei mir waren das 52.600 Stück. Sprich so viele Bilder könnte ich machen, und der Slider bewegt sich jedes mal dazwischen.
Jetzt kommen wir zum coolsten Teil, das Auslösen der Kamera! Das ist super simpel und braucht nur ein paar Zeilen Code:
// Counter-Variable für die Bilder int pictureCounter = 0; short int shutterPin = 2; // PIN der Kamera //In die Setup-Funktion: void setup(){ pinMode (shutterPin, OUTPUT); } // Funktion zum fotografieren: void shutter(){ digitalWrite(shutterPin, HIGH); delay(50); digitalWrite(shutterPin, LOW); pictureCounter++; //Hochzählen des Counters }
Das wars es auch schon. Sobald ihr jetzt die Funktion shutter() aufruft, wird die Kamera ausgelöst.
Der letzte Teil ist die Steuerung des Motors. Das ist gar nicht so simpel und ich bin um ehrlich zu sein auch noch nicht zu 100% zufrieden. Aber der Zweck wird erfüllt und es funktioniert alles sehr gut.
Vorab ein bisschen Mathe: Schaut mal wie viel Grad pro Schritt euer Motor macht. Bei mir sind das 1,8. Jetzt rechnet ihr 360/1.8 = 200. Falls bei euch etwas anderes rauskommt, müsst ihr die 200 in meinem Code mit eurer Zahl ersetzen.
Wie gehabt, ein paar Variablen definieren und die Setup-Funktion:
const int resolution = 16; // bzw. 1/16tel const long int maxSteps = 52600; // von Links nach Rechts 17 ganze Schritt á 200 Einzel Steps int speed = 800; long int steps = 0; long int maxPics = 0; long int maxDelay = 0; short int motorEnable = 6; // HIGH = Motor deaktiviert | LOW = Motor aktiviert short int motorStep = 5; // Step short int motorDir = 4; // Dir | LOW hin zum Motor | High = Weg vom Motor boolean motorDirection = HIGH; //LOW hin zum Motor | High = Weg vom Motor short int motorM1 = 7; // \ short int motorM2 = 8; // -> Bestimmen die Revolution | M1,M2,M3 High = 1/16, M1,M2,M3 auf LOW = 1 short int motorM3 = 9; // / void setup{ // Motor pinMode(motorEnable,OUTPUT); // Enable digitalWrite(motorEnable,HIGH); // Motor deaktivieren pinMode(motorStep,OUTPUT); pinMode(motorDir,OUTPUT); pinMode(motorM1,OUTPUT); pinMode(motorM2,OUTPUT); pinMode(motorM3,OUTPUT); setRes(16); }
Hier wird bereits die erste Funktion, nämlich die setRes (für setResolution) aufgerufen. Die Resolution bestimmt das A4988-Board (also diese kleine Platine für den StepperMotor). Es gilt:
MS1-MS3 sind die Pins auf dem A4988 Board. Wenn also alle 3 auf HIGH stehen, sind die schritte nochmal viel genauer, als wenn sie auf LOW stehen. Ich habe nur alle auf LOW oder alle auf HIGH eingebaut. LOW nutze ich nur, wenn der Motor schnell zur Ausgangsposition fahren soll. HIGH sobald der Timelapse gestartet wurde. Natürlich macht es hier Sinn auch die anderen Resolutionen einzubauen, allerdings ist das dann deutlich aufwendiger, da man eine Logik einbauen müsste, wann welche Resolution genommen werden soll ;)
Der Code schaut also aus:
void setRes(int i){ if(i == 16){ digitalWrite(motorM1,HIGH); digitalWrite(motorM2,HIGH); digitalWrite(motorM3,HIGH); }else{ digitalWrite(motorM1,LOW); digitalWrite(motorM2,LOW); digitalWrite(motorM3,LOW); } }
Die Bewegung des Motors ist wieder sehr simpel. Man übergibt die Anzahl der Schritt und der Motor bewegt sich mit Hilfe einer for-Schleife bis alle Schritte fertig sind:
void Move(int steps){ for(int i = 0;i < steps;i++){ digitalWrite(motorStep,HIGH); delayMicroseconds(speed); // 1/2ms warten digitalWrite(motorStep,LOW); delayMicroseconds(speed); // 1/2ms warten } }
Standardmäßig ist der Motor deaktiviert. In jeder Funktion, in der der Motor sich bewegen soll (loadManuell und loadSetup bzw. timelapse()), muss er erst aktiviert werden und die Resolution gesetzt werden:
loadManuell(){ .... setRes(16); digitalWrite(motorEnable,LOW); .... Move(stepSize); .... }
Ich denke, das gibt einen guten Überblick über die einzelnen Bestandteile des Programms und man sollte es gut schaffen die Steuerung selbst zu bauen. Gerne kann der Code auch bei mir erworben werden (s. oben).
Wer 2- oder 3- Achsen nutzen möchte, kann das ebenfalls in die Steuerung einbauen, das sollte genauso gut funktionieren. Cool wäre auch einen Start- und Endpunkt (+ ggf. Zwischenpunkte) festzulegen und die Steuerung errechnet sich darauf den ideal Pfad. Bisher ist es nämlich so, dass sie immer auf die ganze Länge des Sliders ausgelegt ist.
von: Herbert
Hallo Johannes, gilt dein Angebot noch? Würde gerne den Code erwerben.
Antwort von Johannes - 08.06.2022
Hallo Herbert, ja das gilt noch :)
Bewertung:
War dieser Kommentar hilfreich?
von: Siegfried Bronner
Hallo Johannes,
Habe vor einigen Tagen einen Betrag überwiesen.
Antwort von Johannes - 15.11.2021
Hallo Siegfried,
danke für die Nachricht. Habe dir soeben den Code via Mail geschickt.
Schöne Grüße
Johannes
Bewertung:
War dieser Kommentar hilfreich?
von: Andreas
Hallo Johannes, ich benutze Dein Programmcode in dem die Steps von links nach rechts geändert worden sind. Ich habe eine Trapezgewindespindel mit 4mm Steigung verbaut und von links nach rechts sind es 80 Umdrehungen. In meinem Fall sind es 256000 Steps (200 x 16 x 80 = 256000 ). Mit dieser Einstellung funktioniert Timelaps.
Nun zum eigentlichen Problem, wenn der Schlitten wieder zurückfährt stößt er links immer an bzw. fährt zu weit zurück. Ich weiß nicht wie die Parameter dafür erstellt werden. Könntest Du mir bei diesem Problem helfen? Danke schon mal im Voraus.
Mit freundlichen Grüßen
Andreas
Antwort von Johannes - 08.06.2021
Hallo Andreas,
eigentlich sollte das nicht passieren, da der Slider nur so viele Schritte zurück geht, wie er hingeht.
Du hast in Zeile 431 die Funktion goBack(). und bei der Schleife while(steps > 0) kannst du statt der 0 mal eine größere Zahl (z.B. 16000) reinschreiben und damit testen. Dann sollte er früher stehen bleiben. Da musst du etwas rumprobieren.
Schöne Grüße
Johannes
Bewertung:
War dieser Kommentar hilfreich?
von: Geiger Johannes
Hallo Johannes,
Habe eben einen Betrag überwiesen.
Gruß
Johannes
Antwort von Johannes - 11.04.2021
Vielen Dank, Code ist raus :)
Bewertung:
War dieser Kommentar hilfreich?
von: Johannes G.
Hallo Johannes, gilt dein Angebot noch? Würde gerne den Code erwerben.
Antwort von Johannes - 21.03.2021
Hallo Johannes,
ja, den Code gibt es noch.
Schöne Grüße
der andere Johannes
Bewertung:
War dieser Kommentar hilfreich?
von: Manuel Kerer
Hallo echt geniale Anleitung ????
Ich werde mich auch drüber trauen.....hab dir was auf dein PayPal Konto überwiesen.
danke
Bewertung:
War dieser Kommentar hilfreich?
von: Ben g.
Hallo Johannes,
Habe dir was für den Sketch überwiesen.
LG
Bewertung:
War dieser Kommentar hilfreich?
von: Beken
Moin,
Denn würde ich den Wohl gerne kaufen.
Was Kriegst du da so für?
Und deine Antworten Funktion Funktioniert nicht.
LG
Beken
Antwort von Johannes - 17.08.2020
Huhu, so viel du möchtest und es dir wert ist.
Bewertung:
War dieser Kommentar hilfreich?
von: Beken
Moin,
Muss man ein 4 Zeilen Display haben oder reicht auch eins mit Zwei?
und Kann man den Code bei dir noch Erwerben?
LG
Beken
Antwort von Johannes - 12.08.2020
Hallo Beken,
ja, Code gibt es noch.
Du kannst auch ein 2-zeiliges Display verwenden, dazu musst du dann aber den Code abändern.
Schöne Grüße
Bewertung:
War dieser Kommentar hilfreich?
von: Kay S.
Hallo Johannes,
habe die Hardware so weit fertig...bin nun interessiert an Deinem Code.
Die Überweisung ist getätigt...besten Dank für Deine Mühe.
Beste Grüße,
Kay
Bewertung:
War dieser Kommentar hilfreich?
von: Simon
Hi Johannes,
hab dir grade was für den Sketch überwiesen - freu mich schon das Teil nachzubauen.
Gruß
Antwort von Johannes - 06.04.2020
Code habe ich Dir geschickt :)
Bewertung:
War dieser Kommentar hilfreich?
von: Sven Knobloch
Hallo,
mein Slider steht seit über nen Jahr in der Werkstatt. Fertig bis auf ne sinnvolle Steuerung
Da ich keine Ahnung von Arduino Programmieren habe, hätte ich gerne den Code. Löten ist mich als Elektroniker kein Problem.
Zusatz frage: braucht man Endschalter? oder hat der Slider einen Start oder Refernzpunkt und weis wie viele Steps der Motor maximal fahren kann???
Freu mich auf Antwort
VG Sven
Antwort von Johannes - 06.04.2020
Hallo Sven,
einen Endschalter brauchst Du nicht. Du musst einmalig alle Steps zählen, die der Slider braucht um von Links nach Rechts zu fahren. Diesen Maximalwert trägst du dann in dem Code ein.
Schöne Grüße
Johannes
Bewertung:
War dieser Kommentar hilfreich?
von: Matt
Hallo, kann man den Code noch erwerben?
Wenn ja würde ich gerne überweisen.
Danke
Antwort von Johannes - 07.02.2020
Hallo Matt, natürlich, das kannst du noch machen :)
Antwort von Matt - 13.02.2020
Hallo, ich hab Dir was überwiesen.
Danke
Bewertung:
War dieser Kommentar hilfreich?
von: Andreas
Hallo Johannes
Habe dir eben das Geld Für die Programmierung des Kamera Slider geschickt.
Freue mich auf den Quelltext.
Gruß Andreas
Bewertung:
War dieser Kommentar hilfreich?
von: Gerhard
Hallo Johannes
Habe dir eben das Geld Für die Programmierung des Kamera Slider geschickt.
Freue mich auf den Quelltest.
Habe noch ein Arduino Mega mit Ramps 1.4, will es damit probiern
Gruß Gerd
Antwort von Johannes - 15.04.2019
Hi Gerd,
vielen Dank!
Habe Dir den Code per Mail geschickt :)
Viel Erfolg und Spaß damit =)
Bewertung:
War dieser Kommentar hilfreich?
von: Jan
Hey,
Erstmal danke für die tolle Anleitung!
Ich bin auch gerade dabei meinen Slider zu bauen!
Meine Mechanischen Komponenten sind etwas anders, da ich auf ein anderes Design gehe :)
Ich würde aber gerne mal deinen Code ausprobieren, da es bei mir leider etwas hapert, was die Programmierung angeht - ich habe dir schon auf PayPal etwas hinterlassen - ich würde mich über eine Mail freuen :)
Wenn mein Projekt fertig ist, gibt es auch gerne Feedback von mir wenn du es sehen möchtest!
Grüße aus dem verschneiten Bayern
Antwort von Johannes - 06.01.2019
Hallo Jan, freut mich sehr, dass Du Dir das Projekt vorgenommen hast. Lass sehr gerne ein Feedback da, sobald Du Deinen Slider fertig gebaut hast. Ich bin gespannt :)
Schöne Grüße und ein gutes 2019
Hansi
Bewertung:
War dieser Kommentar hilfreich?
von: Ben
Hallo Hannes,
Ich mach jetzt mal weiter seit langer zeit.
Ich habe jetzt meinen Igus Slider mechanisch sonweit fertig, inkl motor riemen und umlenkrolle.
Jetzt will ich mit der Elektrik beginnen, hab mir auch schon alles bestellt.
Hab gelesen du arbeitest an einer Version 2, ist die schon fertig?
Ich würde gern auf dein Angebot zurück kommen und den Sketch von dir kaufen, sind da dann auch Ableitungen dabei?
Würd mich sehr um eine Antwort freuen.
Danke
Antwort von Johannes - 16.11.2018
Hallo Ben, freut mich, dass Du die Zeit findest, weiter an deinem Slider zu basteln.
Ich baue nur den Slider um (auch Igus). Da ich aktuell viel unterwegs bin, habe ich aber bisher keine Zeit dafür gehabt :-/
Irgendwann möchte ich auch die Steuerung verkleinern, aber auch da ändert sich nichts am Code.
Für den Programmcode einfach einen Beitrag deiner Wahl per PayPal spenden :)
Was meinst du mit Ableitungen?
Schöne Grüße
Johannes
Bewertung:
War dieser Kommentar hilfreich?
von: Deex
Grüße, die Anleitung ist echt super, alles super nachzuvollziehen
Habe dir auf deinem Paypal Konto was gespendet für den Code, wie läuft das jetzt? Habe dort jetzt kein Verwendungszweck oder so angegeben.
Antwort einfach auf [E-Mail entfernt] falls ich es hier nicht sehen kann.
LG und schönen Abend, weiter so!
Antwort von Johannes - 08.06.2018
Hallo Deex,
dank für die Spende! Anleitung habe ich Dir geschickt.
Schöne Grüße
Bewertung:
War dieser Kommentar hilfreich?
von: Marvin
Tolles Tutorial . Werde mich die Tage mal dran versuchen. Wie siehts eigentlich mit Endstops aus ? Was passiert wen der Schlitten an das Ende kommt ? Grüße
Antwort von Hansi - 03.11.2017
Hall Marvin,
freut mich, dass es Dir gefällt und Du den Eigenbau versuchst :)
Sobald der Slider am Ende ankommt, fährt er bei mir die gleichen Anzahl an Schritte zurück.
Sprich er geht einfach zurück auf Start. Das kannst Du aber so einbauen, wie Du möchtest.
Schöne Grüße
Johannes
Bewertung:
War dieser Kommentar hilfreich?