Darkbhaal

Bonsoir, pour pouvoir t'aider il faudrait un bout de code.

Cela peut venir de ton calcul d'angle qui n'est pas assez rapide après je ne connais pas Accelstepper mais peut etre stepper.setAcceleration n'est pas assez élevé.

En tout cas c'est super tu es sur la bonne voie.

Concernant le MPU j'ai du utiliser un câble blindé car j'avais des interférences provenant de mes moteurs qui faisait planté l'I2C si cela peu t'aider.

Après tu peux vérifier le temps de ton Loop avec un truc comme ça tu devrait normalement avoir quelque chose entre 3 et 20ms ne surtout pas utiliser de delay.

//Calcul temps du LOOP toutes les variable sont de type float

    tempoActuel = micros();

    tempoPasse = (tempoActuel - tempoAnterieur); //Temps passé depuis la dernière boucle de programme en Microsecondes
    
    tempo = tempoPasse / 1000; //Temps passé depuis la dernière boucle de programme en Millisecondes

    Serial.print(" Tempo : ");Serial.println(tempo);
    
    tempoAnterieur = tempoActuel;

Bonsoir,

Lorsque je regarde ton programme il me semble que tu ne te bases que sur les données brut de l'accélération en Z pour te servir de mesure d'angle hors cette mesure est précise dans le temps mais très très bruité. Il faudrait au moins que tu passes par un filtre complémentaire en intégrant le gyroscope de ton MPU6050.

Je vois que tu print Input, as tu analysé ces variations?

Concernant Setpoint es tu sur que 837.2 qui est ta consigne corresponde au point d’équilibre de ton robot?

As tu calibrer ton MPU6050 car rien n'apparait dans ton programme.

Pour ma part j'utilise 2 PID sans la librairie mais cela doit être pareil, un PID consigne vitesse moteur et un PID Setpoint les 2 étant lier.

Pour ma part URSA n'a commencé qu'a  balancé qu'une fois le PID setpoint mis en place car il suffit de bouger un cable pour changer le point d’équilibre du robot.

float resultatPID = PID (AngleActuel,AngleObjectif,Kp,Kd,Ki,tempo);

angleObj = -speedPI(tempo, vitesse_moyenne, vitesse_voulu, Kps, Kis, Kds); // vitesse moyenne est égale au résultatPID si je ne fait pas de rotation
AngleObjectif = 0.02 * angleObj + 0.98 * AngleObjectif;
AngleObjectif = constrain (AngleObjectif,-MAX_ANGLE, MAX_ANGLE);


float PID (float AngleActuel, float Angle_desire, float Kp, float Kd, float Ki, float tempo) // tempo et le temps entre chaque mesure d'angle(loop)
{
  float erreurActuel;
  float output;
  erreurActuel = Angle_desire - AngleActuel;
  proportionnel = erreurActuel * Kp *0.1;
  ITerm += (Ki*(tempo*0.001)*erreurActuel);  //tempo *0.001 pour le mettre en secondes
  ITerm = constrain (ITerm, (-VIT_MAX/2),(VIT_MAX/2));
  derive = Kd  * (AngleActuel - input_Ant) / (tempo);
  input_Ant = AngleActuel;
  output = constrain ((proportionnel + ITerm - derive),-VIT_MAX,VIT_MAX);
  
  return(output); 
}

float speedPI(float DT, float input, float setPoint,  float Kp, float Ki, float Kd) // sert pour le calcul de l'angle objectif deplacement angleObj = -speedPI(tempo, vitesse_moyenne, vitesse_voulu, Kps, Kis, Kds);
{
  float error;
  float output;
  error = setPoint-input;
  PID_errorSomme += constrain(error,-ITERM_MAX_ERROR,ITERM_MAX_ERROR); 
  PID_errorSomme = constrain(PID_errorSomme,-ITERM_MAX,ITERM_MAX); 
  float prop = Kp * error * 0.001;
  float integ = Ki * PID_errorSomme * (DT * 0.001)*0.0001;
  float deriv = Kd * (error - errorAnt) / DT;
  output = prop + integ + deriv;
  errorAnt = error;
  
  return(output);
}

Je te conseille également de modifier ton programme pour pouvoir changer en fonctionnement tes facteur KP KI et KD car reuploader le programme à chaque changement va te décourager. Et même avec cela je n'ai toujours pas trouver les bons coefficients.

Comme l'a dit mike commence par régler le P en tenant le robot, il te permettra de vérifier si il répond bien en cas lorsque tu le lâches puis I et en dernier le D, n’hésite pas à utiliser des coefficients multiplicateurs pour bien les diminuer au départ .

En tout cas bon courage pour la suite

Bonsoir,

Je serais super intéressé d'avoir ton programme final (juste pour le balancement, pas la partie serveur).

 

Super boulot, je galère avec le miens depuis quelques mois

Alors pour le code, en attendant d'avoir quelque chose de vraiment fini que je pourrais publier je t'invite à regarder ces robots qui m'ont fortement servi.

Manolo qui s'inspire de Brobot mais avec une arduino UNO et non une Leonardo comme pour Brobot, les code sont disponible sur Github.

Le problème principal avec ce type de robot est de bien maitriser la centrale inertiel. N'étant pas capable d'exploiter moi même les registres du MPU 6050 qui permette d'utiliser le MPU pour faire les calculs, j' ai d'abord récupérer les données brut de accéléromètre et du gyroscope et appliquer le filtre complémentaire.

