Arduino: servo met LED. Fade in-uit werkt niet.

[Sven]

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.

Code: [Selecteer]

#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
  }

}


[Joz]

In je fade-in en fade-out heb je een regel:

Code: [Selecteer]

    // pause
    delay(0);
Dat betekent: 0 miliseconden wachten.
Verander dus de 0 naar iets positievers 

[Joz]

Wat betreft de schokkerige stapjes van de servo...

Jouw code:

Code: [Selecteer]

  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:

Code: [Selecteer]

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

Code: [Selecteer]

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

[Menno]

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.

[Sven]

In je fade-in en fade-out heb je een regel:

Code: [Selecteer]

    // 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.

[Sven]

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.

[bask185]

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.

Code: [Selecteer]

#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

[Sven]

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.

[Hans1963]

Sven, op de Arduino site staan alle begrippen en bewerkingen uitgelegd.

https://www.arduino.cc/reference/en/

[Peter J K]

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.

[bask185]

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.

Code: [Selecteer]

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

Code: [Selecteer]

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 { }

Code: [Selecteer]

if( 2 > 1 )
{
  doeIets() ;
  doetIetsAnders() ;
}

EDIT; peter was me voor :-P

Bas

[meino]

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.

[Sven]

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.

[bask185]

Ik snap niet waarom deze stukjes niet werken    zoiets simpels... Meino kijk jij eens.. wat klopt er nou niet aan die sketch?

Code: [Selecteer]

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..
    }


[bask185]

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/

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 

Bas