BeneluxSpoor.net forum
Vraag en antwoord => Elektronica en analoog => Topic gestart door: Sven op 01 January 2024, 19:23:43
-
Ik ga een Arduino met servo en één LED integreren in mijn modelbaan waarbij het volgende moet gebeuren:
1. LED fade in
2. Servo beweegt een stukje (20 graden) en bereikt eindpunt
3. LED fade uit
4. Servo gaat terug naar beginpunt
5. Routine begint van voor af aan.
Ik heb de code van de fade in/uit gekopieerd van het voorbeeldbestand dat bij de Arduinosoftware komt. Als ik dat script los upload naar de Arduino werkt het, maar in het script met de servo werkt de fade in/uit niet. De LED gaat meteen naar 100%. Heeft iemand een idee wat ik veranderen moet om de fade in/uit te bewerkstelligen?
Een andere vraag is dat ik de servo eigenlijk kleinere stapjes wil laten maken. Het gaat toch met teveel schokken, al heb ik de stappen op 0.1 staan. Zelfs als ik het op 0.01 zet.
#include <Servo.h>
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
int pos = 0; // variable to store the servo position
int led = 9; // the PWM pin the LED is attached to
void setup() {
myservo.attach(8); // attaches the servo on pin 8 to the servo object
}
void loop() {
// fade in from min to max in increments of 5 points:
for (int fadeValue = 0; fadeValue <= 255; fadeValue += 5) {
// sets the value (range from 0 to 255):
analogWrite(led, fadeValue);
// pause
delay(0);
}
for (pos = 180; pos >= 160; pos -= 0.1) { // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(500); // waits 15 ms for the servo to reach the position
}
// fade out from max to min in increments of 5 points:
for (int fadeValue = 255; fadeValue >= 0; fadeValue -= 5) {
// sets the value (range from 0 to 255):
analogWrite(led, fadeValue);
// pause
delay(0);
}
for (pos = 160; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(50); // waits 15 ms for the servo to reach the position
}
}
(https://images.beneluxspoor.net/bnls_2024/IMG-1743-659302d051768.jpg) (https://images.beneluxspoor.net/bnls_2024/IMG-1743-659302d051768.jpg)
-
In je fade-in en fade-out heb je een regel:
// pause
delay(0);
Dat betekent: 0 miliseconden wachten.
Verander dus de 0 naar iets positievers ;)
-
Wat betreft de schokkerige stapjes van de servo...
Jouw code:
for (pos = 180; pos >= 160; pos -= 0.1) { // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(500); // waits 15 ms for the servo to reach the position
}
waarbij je bovenaan de variabele pos als integer, dus geheel getal, hebt gedefinieerd:
int pos = 0; // variable to store the servo position
Dat betekent dat 180 minus 0.1 nog steeds 180 blijft
Als je er een float van maakt, zou je meer geluk kunnen hebben, al betwijfel ik eigenlijk of de servo.write functie dat wel toelaat, en anders de servo zelf misschien niet precies genoeg is.
<edit>
helaas is een float niet mogelijk, de servo.write maakt er toch een int van:
https://github.com/arduino-libraries/Servo/blob/master/src/avr/Servo.cpp
void Servo::write(int value)</edit>
In dat geval zou je het misschien mechanisch kunnen oplossen met een vertragingsmechaniek die van de volle 180 graden draaiing omzet naar 20 graden.
Groeten,
Jos
-
En vergeet ook de voeding van de servo zelf niet. Servo's trekken enorme piekstromen bij het bewegen. Daar is de Arduinoprint niet op berekend. Het is zeker aan te raden die servo buiten de Arduino om te voeden. Een voedingsspanning van een microcontroller die niet stabiel is kan het programma ook goed in de war schoppen.
-
In je fade-in en fade-out heb je een regel:
// pause
delay(0);
Dat betekent: 0 miliseconden wachten.
Verander dus de 0 naar iets positievers ;)
Zou je denken. Wat er dan gebeurt is dat de LED wacht met aan gaan tot die wachttijd verlopen is. Daarom heb ik het ook "pause" genoemd. Het is inderdaad waar dat het wel zo werkt bij het originele "Fade" bestand van de Arduino software, maar niet als ik het naar mijn script kopieer en tussen de opdrachten voor de servo plaats.
-
Wat betreft de schokkerige stapjes van de servo...
...
waarbij je bovenaan de variabele pos als integer, dus geheel getal, hebt gedefinieerd:
Dat betekent dat 180 minus 0.1 nog steeds 180 blijft
Ik heb helaas nog veel te weinig kennis van Arduino om dat te begrijpen. Ik moet het vooralsnog met copy-paste en combineren doen.
-
Ik heb je programma aangepast.
Punt #1
Hoewel niet echt nodig, heb ik je code aangepast naar een basale state-machine. Je hebt 4 states, fadeIn, moveServoIn, fadeOut, moveServoOut. Ze worden in sequentie uitgevoerd.
#2
Ik heb meer constantes toegevoegd. Het gewenste aantal grades voor upper en lower posities kan je nu boven in aanpassen. Dit past meteen alles aan voor zowel moveServoIn, als moveServoOut. Idem dito voor de delay waardes voor faden en servo bewegen.
#3
Onder je delays, heb ik in commentaar delayMicroseconds() gezet. Het doet hetzelfde maar je gebruikt us ipv ms. Voor je led niet nodig, voor je servo misschien.
Indien gewenst, kan je delay wegknikkeren en de delayMicroseconds gebruiken.
#4
Servo.write pakt alleen gehele getallen en geen floats. Behalve servo.write bestaat er ook servo.writeMicroseconds(). Deze geeft je een veel grotere resolutie, maar je moet niet het aantal graden invullen maar het aantal us dat de puls moet duren.
Ik heb daarom 2 variabelen toegevoegd; servoLowerUs en servoUpperUs en deze geef ik de juiste waardes in de setup door middel van de o zo rete handige map functie. Met die functie laat ik 0 tot 180 lineair omschalen naar 1000 - 2000 (<== dit zijn de puls lengtes van 0 en 180 graden respectievelijk). Hierbij voer ik het aantal gewenste grades in komt er het juist aantal microseconde uitrollen.
Dit compileert maar is niet getest, want ik heb even geen test setup liggen.
#include <Servo.h>
Servo servo ;
int pos = 0 ;
int dutyCycle = 0 ;
const int servoPin = 8 ;
const int ledPin = 9 ;
const int fadeDelay = 10 ;
const int servoDelay = 15 ;
const int servoLowerDegree = 160 ;
const int servoUpperDegree = 180 ;
int servoLowerUs ;
int servoUpperUs ;
enum states
{
fadeIn,
moveServoIn,
fadeOut,
moveServoOut
} ;
uint8_t state = fadeIn ;
void setup()
{
servo.attach(servoPin); // attaches the servo on pin 8 to the servo object
pinMode( ledPin, OUTPUT ) ;
servoLowerUs = map( servoLowerDegree, 0, 180, 1000, 2000 ) ; // Dit schaalt de gewenste graden om naar de corresponderende tijd in uS
servoUpperUs = map( servoUpperDegree, 0, 180, 1000, 2000 ) ;
}
void loop()
{
int i ;
switch( state )
{
case fadeIn:
for( i = 0 ; i < 255 ; i ++ ) // 1 stapje per keer is beter, kleinere stapgrootte
{
analogWrite(ledPin, i);
delay(fadeDelay) ;
// delayMicroseconds() ; // dit kan ook, dit is een delay in uS zoals de naam al zegt..
}
state = moveServoIn ;
break ;
case moveServoIn:
for( i = servoLowerUs ; i < servoUpperUs ; i ++ )
{
servo.writeMicroseconds(i) ;
delay(servoDelay) ;
// delayMicroseconds(servoDelay) ;
}
state = fadeOut ;
break ;
case fadeOut:
for( i = 255 ; i > 0 ; i -- )
{
analogWrite(ledPin, i);
delay(fadeDelay) ;
}
state = moveServoOut ;
break ;
case moveServoOut:
for( i = servoUpperUs ; i > servoLowerUs ; i -- )
{
servo.writeMicroseconds(i) ;
delay(servoDelay) ;
// delayMicroseconds(servoDelay) ;
}
state = fadeIn ;
break ;
}
}
Ik hoop dat ik geen foutje gemaakt heb ::) Maar ik denk dat bovenstaande code doet wat je wilt dat het doet. Je moet uiteraard die delay waardes nog fine tunen.
Als algemene tip geef ik om geen floats, doubles, of decimale getallen te gebruiken. Je kan meestal gewoon zonder af en ze kunnen tot verscheidene probleempjes lijden.
Mvg,
Bas
-
Dark je wel voor die moeite, Bas. De beweging van de servo-arm is nu inderdaad vloeiender. Maar de LED is nu uit, totdat de arm in de eerste beweging tot het eind punt komt. Dan knippert het één keer heel kort (flits).
Wat is een "float"?
En op het Internet kan ik nergens het antwoord vinden wat de functie is van { en } en ; . Het lijkt op het begin en afsluiten van een opdracht, maar ik snap nog niet precies hoe precies die toe te passen. Op beginnersvideos op Youtube lijkt het al vanzelfsprekend te zijn dat je dat weet en hebben ze het er niet over.
-
Sven, op de Arduino site staan alle begrippen en bewerkingen uitgelegd.
https://www.arduino.cc/reference/en/ (https://www.arduino.cc/reference/en/)
-
Een float is eenvoudig gezegd een getal met cijfers achter de komma, bijv. 3,14, terwijl een int (integer) een heel getal is, dus bijv. 3.
Tussen { en } staat inderdaad wat er allemaal bij een opdracht moet gebeuren.
Dus setup {doe dit allemaal aan het begin} en loop {doe dit vervolgens de hele tijd na de setup}. Of if(conditie){doe dit}. Let op, dat opdrachten genest kunnen zijn.
De ; wordt gebruikt om een regel af te sluiten. Zie het als een punt in de gewone taal.
Dit is even simpel gesteld. Er zijn natuurlijk wat preciezere regels wanneer je welk teken moet gebruiken.
Dat staat allemaal beschreven op de referentiepagina die Hans noemt.
-
Het is een variable type zoals byte of int, maar dan voor decimale getallen.
Een double is bijna hetzelfde maar onderhuids iets anders.
Deze 2 maken iets wat we 'scope' noemen { }. Een functie heeft altijd een scope. Zie het als een bepaald bereik van regels die bij elkaar horen.
void functie()
{
byte b = 1 ; // ik besta alleen tussen deze { } dit is mijn scope.
}
Met name bij dingen als for loops en if statements zijn ze handig. Je kan 1 regel uitvoeren achter een for-loop of if zoals
if( 2 > 1 ) doeIets() ;
Maar meestal wil je meer dan 1 regel achter een for-loop of if-statement hangen en dan gebruik je de { }
if( 2 > 1 )
{
doeIets() ;
doetIetsAnders() ;
}
EDIT; peter was me voor :-P
Bas
-
Sven
In de wiskunde ken je gehele getallen (... -1, 0, 1, 2, 3 ....), maar ook reële getallen zoals dat zijn getallen die liggen tussen de gehele getallen. Een float word gebruikt als je met reële getallen moet werken.
Binnen C, C++ en andere talen afgeleid van Algol ken je het begrip "scope". Het begrip scope is heel fundamenteel in deze talen. Het bakent een gebied binnen een programma af, bijv variabelen gedefinieerd binnen een scope zijn standdard alleen bekend binnen deze scope. Met de { en } definieer je het begin en eind van een specifiek scope. Zo de loop functie is loop(){...}. Hier binnen kun je gang gaan zonder last te hebben van variabele definities elders.
Bas helpt je al met de code. Mocht je er niet uitkomen, dan kan ik je ook je nog wel een bibliotheek (library) voor het aansturen van servo's en leds toesturen.
Groet Meino
Ps. ik zie dat anderen ook al gereageerd hebben.
-
Tof, dat is me nu duidelijk. Bedankt allemaal voor de suggesties. Ik heb in de tussentijd ook een stoplicht en knapperend vuurtje gevonden om de regels beter te kunnen begrijpen (en in de toekomst misschien wel handig).
Nu staat alleen het originele probleem nog om het LEDje te laten opkomen en verdwijnen. Want dat gaat nu dus nog niet in de sketch van Bas.
-
Ik snap niet waarom deze stukjes niet werken :'( zoiets simpels... Meino kijk jij eens.. wat klopt er nou niet aan die sketch?
for( i = 0 ; i < 255 ; i ++ ) // 1 stapje per keer is beter, kleinere stapgrootte
{
analogWrite(ledPin, i);
delay(fadeDelay) ;
// delayMicroseconds() ; // dit kan ook, dit is een delay in uS zoals de naam al zegt..
}
-
Ik weet het alweer!! Ik begon al weer gek te worden.
Servo library gebruikt hardware timer 1. PWM pinnen 9 en 10 gebruiken ook timer 1.
Je moet andere PWM pinnen pakken, 3,5,6 of 11
https://www.arduino.cc/reference/en/libraries/servo/ (https://www.arduino.cc/reference/en/libraries/servo/)
On boards other than the Mega, use of the library disables analogWrite() (PWM) functionality on pins 9 and 10, whether or not there is a Servo on those pins
De gedachte dat ik een fout maakte met programmeren ;D
Bas
-
Dat werkt. Ik dacht er aan om dat eerder aan te geven of de pin wel klopte, want ik had gelezen over het verschil tussen digitaal en PWM, maar omdat de dimmende LED werkte met het testbestand op pin 9 dacht ik dat het wel moest werken.
Nu moet ik alleen de richting omkeren.
-
richting van de servo of de led?
-
Servo. Ik heb het voor elkaar gekregen door de verschillende dingen om te draaien en aan te passen. Het werkt, dus ik neem aan dat ik dat goed gedaan heb (zie onder).
Iedereen bedankt voor de snelle hulp! Als ik het ingebouwd heb, zal ik het laten zien.
#include <Servo.h>
Servo servo ;
int pos = 0 ;
int dutyCycle = 0 ;
const int servoPin = 8 ;
const int ledPin = 11 ;
const int fadeDelay = 10 ;
const int servoDelay = 15 ; // Snelheid van servo in beide richtingen
const int servoLowerDegree = 100 ;
const int servoUpperDegree = 140 ;
int servoLowerUs ;
int servoUpperUs ;
enum states
{
fadeIn,
moveServoIn,
fadeOut,
moveServoOut
} ;
uint8_t state = fadeIn ;
void setup()
{
servo.attach(servoPin); // attaches the servo on pin 8 to the servo object
pinMode( ledPin, OUTPUT ) ;
servoLowerUs = map( servoLowerDegree, 0, 180, 1000, 2000 ) ; // Dit schaalt de gewenste graden om naar de corresponderende tijd in uS
servoUpperUs = map( servoUpperDegree, 0, 180, 1000, 2000 ) ;
}
void loop()
{
int i ;
switch( state )
{
case fadeOut:
for( i = 255 ; i > 0 ; i -- )
{
analogWrite(ledPin, i);
delay(fadeDelay) ;
}
state = moveServoIn ;
break ;
case moveServoIn:
for( i = servoLowerUs ; i < servoUpperUs ; i ++ )
{
servo.writeMicroseconds(i) ;
delay(servoDelay) ;
// delayMicroseconds(servoDelay) ;
}
state = fadeIn ;
break ;
case fadeIn:
for( i = 0 ; i < 255 ; i ++ ) // 1 stapje per keer is beter, kleinere stapgrootte
{
analogWrite(ledPin, i);
delay(fadeDelay) ;
// delayMicroseconds() ; // dit kan ook, dit is een delay in uS zoals de naam al zegt..
}
state = moveServoOut ;
break ;
case moveServoOut:
for( i = servoUpperUs ; i > servoLowerUs ; i -- )
{
servo.writeMicroseconds(i) ;
delay(servoDelay) ;
// delayMicroseconds(servoDelay) ;
}
state = fadeOut ;
break ;
}
}
-
#4
Servo.write pakt alleen gehele getallen en geen floats. Behalve servo.write bestaat er ook servo.writeMicroseconds(). Deze geeft je een veel grotere resolutie, maar je moet niet het aantal graden invullen maar het aantal us dat de puls moet duren.
Bas
Ter info voor mezelf, gewoon even wat ik me dan afvraag:
Geeft dit niet een verloop van de stappen van de servo?
Als je aangeeft hoe lang iets moet lopen kun je toch kleine afwijkingen krijgen als de CPU ook andere zaken aan het doen is? Weet niet hoe nauwkeurig Arduino hier mee is.
Zal niet direct zichbaar zijn, maar misschien wel bij heel lang lopen, en wat hij verder allemaal moet uitvoeren.
Verder wel zeker interessant om te gebruiken, vond zelf de stappen met de servo ook al wat grof.
Groet,
Roelco
-
Ik weet niet of dat veel zin heeft. Mijn ervaring met servo's is dat ze vrij onnauwkeurig zijn kwa preciese positionering. Ik ben al blij als ze binnen een marge van (geschatte) 5graden ergens terechtkomen. Bij wissels niet zo'n probleem omdat ik er altijd een verend deel in de aandrijving heb, maar bij een seinarm blijft het me irriteren dat ik nooit een preciese stand kan bereiken. Wil je precies positioneren dan zul je met een stappenmotor moeten werken.
Groet Meino
-
Een "servo" systeem is een motor systeem met terugkoppeling. Die kleine hobby servo's die wij gebruiken hebben ook terugkoppeling. Ze zullen altijd draaien naar de stand die jij met de arduino verstuurt. En daar blijven ze dan ook staan.
De pulsen worden gegenereerd op interrupts basis. Dat gebeurt op de achtergrond met redelijke exacte intervallen.
Die hobby servo's hebben verder geen snelheidsregeling, daarom laat je ze meestal 1 graad per tijdstapje opschuiven. Of in geval met writeMicrosconds doe je met kleinere stapjes voor een vloeiendere beweging.
vond zelf de stappen met de servo ook al wat grof.
Eens. Maar het verschilt wel per toepassing. Voor een wissel is het prima, voor een overwegboom wat minder. Ik heb in dit draadje (https://forum.beneluxspoor.net/index.php?topic=97375.msg3222198973#msg3222198973) 3j terug een paar filmpjes gemaakt. Ik kan me niet herinneren of ik toen al writeMicroseconds had gebruikt.
Ik heb ze zelf wel voor seinarmen gebruikt en ik was daar wel tevreden over.
https://youtu.be/gLNPEMmPiQg (https://youtu.be/gLNPEMmPiQg)
Mvg,
Bas
-
Ik heb een video van de actie gemaakt. Ik probeer alleen nog een stoppunt in te bouwen. Een wachtmoment voordat de actie herhaald wordt (een wachttijd of de druk van een knop). Dit moet worden geplaatst voor de LED die aan gaat. Ik heb geprobeerd een "delay(500) ;" in te bouwen, maar dat is merkwaardig genoeg lastiger dan ik zou denken. Het enige dat ik voor elkaar krijg is dat de LED de gehele tijd blijft branden. Waar moet dit moment?
Link: https://youtu.be/4YFzO81VgUw
https://youtube.com/v/4YFzO81VgUw
-
Ik heb ze zelf wel voor seinarmen gebruikt en ik was daar wel tevreden over.
https://youtu.be/gLNPEMmPiQg (https://youtu.be/gLNPEMmPiQg)
Ik heb ze zelf ook voor seinen gebruikt.
https://www.youtube.com/v/8-BYXuSmZZA
Het bewegen van de armen gaat perfect. Alleen de eindstanden zijn nooit stabiel. Als ik die posities bepaald heb en dan zijn ze een paar dagen later alweer verlopen. Dat kan te maken hebben met temperatuur en zo, maar de eindstanden verlopen altijd bij mij. Dus dat moet ik nog eens gaan aanpakken.
Groet Meino
-
Het is ellendig dat die potmeter niet naar buiten is geleid. Het zou zo handig als je besturing kan zien wat de stand is.
Eric van C was bezig met die microsteppers voor armseinen. Dat is wellicht een uitkomst.
Ik heb in december nog een idee geplaatst over een DCC print waarin een servo en limit switches passen. Die stand kan je aanpassen door de servo in de print te verschuiven. Het is mijn hoop dat die limit switches tot constante eindposities lijden. Misschien dat 1 of 2 limit switches er bij iets voor je kunnen betekenen?
Bas
-
Bas
ik heb ook aan die microsteppers gedacht. Met stappenmotors heb ik ook ervaring (draaischijf). Die kun je heel precies laten bewegen. Nadeel is dat ze geen vast nulpunt hebben, voor een draaischijf geen probleem, die kun je makkelijk met een Hallsensor en een magneetje op de brug kalibreren, maar voor seinen wordt dat lastiger. Ik denk zelf nu aan een constructie met verenstaal en een fysieke begrenzing van de beweging. Een beetje analoog met de constructie van de wisselaandrijvingen die ik momenteel maak voor Kranenberg.
Groet Meino
-
Nadeel is dat ze geen vast nulpunt hebben
Je moet kijken naar die lineaire stappen dingen (https://www.aliexpress.us/item/3256804629918565.html?spm=a2g0o.productlist.main.47.3fb92cde0ct59g&algo_pvid=1b67e025-bbbb-4ff6-9a24-3f8532e30ce7&algo_exp_id=1b67e025-bbbb-4ff6-9a24-3f8532e30ce7-23&pdp_npi=4%40dis%21EUR%211.57%211.41%21%21%211.69%21%21%4021038edc17041957978987056e4391%2112000030597911823%21sea%21US%21175003200%21&curPageLogUid=rYxxTIFIrLnw), niet die roterende. Die hebben al 2 fysieke eindpunten. Je kan hem bij opstarten zonder schade tegen een van zijn 0 punten aandraaien. Dan weet je zeker dat die 'thuis' staat en vanaf dat moment kan je verder.
Bas
-
Wat die pause betreft.
Ik heb de code aangepast en voorzien van een nieuwe state genaamd 'pause'. De 'pauseTime' is een constante en die staat voor nu op 500ms voor Sven om aan te passen.
Tevens heb ik een extra input aangemaakt waarmee je de pause kan skippen. Die heet 'continuButton'. Die dien je aan GND te verbinden met een schakelaar. (als je die schakelaar wilt, that is)
#include <Servo.h>
Servo servo ;
int pos = 0 ;
int dutyCycle = 0 ;
long prevTime ;
const int continuButton = 7 ;
const int servoPin = 8 ;
const int ledPin = 11 ;
const int fadeDelay = 10 ;
const int servoDelay = 15 ; // Snelheid van servo in beide richtingen
const int servoLowerDegree = 100 ;
const int servoUpperDegree = 140 ;
int servoLowerUs ;
int servoUpperUs ;
const int pauseTime = 500 ;
enum states
{
pause,
fadeIn,
moveServoIn,
fadeOut,
moveServoOut
} ;
uint8_t state = pause ;
void setup()
{
servo.attach(servoPin); // attaches the servo on pin 8 to the servo object
pinMode( ledPin, OUTPUT ) ;
pinMode( continuButton, INPUT_PULLUP ) ;
servoLowerUs = map( servoLowerDegree, 0, 180, 1000, 2000 ) ; // Dit schaalt de gewenste graden om naar de corresponderende tijd in uS
servoUpperUs = map( servoUpperDegree, 0, 180, 1000, 2000 ) ;
}
void loop()
{
int i ;
switch( state )
{
case pause:
if( millis() - prevTime >= pauseTime // if the time expires
|| digitalRead( continuButton ) == LOW ) // OR the button is pressed. Continu
{
state = fadeOut ;
}
break ;
case fadeOut:
for( i = 255 ; i > 0 ; i -- )
{
analogWrite(ledPin, i);
delay(fadeDelay) ;
}
state = moveServoIn ;
break ;
case moveServoIn:
for( i = servoLowerUs ; i < servoUpperUs ; i ++ )
{
servo.writeMicroseconds(i) ;
delay(servoDelay) ;
// delayMicroseconds(servoDelay) ;
}
state = fadeIn ;
break ;
case fadeIn:
for( i = 0 ; i < 255 ; i ++ ) // 1 stapje per keer is beter, kleinere stapgrootte
{
analogWrite(ledPin, i);
delay(fadeDelay) ;
// delayMicroseconds() ; // dit kan ook, dit is een delay in uS zoals de naam al zegt..
}
state = moveServoOut ;
break ;
case moveServoOut:
for( i = servoUpperUs ; i > servoLowerUs ; i -- )
{
servo.writeMicroseconds(i) ;
delay(servoDelay) ;
// delayMicroseconds(servoDelay) ;
}
state = pause ;
prevTime = millis() ; // store current time for pause delay
break ;
}
}
[code]
Bovenstaande code compileert maar is ongetest.
Mvg,
Bas
-
Brilliant, hartstikke bedankt. Als je straks ziet waar het voor is (en het werkt) ga je blij worden. ;D