Oracid

 PimroniServosRP2040.jpg   157,55 Ko   22 téléchargement(s)

Pimoroni, bien connu dans le monde RaspBerry Pi a sorti une carte dédiée à la mise en oeuvre de pas moins de 18 servos.

Notez que les servos peuvent être alimentés jusqu'à 11V. Enfin, c'est ce que j'ai compris, mais il y a un petit astérisque non documenté dans la description. 

La carte elle-même est dotée d'un RP2040, de 6 E/S pour capteurs, de 6 leds programmables, et d'un capteur de tension/courant.

Il vous en coutera environ 30€. Le seul problème, c'est qu'elle est en rupture de stock . . . dommage !

Voici un lien et la vidéo :

Servo 2040 - 18 Channel Servo Controller (pimoroni.com)

Voici un lien fournit par pmdd, dans lequel l'astérisque est documenté. Il s'agit de couper une piste,en cas d'alimentation des servos suoérieure à 5V, et d'alimenter les servos par sa propre alimentation.

Servo 2040 - 18 Channel Servo Controller | Kiwi Electronics (kiwi-electronics.com)

Documentation :

servo2040.sch (shopify.com)

servo-2040-drawing.png (1534×1206) (shopify.com)

Le PID, c'est comme le piano. Ce n'est pas parce que l'on sait comment cela fonctionne que l'on sait en jouer.

J'ai découvert une vidéo de Ian Carey qui propose un banc de test extrêmement facile à réaliser qui permet de s'entrainer à modifier les variables pour bien les maitriser.

L'idée de Ian Carey, avec un Arduino Nano, est de générer une tension de référence (target) sur une sortie PWM au travers d'un filtre Passe Bas. Puis cette tension est réinjectée dans une entrée analogique. C'est ça, le truc génial !

Dans cette vidéo, j'ai également découvert l'influence très importante de dt (delta time) dans le calcul du PID.

J'ai modifié son filtre en reprenant un filtre calculé par Sando, avec R=470 et C=100µF. Ce filtre fonctionne parfaitement et génère très peu d'oscillations.

J'ai réécrit le programme de Ian Carey à ma manière. Avec 25 lignes de code, j'ai un PID qui fonctionne très bien.

Il y a quand même des choses que je ne m'explique pas dans le programme Ian Carey.

Dans la fonction setup(), il initialise l'abscisse à 0 et target , dans une boucle. J'ai voulu supprimer cette boucle, mais le "dessin" caractéristique du début du feedback, disparaissait. Il s'agit de cette oscillation à peu près symétrique sur la ligne de target. En fait, sa boucle camouflait ce problème.

J'ai alors eu l'idée de remplacer cette boucle par une temporisation de 5000ms,  init_time .

J'aimerais bien savoir pourquoi, il est nécessaire de patienter pendant 5 secondes pour avoir ce début d'oscillations.

C'est important, car dans la vraie vie, on peut se demander si on lance le processus immédiatement ou si on doit attendre un petit moment avant que le feedback atteigne la bonne position.

Je génère donc l'axe des abscisses et le target dans la fonction loop(). De plus, je génère une ligne symétrique aux abscisses par rapport à la ligne du target. Cela pour que le Plotter Arduino ne zoom pas en fonction des valeurs du feedback.

Je paramètre également un délai à la fin de la fonction loop(), loop_time . Ce paramètre est très important car, il détermine le dt , et donc le calcul du PID.

Le Plotter Arduino est assez sensible, mais je pense avoir trouver le bon code.

Après avoir lancer le programme, il faut attendre les 5 secondes d'initialisation avant de voir apparaitre le feedback. Il est préférable de cocher "Interpolate" pour avoir une oscillation plus "fluide".

Je pense que l'utilisation du Plotter a une grande influence dans le dt à cause du temps d'exécution des Serial.print() , mais ce délai n'impacte pas négativement le calcul du PID, car si je diminue la variable loop_time , le résultat est impacté négativement.

Il me semble donc nécessaire que le PID soit déterminer dans un lapse de temps minimum, incompressible.

Le schéma du banc de test sur une breadbord.

 Schema01_bb.jpg   151,71 Ko   1 téléchargement(s)

Le résultat avec mon code.

 PID01.jpg   107,5 Ko   1 téléchargement(s)

Mon code :

// Program inspired from the code of Ian Carey https://www.youtube.com/@careyian - 03/11/2023
const int INPUT_PIN = A0;
const int OUTPUT_PIN = DD5;
 
float dt, last_time = 0, init_time = 5000, loop_time = 200, target = 60.00, kp = 0.76, ki = 0.191, kd = 0.0009;
 
void setup(){
  Serial.begin(115200);
  analogWrite(OUTPUT_PIN, 0);
  delay(init_time);
}
 
void loop(){
  float now = millis(); dt = (now - last_time) /1000.00; last_time = now;
  float feedback = map(analogRead(INPUT_PIN), 0, 1024, 0, 255);
  float error = target - feedback;
  float output = pid(error);
  analogWrite(OUTPUT_PIN, (int)output);
  Serial.print(target); Serial.print(","); Serial.print(target*2); Serial.print(","); Serial.print(feedback); Serial.print(","); Serial.println(0);
  delay(loop_time);
}
 
float pid(float error){
  static float integral, previous = error;
  float P = kp * error;
  float I = ki * (integral = integral + error * dt);
  float D = kd * (error - previous) / dt;
  return P + I + D;
}

// code de Ian Carey https://www.youtube.com/@careyian
// https://youtu.be/RZW1PsfgVEI?si=yrka40X2lhyUlicM
// https://gist.github.com/careyi3/02a57dfd3a62a96d46171489c83488bd#file-pid-ino
 
