Comment programmer ESC pour augmenter/diminuer PWM par incréments

Question

J'ai codé avec Python avant de commencer, mais je suis en train d'apprendre C et d'après ce qu'on m'a dit Arduino est assez similaire à C dans certains aspects (au moins avec codage). J'ai remarqué que quand je cours le code sur mon robot, il se secoue en raison des changements rapides de PWM. Donc, je voudrais des conseils sur la façon de faire une instruction if sur Arduino parce que j'essaie d'augmenter/diminuer le PWM par incréments.

//On Roboclaw set switch 1 and 6 on. // <-- what does this refer to? 
//mode 2 option 4 // <-- my note based on user manual pg 26 


#include <Servo.h> 


Servo myservo1; // create servo object to control a Roboclaw channel 
Servo myservo2; // create servo object to control a Roboclaw channel 

//int pos = 0; // variable to store the servo position //<-- left-over from arduino ide servo sweep example? 

void setup() 
{ 
    myservo1.attach(9); // attaches the RC signal on pin 5 to the servo object (Left Motor) 
    myservo2.attach(11); // attaches the RC signal on pin 6 to the servo object (Right Motor) 
} 


void loop() 
{ 
    //forward 
    myservo1.writeMicroseconds(1000); 
    myservo2.writeMicroseconds(1000); 
    delay(2000); 

    //backward 
    myservo1.writeMicroseconds(2000); 
    myservo2.writeMicroseconds(2000); 
    delay(2000); 

    //left 
    myservo1.writeMicroseconds(1500); 
    myservo2.writeMicroseconds(1000); 
    delay(2000); 

    //right 
    myservo1.writeMicroseconds(1000); 
    myservo2.writeMicroseconds(1500); 
    delay(2000); 

} 

Answer 1

Ok, chaque fois que vous écrivez une valeur différente pour le servo, il se déplace dans cette position le plus rapidement possible. Vous devrez donc déplacer votre servo étape par étape.

Pour cette tâche, cependant, vous ne pourrez pas utiliser les délais, car ils bloquent le processeur. Vous devrez imiter l'exemple "clignoter sans délai" (c'est-à-dire utiliser la fonction millis() pour faire quelque chose quand le temps passe.)

Le contrôle d'accélération se déplace simplement de 1 ° toutes les X millisecondes (dans ce cas 6ms, fait un mouvement complet - 180 ° - dure environ une seconde) Toutes les X millisecondes, l'UC se déplace de 1 ° dans la direction d'une position de cible.Pour l'autre code, il suffit de placer la cible à la position désirée et vous sont fait.

Voici le code que j'écrit. Permettez-moi de savoir si cela fonctionne pour vous

#include <Servo.h> 

Servo myservo1; 
Servo myservo2; 
unsigned long prevMillisAccel = 0, prevMillisAction = 0; 
uint8_t servo1_target; 
uint8_t servo2_target; 
uint8_t currAction; 

#define TIME_FOR_ONE_DEGREE_MS 6 

void setup() 
{ 
    myservo1.attach(9) 
    myservo2.attach(11); 
    prevMillisAccel = millis(); 
    prevMillisAction = millis(); 
    servo1_target = 0; 
    servo2_target = 0; 
    myservo1.write(0); 
    myservo2.write(0); 
    currAction = 0; 
} 

void moveServoTowardsTarget(Servo *servo, uint8_t target) 
{ 
    uint8_t pos = servo->read(); 
    if (pos > target) 
     servo->write(pos-1); 
    else if (pos < target) 
     servo->write(pos+1); 
} 

void loop() 
{ 
    unsigned long currMillis = millis(); 
    if (currMillis - prevMillisAccel >= TIME_FOR_ONE_DEGREE_MS) 
    { 
     prevMillisAccel += TIME_FOR_ONE_DEGREE_MS; 

     moveServoTowardsTarget(&myservo1, servo1_target); 
     moveServoTowardsTarget(&myservo2, servo2_target); 
    } 

    if (currMillis - prevMillisAction >= 2000) 
    { 
     prevMillisAction += 2000; 
     currAction = (currAction + 1) % 4; 
     switch(currAction) 
     { 
      case 0: // forward 
       servo1_target = 0; 
       servo2_target = 0; 
       break; 
      case 1: // backward 
       servo1_target = 180; 
       servo2_target = 180; 
       break; 
      case 2: // left 
       servo1_target = 90; 
       servo2_target = 0; 
       break; 
      case 3: // right 
       servo1_target = 0; 
       servo2_target = 90; 
       break; 
     } 
    } 
} 

PS. J'ai utilisé le write fonction au lieu de writeMicroseconds car vous pouvez read la valeur que vous avez écrite. Si vous avez vraiment besoin d'utiliser writeMicroseconds (ce qui est assez inutile à mon avis, puisque la précision de servo est inférieure à 1 °, donc write est plus que suffisant) il suffit de stocker la cible comme uint16_t et de stocker également la dernière valeur de consigne (et l'utiliser au lieu de la fonction read)