Bonjour, je souhaite 'fabriquer" un servomoteur, l'idée est de piloter sur 180° un moto-réducteur via un pont en H, la positon serait mesuré a l'aide d'un potentiomètre et la consigne est un signal provenant d'un récepteur rc, il s'agit d'un signal haut variant de 1ms (0°) a 2ms (180°) toutes les 20ms.
Pensez que tout ça peut être gérable par une carte Arduino ?
Merci beaucoup
C'est faisable avec n'importe quoi et même mieux ! sans microcalculateurEnvoyé par val.du.12
Bonsoir, je n'arrive pas a trouver de schéma détaillé de la composition d'un servomoteur, avez des pistes ? Merci
devoir à rendre quand ?
Y a qu'une seule piste ! Celle du potentiomètre que tu dois lire pour avoir la position du servomoteur .
Non ce n'est pas un devoir c'est un projet personnel
Tu prends la valeur moyenne de la tension PWM, c'est la consigne
Tu prends la valeur de la tension du potentiomètre, c'est la position actuelle
En fonction de la différence , tu actionnes ton pont "H" dans un sens ou dans un autre
Un arduino peut gérer jusqu'à 12 servos simultanément.Bonjour, je souhaite 'fabriquer" un servomoteur, l'idée est de piloter sur 180° un moto-réducteur via un pont en H, la positon serait mesuré a l'aide d'un potentiomètre et la consigne est un signal provenant d'un récepteur rc, il s'agit d'un signal haut variant de 1ms (0°) a 2ms (180°) toutes les 20ms.
Pensez que tout ça peut être gérable par une carte Arduino ?
Merci beaucoup
Il suffit d'utiliser la bibliothèque Servo
Cette bibliothèque permet à une carte Arduino de contrôler des servo-moteurs de type radio-modélisme.
La bibliothèque Servo prend en charge jusqu'à 12 moteurs sur la plupart des cartes Arduino et 48 sur le Mega Arduino. Sur les cartes autres que les Mega, l'utilisation de la bibliothèque désactive analogWrite () (PWM) sur les broches 9 et 10, qu'il y ait ou non il y a un servo sur ces broches. Sur le Mega, jusqu'à 12 servomoteurs peuvent être utilisés sans interférer avec la fonctionnalité PWM, mais l'utilisation de 12 à 23 moteurs désactivera la PWM sur les broches 11 et 12.
Les servomoteurs ont trois fils: alimentation, masse, et signal. Le fil d'alimentation est généralement rouge, et doit être connecté à la broche 5V sur la carte Arduino. Le fil de masse est généralement noir ou marron et doit être relié à une broche de masse sur la carte Arduino. La broche de signal est généralement jaune, orange ou blanc et doit être connecté à une broche numérique sur la carte Arduino. Notez que les servos peuvent consommer une puissance considérable, donc si vous devez en actionner plus d'un ou deux, vous aurez probablement besoin de les alimenter à partir d'une alimentation séparée (à savoir pas la broche + 5V sur votre Arduino). Assurez-vous de connecter la masse de l'Arduino et alimentation externe ensemble.
Le programme exemple " Knob" permet de contrôler la position d'un servo avec un potentiomètre.
Il faut réaliser le montage suivant:
et programmer l'Arduino avec le code suivant:
Dans ton cas, il ne s'agit pas d'un servo de télécommande, donc l'exemple ci-dessus n'est pas directement utilisable.Code:/* Controlling a servo position using a potentiometer (variable resistor) by Michal Rinott <http://people.interaction-ivrea.it/m.rinott> modified on 8 Nov 2013 by Scott Fitzgerald http://www.arduino.cc/en/Tutorial/Knob */ #include <Servo.h> Servo myservo; // create servo object to control a servo int potpin = 0; // analog pin used to connect the potentiometer int val; // variable to read the value from the analog pin void setup() { myservo.attach(9); // attaches the servo on pin 9 to the servo object } void loop() { val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023) val = map(val, 0, 1023, 0, 180); // scale it to use it with the servo (value between 0 and 180) myservo.write(val); // sets the servo position according to the scaled value delay(15); // waits for the servo to get there }
Il faudrait utiliser une entrée analogique pour le potentiomètre de recopie et une digitale pour le signal de commande en provenance du récepteur RC. Ce signal est envoyé à la broche 2 ou 3 et déclenche une interruption qui met un route un compteur permettant de mesurer la durée de l'impulsion.
Et utiliser 2 sorties PWM pour contrôler un demi L 298.
Ou une seule sortie PWM et une autre broche digitale sortant le signal inverse du signal PWM. Le programme va lire le signal sur la broche PWM et sort le signal inverse par l'autre broche. Le L298 garantit que tout shoot through est exclu.
Lorsque le moteur est à la position souhaitée, les 2 broches passent à zéro et le moteur s'arrête.
Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)
Bonjour, merci beaucoup j'y vois maintenant plus clair et vais continuer a chercher et je vous tiens au courant
Valentin
La question du demandeur ne concerne pas l'utilisation d'un servo mais la fabrication d'un servo.
Voila j'ai réalisé un circuit RC a l'aide d'un condensateur et une résistance afin de lire la tension moyenne du signal PWM, lors de la mesure au multimètre je trouve une tension variant de 35 a 70 mV suivant la position de ma radio, mais voila lorsque je remplace le multimètre par une entrée analogique de mon Arduino les mesures sont incohérentes et varient ! Qu'en pensez vous ? Merci
Mesurer un signal de 35 à 70mV avec une entrée qui est faite pour mesurer du 0 à 5V .....
Il faut amplifier ton signal avant de le faire bouffer au convertisseur ADC !
Bonjour,
La position d'un servo n'est pas définie par le rapport cyclique du signal de commande, mais par la durée des pulses.
Pour bien faire les choses, il ne faudrait donc pas lire la tension moyenne du signal PWM, mais faire mesurer par le µC la durée des pulses.
Mesurer ainsi la tension moyenne de la consigne risque d'obliger à utiliser une calibration.
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
Comme il a un pulse toutes les 20ms, le moyennage par un RC du PWM donne bien la position analogique à atteindre
Bonsoir,
L'information codant la position désirée est contenue dans la longueur du pulse : entre 1 ms et 2 ms.
L'information doit être répétée toutes les 20 ms au maximum, éventuellement plus souvent.
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
Il utilise une télécommande du commerce .... donc la fréquence de répétition est constante.
La bonne questionPourquoi faire un truc bancal, alors que ça coute 3 francs six sous !je souhaite 'fabriquer" un servomoteur
Pour commander le moteur, on pourrait utiliser un L 298, qui contient 2 ponts en H. Il permettrait donc même de commander un deuxième moteur CC.
Le circuit est le suivant:
Au lieu d'être actionnées par des interrupteurs, les entrées In 1 et In 2 seraient connectées à deux sorties PWM de l'Arduino.
Le PWM permettrait d'avoir un moteur qui tourne à grande vitesse lorsque la consigne est très éloignée de la position actuelle du moteur, puis au fur et à mesure que le moteur se rapproche de la position désirée, la vitesse diminue. Au cas où un tel comportement est désiré, bien sûr. Autrement, on peut aussi commander le moteur du servo par tout ou rien.
Pour ce qui est de la mesure de la durée des impulsions, 1 à 2 ms toutes les 20 ms, on envoie les impulsions sur une entrée digitale et on pourrait imaginer le programme suivant:
A chaque passage de la boucle, on lit l'entrée de commande. Lorsqu'elle passe à l'état haut et tant qu'elle reste dans cet état, un incrémente un compteur. Lorsque la broche passe à l'état bas, on copie la valeur du compteur dans la variable consigne et on met le compteur à zéro. Un tour de boucle se fait en quelques microsecondes. Une impulsion de 1 ms devrait donner un total de quelques centaines au compteur, et une impulsion de 2 ms, le double.Code:const int brocheCommande = 2; // la broche qui reçoit les impulsions du récepteur de télécommande // Variables int compteur = 0; // compteur mesurant la durée de l'impulsion int etatBrocheCommande = 0; // état actuel de la broche de commande int dernierEtatBrocheCommande = 0; // état précédent de la broche de commande int consigne = 512; // valeur de départ de la consigne void setup() { // déclarer la broche de commande comme entrée pinMode(brocheCommande, INPUT); } void loop() { // on lit l'état de la broche de Commande etatBrocheCommande = digitalRead(brocheCommande); if (etatBrocheCommande == HIGH && dernierEtatBrocheCommande == LOW) { compteur++; } if (etatBrocheCommande == HIGH && dernierEtatBrocheCommande == HIGH) { compteur++; } if (etatBrocheCommande == LOW && dernierEtatBrocheCommande == HIGH) { consigne = compteur; compteur=0; } dernierEtatBrocheCommande= etatBrocheCommande; }
De cette manière, on aura une mesure bien plus précise de la durée des impulsions qu'en utilisant un filtre passe-bas et un amplificateur attaquant une entrée analogique, surtout si le rapport cyclique n'est que de 5 à 10%.
Le reste du programme (qui reste à écrire) devra utiliser la valeur consigne et la comparer à la valeur fournie par le potentiomètre de recopie (lue par une entrée analogique, après s'être assuré que la tension fournie par ce potentiomètre est comprise entre 0 et 5 V), on pourra éventuellement utiliser la fonction MAP.
En fonction du résultat de cette comparaison, on va commander les deux broches de sortie de l'Arduino , qui elles-mêmes vont aller commander le L 298.
Dans un premier temps, il faudrait déjà voir les valeurs atteintes par la variable "consigne" en fonction de la durée des impulsions. Et il faudrait aussi savoir si le courant fourni par le L 298 est suffisant pour le moteur qui va être utilisé.
Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)
Alors voilà le schéma mis au net du montage:
A noter que le L298 permet d'avoir une alim pour le moteur qui va jusqu'à une quarantaine de volts. Mais attention au courant qui circulera dans le moteur, parce que sur ce circuit, il n'y a pas de limitation! Si on voulait surveiller le courant du moteur, il faudrait utiliser la patte sensA (1).
Reste à compléter le programme.
Il faut maintenant passer à la réalisation du montage et voir en pratique quelles sont les valeurs prises par consigne et par potentiometreRecopie, en utilisant le moniteur série. Une fois ces valeurs connues, il faudra utiliser la fonction map pour que les plages de valeurs de consigne et de potentiometreRecopie soient les mêmes.Code://Constantes const int brocheCommande = 2; // la broche qui reçoit les impulsions du récepteur de télécommande // Variables int compteur = 0; // compteur mesurant la durée de l'impulsion int etatBrocheCommande = 0; // état actuel de la broche de commande int dernierEtatBrocheCommande = 0; // état précédent de la broche de commande int consigne = 512; // valeur de départ de la consigne void setup() { // déclarer la broche de commande comme entrée ainsi que les deux sorties pinMode(brocheCommande, INPUT); pinMode(9, OUTPUT); pinMode(10, OUTPUT); } void loop() { // on lit l'état de la broche de Commande etatBrocheCommande = digitalRead(brocheCommande); if (etatBrocheCommande == HIGH && dernierEtatBrocheCommande == LOW) { compteur++; } if (etatBrocheCommande == HIGH && dernierEtatBrocheCommande == HIGH) { compteur++; } if (etatBrocheCommande == LOW && dernierEtatBrocheCommande == HIGH) { consigne = compteur; compteur=0; } dernierEtatBrocheCommande= etatBrocheCommande; int potentiometreRecopie = analogRead(A0);// on lit le potentiomètre de recopie //pour que la suite du programme fonctionne, il faut que les plages de valeurs de //potentiometreRecopie et de consigne soient les mêmes if (abs(potentiometreRecopie - consigne)>3){//on ménage une zone morte au voisinage de consigne if (potentiometreRecopie > consigne){ digitalWrite(9, HIGH); digitalWrite(10, LOW); } if (potentiometreRecopie < consigne){ digitalWrite(9, LOW); digitalWrite(10, HIGH); } } else { digitalWrite(9, LOW); digitalWrite(10, LOW); } }
Un civet, un plat de côtes et puis, glissez-moi une petite paupiette avec.( Lino Ventura)