Malheureusement je n'arrivai pas à avoir quelque chose de stable une fois les moteurs en actions.

J'ai provisoirement solutionner mes principaux problème avec le code décrit dans ce lien mais je compte trouver une autre solution.

Attention également sur URSA le Positionnement du MPU 6050 m'a pas mal aidé, je l'ai positionné au niveau de l'axe des moteurs pour gagner en réactivité.

Ci dessous un schema de Principe de fonctionnement des 2 PID pour l'auto équilibrage du robot qui je l’espère pourra aider certain à mieux comprendre le fonctionnement.

 

Path à écrit:

J'ai pas compris ce qui te gène avec les timers.

Bon je galère avec les citations

Le problème que j'ai rencontré avec les TIMERS et le nombre limiter de 3 TIMERS disponible dans l'arduino UNO.

En effet j'utilise Timer 1 et 2 pour l'envoi des step aux 2 moteurs, j'ai essayer avec le TIMER0 mais je n'ai pas su le modifier et conserver les fonctions millis et ou micros que j'ai besoin pour les PID.

Du coup je me retrouve dans l'incapacité de piloter avec la UNO les 2 servos que j'ai prévu pour le Pan tilt.

Ci dessous le schéma fritzing de URSA

 segway lg v2 Ursa_bb.pdf   2,78 Mo   284 téléchargement(s)

Pour la partie communication j'ai choisi node.js et j'ai trouvé un super tuto (en plus de celui de PATH lien) très détaillé pratique pour les débutant en programmation comme moi et en français lien (d'ailleurs je ne veux pas faire de la pub mais ce site à pas mal de tutoriel intéressant sur arduino).

Cela m'a permis de faire une interface de pilotage en HTML pour URSA. Pour l'instant il manque le retour vidéo de la camera PI en fond. Il y a 2 joysticks virtuels celui de gauche pilote le déplacement et celui de droite pilote le Pan tilt. Je voulais un déplacement et une vision un peu comme dans World of Tank sur mobile si certains connaissent.

J'utilise pour les joysticks virtuels ceci.

Pour les courbes dynamiques j'utilise jquery flot

Ci dessous quelques photos de Ursa.

Ursa vu de dos

Le raspberry pi et le combo Arduino UNO CNC Shield

La lipo bien caler pour éviter les transfert de masse et le module bluetooth pour les tests sans raspberry

La batterie 5V pour le raspberry pi

Le dessous avec le MPU 6050 et les 2 Nema et les cales pour le maintient à l’arrêt car elles ne l’empêche pas de tomber.

Bon j'ai encore beaucoup de problème outre le balancing de URSA.

Le joystick virtuel de droite est décalé de la moitié de l'écran et je n'arrive pas à le centrer les joie de l'html et du css.

La page HTML sature au bout d'un moment et il faut que je la recharge régulièrement surement du au courbes.

Si vous avez des conseils je suis preneur.

Voila si vous avez lu jusque la je suis désolé pour l'orthographe et le pavé un peu fouilli.

A bientôt.

Bonjour 

Je me permets de vous présenter mon robot de type "Self Balancing" nommé ‘’URSA ‘’.

J'utilise:

Serveur : Raspberry PI 2 

Contrôleur : Arduino UNO

Moteur : 2 x Nema 17 moteur pas à pas

Driver Nema 17 : A4988

Centrale inertielle : MPU 6050

Batterie : LIPO 3S 3000maH

Batterie 5V : Batterie chargeur portable 12000mah (j’avais ça sous la main)

Châssis : Medium + tige fileté

Pour la partie Serveur je suis partie sur node.js (merci le tuto de Ash et en général les tutos de Locoduino) et une interface de commande et télémétrie via une page html. Le robot est donc pilotable depuis un pc ou un smartphone.

Pour l'instant j'en suis au balbutiement du Balancing. En effet il tient debout en position statique mais pas mal de boulot sur le réglage.

Petite vidéo pour le Balancing a l’arrêt:

Une autre ou il se déplace mais fini par tomber : 

Voila il faut que je finisse les réglages des PID.

Après cela je compte:

- alléger le robot qui pèse quand même 2kg, dans un premier temps diminuer le diamètre des roue car je manque de couple

- rajouter un pan tilt et faire un combo "camera pi - HC 04" mais je suis limité sur la UNO au niveau des TIMERS(si quelqu'un sait si on peut modifier le Timer 0 et continuer à gérer le temps car j'ai renoncer à modifier ce Timer? J'utilise Timer1 et Timer2 pour le pilotage des moteurs) donc à voir si je pilote les Servo avec le Raspberry PI  via python ou via une Arduino Nano que j'ai de disponible.

- se pencher sur Open Cv pour traiter la vidéo, faire de la reconnaissance d'objet, d'obstacle. J'ai déjà un serveur uv4l sur le Raspberry avec un simple retour video

- essayer de faire un lidar du pauvre

- faire toute la partie autonomie du robot

Voila après j'ai encore beaucoup idées mais ça fait déjà beaucoup et faut se limiter car on s’éparpille très très vite.

N’hésitez pas à poser des questions sur le robot ainsi qu'à me conseiller, car j'ai fait des choix après pas mal de lecture mais je n'ai que de très faible connaissance en programmation.