const int INPUT_PIN = A0;
const int OUTPUT_PIN = DD3;
 
double dt, last_time;
double integral, previous, output = 0;
double kp, ki, kd;
double setpoint = 75.00;
 
void setup()
{
  kp = 0.8;
  ki = 0.20;
  kd = 0.001;
  last_time = 0;
  Serial.begin(9600);
  analogWrite(OUTPUT_PIN, 0);
  for(int i = 0; i < 50; i++)
  {
    Serial.print(setpoint);
    Serial.print(",");
    Serial.println(0);
    delay(100);
  }
  delay(100);
}
 
void loop()
{
  double now = millis();
  dt = (now - last_time)/1000.00;
  last_time = now;
 
  double actual = map(analogRead(INPUT_PIN), 0, 1024, 0, 255);
  double error = setpoint - actual;
  output = pid(error);
 
  analogWrite(OUTPUT_PIN, output);
 
  // Setpoint VS Actual
  Serial.print(setpoint);
  Serial.print(",");
  Serial.println(actual);
 
  // Error
  //Serial.println(error);
 
  delay(300);
}
 
double pid(double error)
{
  double proportional = error;
  integral += error * dt;
  double derivative = (error - previous) / dt;
  previous = error;
  double output = (kp * proportional) + (ki * integral) + (kd * derivative);
  return output;
}

Si vous recherchez un mini servo de qualité, en voici un qui promet 12kg.cm, 0.06s/60° (en 8.5V) et un poids de 22g.

Pour bien se rendre compte de ses capacités, ce mini servo promet un couple d'un servo standard, tel qu'un MG995 qui pèse 55g.

Petit problème, il faudra débourser 52€.  On a rien, sans rien !

Le pignon de sorti a un diamètre de 4.96mm, soit environ 5mm/25T. Cela semble assez courant.

Un pignon standard, sur un gros servo, a un diamètre de 6mm/25T.

Les diamètres des pignons des SG90 ou MG92B sont différents.

A voir . . .

https://yantrs.cn/pr...servo-的副本

https://www.aliexpre...ayAdapt=glo2fra

 Yantrs-12kg-0612MG-B-02.jpg   62,34 Ko   41 téléchargement(s)  Yantrs-12kg-0612MG-B-01.jpg   112,93 Ko   40 téléchargement(s)

https://store.arduino.cc/pages/uno-r4

La grande idée, c'est de sortir un nouvel Uno compatible avec le précédent, mais avec un microprocesseur 32bit, au lieu de 8 bits, précédemment.

Il est sorti en deux versions, le Uno R4 Minima et le Uno R4 WiFi. 

La compatibilité passe par une tension de niveau logique à 5V. A mon avis, c'est ce petit "détail" qui va faire son succès.

C'est, en tout cas, pour cette raison que je l'ai commandé. J'ai commandé le WiFi, qui peut le plus, peut le moins.

Personnellement, j'aurais préféré un Nano, compatible.

Même si j'ai l'habitude d'utiliser des Nano, dans mes débuts, j'ai utilisé des Uno avec 2 Shields différents. Le YFROBOT V5 et le Sensor Shield V5.0.

L'avantage de ces Shields, c'est qu'ils permettent d'être alimentés par une tension de 7.4V. Ainsi, mes servos sont directement alimentés par la batterie, sans passer par une alimentation spécifique qui pourrait limiter l'intensité souhaitée.

Toutes les pins d'entrées/sorties sont à 7.4V, même les pins analogiques. Pour ces dernières, j'ai un doute, il faudra que je teste.

Le connecteur I2C et Rx/Tx sont également en 7.4V. En principe, là, cela ne devrait pas poser de problème.

Voici les tensions relevées sur les pins suivantes :

Pin 3.3V  --  3.3V

Pin 5V   --  7.4V

Pin Vin  --  5.6V

Je ne comprends pas vraiment, les tensions relevées sur les pins 5V et Vin. A priori, j'aurais parié l'inverse.

J'ai donc testé le Uno R5 avec un servo, le tout alimenté en 7.4V. J'en ai profité pour passer à l'IDE V2.

Tout cela fonctionne parfaitement bien.

Attention, les borniers d'alimentation de ces deux Shields sont inversés. Cela m'a valu un magnifique court circuit et une entrée USB de mon PC, cramée.

Longue vie à cette nouvelle carte qui a déjà beaucoup de succès. Elle est déjà en rupture de stock sur le site Aduino, mais vous pourrez la trouver sur le shop d'Elektor.

Cliquez moi.

 YFROBOT_V5.jpg   249,32 Ko   23 téléchargement(s)  SensorShield_V5.jpg   206,96 Ko   24 téléchargement(s)

Cliquez moi.

               DSC_4042-L-v2.jpg   72,85 Ko   25 téléchargement(s)

Voici mon dernier né.

Ce n'est pas un grand quadrupède comme 8DOF-Q5, https://www.robot-ma...upede/?p=118867, mais un quadrupède de taille moyenne.

Sa voie est de 170mm, et l'écartement des pattes, avants et arrières, est de 290mm, contre 210mm et 380mm précédemment.

Les longueurs du fémur et le tibia  sont de 184mm, contre 200mm.

La hauteur du garrot est identique à 355mm.

Tout cela donne une allure beaucoup plus ramassée et une impression de puissance.

Le rapport longueur/largeur est empirique, et est le résultat du choix des pièces Lego, en particulier les trois grands cadres qui donnent la longueur et la largeur du châssis.

J'ai fait un petit test à faible vitesse. Avec sa petite largeur et ses pattes très hautes, il se comporte plutôt bien et ne se renverse pas, ce qui est l'objectif principal de ce nouveau quadrupède.