Bonjour à tous,
Construire un système pour commander un servomoteur n'a rien d'extraordinaire et pourtant c'est ce que j'ai cherché à faire depuis quelques temps mais sans utiliser d'Arduino. En effet utiliser un Arduino c'est un peu cher payer la note pour «remuer» un servomoteur. Mais il y a également une autre raison.
Prenons le cas d'une séquence d'animation (avec relais, LEDs, etc.) pilotée par un Arduino.
On sait qu'un servomoteur mis dans une position souhaitée a besoin, en permanence, de recevoir des signaux de commande pour maintenir cette position.
Comme l'Arduino est un système mono-tâche, il « lâchera » le servomoteur pour faire autre chose à un moment donné de la séquence d'animation. A cet instant-là l'absence de production de signaux destinés au servomoteur fera que celui-ci n'aura plus de couple moteur... et pourrait quitter la position angulaire sur laquelle il a été mis.
Pour ces raisons et pour piloter correctement un servomoteur, j'ai donc choisi de dédier cette unique tâche à un ATtiny85.
L'ATtiny85 est également un microprocesseur ; mais alors un tout petit-petit microprocesseur qui se programme cependant comme un Arduino, avec moins de possibilités de fonctions tout de même.
Voici le cahier des charges que je m'étais fixé :
• Une commande de mouvement qui :
- lorsqu'elle est au moins (0V) ou « en l'air » fait que le servomoteur se déplace puis reste sur un angle de "repos » dont la valeur est réglage,
- lorsqu'elle est au plus (5V) fait que le servomoteur se déplace puis reste sur un angle de « travail » dont la valeur est également réglage,
-accepte les contacts unipolaires.
• Un réglage possible de la valeur des angles : angle de « repos » compris entre 0° et 90° et un angle de travail compris entre 91° et 180°.
• Pour un débattement de 180°, avoir un réglage possible de la vitesse de rotation (entre « quasi instantané » et 3 s).
• Peu de composants.
Le schéma remplit déjà la dernière condition : 3 résistances variables de 10k seulement !
Inutile de mettre une résistance de 10k entre la commande et la masse pour « tirer » vers le 0V (LOW) l'entrée de cette commande si elle est « en l'air ».
Il suffit de le déclarer dans le « setup » du programme ; 1 composant en moins ! :)
Le programme (ou le « sketch » comme disent les docteurs es Arduino).
Rien de difficile, il a deux parties ; une qui correspond à la mise au moins ou « en l'air » (LOW) de la commande de mouvement et l'autre qui correspond à la mise au plus (HIGH) de la dite commande.
Chaque partie comprend deux étapes :
- Le déplacement vers l'angle défini avec contrôle de la vitesse de rotation.
- Le maintien à l'angle défini atteint tant que l'état de la commande de mouvement n'a pas changé et la possibilité, à cet instant, d'effectuer un réglage de la valeur de cet angle.
Petite remarque, l'angle de « repos » est à définir entre 5° et 90° et celui de « travail » entre 91° et 175° ; pourquoi ?
Parce que certains servomoteurs ne réagissent pas ou mal, aux valeurs strictes de 0° ou de 180° et vibrent alors à ces valeurs extrêmes. De toute manière, l'écart entre 5° et 175° couvre largement nos besoins : mouvements d'aiguillage, de barrières de PN, de plaque de signaux mécaniques, etc.
Voici le programme que vous trouverez également en fichiers joints (.ino et .doc) :
// MAJ 22-08-2021 - Forum EspaceTrain
// Pour ATtiny85 - Horloge interne à 8MHz
// Alimentation en 5V pour ATtiny85 et servomoteur
#include <SoftwareServo.h>
SoftwareServo Servo_Moteur;
const int Commande = 0; // BROCHE N° 5 DE L'ATtiny85
int Etat_Commande;
const int Potentiometre_Angle_Mini = A3; // BROCHE N° 2 DE L'ATtiny85
int Valeur_Angle_Mini;
const int Potentiometre_Angle_Maxi = A2; // BROCHE N° 3 DE L'ATtiny85
int Valeur_Angle_Maxi;
const int Potentiometre_Vitesse_Deplacement = A1; // BROCHE N° 7 DE L'ATtiny85
int Valeur_Vitesse_Deplacement;
int val;
void setup()
{
Servo_Moteur.attach(1); // BROCHE N° 6 DE L'ATtiny85 > PWM
pinMode (Commande, INPUT);
digitalWrite (Commande, LOW);
Etat_Commande = digitalRead (Commande);
pinMode (Potentiometre_Angle_Mini, INPUT);
pinMode (Potentiometre_Angle_Maxi, INPUT);
pinMode (Potentiometre_Vitesse_Deplacement, INPUT);
}
void loop()
{
//************************************************************************************
// PASSAGE DE ANGLE MAXI A ANGLE MINI (REGLABLES) AVEC APPLICATION DU CONTROLE DE VITESSE *
//************************************************************************************
Valeur_Angle_Mini = analogRead (Potentiometre_Angle_Mini);
Valeur_Angle_Mini = map (Valeur_Angle_Mini, 0, 1023, 5, 90)
Valeur_Angle_Maxi = analogRead (Potentiometre_Angle_Maxi);
Valeur_Angle_Maxi = map (Valeur_Angle_Maxi, 0, 1023, 91, 175);
Valeur_Vitesse_Deplacement = analogRead (Potentiometre_Vitesse_Deplacement);
Valeur_Vitesse_Deplacement = map (Valeur_Vitesse_Deplacement, 0, 1023, 1, 50);
// Ligne ci-dessus : transformée de [0, 1023] en [0, 50].
// Les valeurs 0 et 50 correspondent à 0ms et 50ms si utilisation de "delay" par la suite
// Dans le cas de l'utilisation de "delayMicoseconds", plage possible peut varier entre 0 et 16383
// 16383 (16383µs) est la valeur maxi qu'il est possible de mettre dans un "delayMicoseconds"
val = Valeur_Angle_Maxi;
do
{
Servo_Moteur.write (val);
SoftwareServo::refresh();
delay (Valeur_Vitesse_Deplacement);
val = (val - 1) ;
}
while (val >= Valeur_Angle_Mini);
//******************************************************
// MAINTIEN A ANGLE MINI TANT QUE LA COMMANDE VAUT LOW *
//******************************************************
while (Etat_Commande == LOW)
{
val = analogRead (Potentiometre_Angle_Mini);
val = map (val, 0, 1023, 5, 90);
Servo_Moteur.write (val);
SoftwareServo::refresh();
Etat_Commande = digitalRead (Commande);
}
//************************************************************************************
// PASSAGE DE ANGLE MINI A ANGLE MAXI (REGLABLES) AVEC APPLICATION DU CONTROLE DE VITESSE *
//************************************************************************************
Valeur_Angle_Mini = analogRead (Potentiometre_Angle_Mini);
Valeur_Angle_Mini = map (Valeur_Angle_Mini, 0, 1023, 5, 90);
Valeur_Angle_Maxi = analogRead (Potentiometre_Angle_Maxi);
Valeur_Angle_Maxi = map (Valeur_Angle_Maxi, 0, 1023, 91, 175);
Valeur_Vitesse_Deplacement = analogRead (Potentiometre_Vitesse_Deplacement);
Valeur_Vitesse_Deplacement = map (Valeur_Vitesse_Deplacement, 0, 1023, 1, 50);
// Ligne ci-dessus : transformée de [0, 1023] en [0, 50].
// Les valeurs 0 et 50 correspondent à 0ms et 50ms si utilisation de "delay" par la suite
// Dans le cas de l'utilisation de "delayMicoseconds", plage possible peut varier entre 0 et 16383
// 16383 (16383µs) est la valeur maxi qu'il est possible de mettre dans un "delayMicoseconds"
val = Valeur_Angle_Mini;
do
{
Servo_Moteur.write (val);
SoftwareServo::refresh();
delay (Valeur_Vitesse_Deplacement);
val = (val + 1) ;
}
while (val <= Valeur_Angle_Maxi);
//*******************************************************
// MAINTIEN A ANGLE MAXI TANT QUE LA COMMANDE VAUT HIGH *
//*******************************************************
while (Etat_Commande == HIGH)
{
val = analogRead (Potentiometre_Angle_Maxi);
val = map (val, 0, 1023, 91, 175);
Servo_Moteur.write (val);
SoftwareServo::refresh();
Etat_Commande = digitalRead (Commande);
}
}
Bilan matériel :
- 1 ATtiny85
- 3 résistances variables de 10k
- 1 servomoteur
- Une chute de Veroboard à pistes
- Éventuellement des connecteurs
Parlons « sous » : dans le 3 à 4 euros le montage (sans servomoteur ni connecteurs).
Parlons chargement de l'Attiny85 : Heliox nous explique simplement le « comment fait-on » https://www.youtube.com/watch?v=S-oBujsoe-Q . Comme elle j'ai fabriqué un « Shield » (une interface, quoi...) qui accueillera l'Attiny85 à programmer et qui sera enfiché sur l'Arduino UNO ; c'est bien pratique.
Parlons vidéo, c'est ici : https://youtu.be/86FOV5WgncQ
Bon amusement :) :)
Merci Philippe pour cet article. :D
J'espère qu'il incitera certains à se lancer dans la découverte de ce petit microcontrôleur.
Mais de rien, dans ce domaine on se doit de partager ; c'est du "open". :) :)
Le seul point à régler pour se lancer c'est d'avoir fait plusieurs fois la manip avec l'Arduino UNO.
Merci pour ton appréciation :)
Bonjour Philippe,
Je suis très intéressé par cette commande de servo.
Néanmoins , sur le schéma ci dessus, il y a 2 fois P2 dans la nomenclature, le deuxième P2 est en fait P3,
Mais ce qui me pose soucis, c'est que tu cites une commande par le Plus ou en l air/0v
sur le schéma le bouton poussoir est relié au moins. Il ne semble pas possible d'avoir une commande par le Plus ...
Pourtant, sur la vidéo, le fil marron de la plaque bouton est bien sur la ligne rouge de la bredboard ! Et donc le plus.
Pourrais tu , stp, me préciser la chose.
Bonne journée.
Cordialement, Dan.
Citation de: Dan37 le 09 Décembre 2021 à 04:22:38
Bonjour Philippe,
Je suis très intéressé par cette commande de servo.
Néanmoins , sur le schéma ci dessus, il y a 2 fois P2 dans la nomenclature, le deuxième P2 est en fait P3,
Mais ce qui me pose soucis, c'est que tu cites une commande par le Plus ou en l air/0v
sur le schéma le bouton poussoir est relié au moins. Il ne semble pas possible d'avoir une commande par le Plus ...
Pourtant, sur la vidéo, le fil marron de la plaque bouton est bien sur la ligne rouge de la bredboard ! Et donc le plus.
Pourrais tu , stp, me préciser la chose.
Bonne journée.
Cordialement, Dan.
Bonjour Dan,
D'abord merci car, grâce à toi, je viens de voir que j'ai mis le mauvais schéma qui ne va pas bien du tout mais alors pas bien du tout. Ce que c'est d'enregistrer sans faire le tri...
Honte sur moi et sur les dix prochaines générations :-[ :-[ :-[
C'est en revoyant la vidéo que je me suis aperçu de l'erreur.
Les résistances variables P1, P2 et
P3 valent 10k.
Encore merci à toi. :D :D
Le vrai schéma est celui-ci :
Comme on dit : il n'y a que ceux qui ne font rien qui ne font jamais de bêtises !!! ::)
Bien ,il ne me reste plus qu'a essayer tout ça .
A bientôt. :D
Dan.
Bonjour Philippe
l'application fonctionne très bien sur l'Attiny 45 (et 85), mais j'ai un problème avec l'attiny 84,
ayant besoin de 2 sorties supplémentaires (allumage de 2 leds)
pour info : potentiomètres A1 A2 A3 , commande 6 , moteur 7 , leds 1 et 2
essais avec plusieurs att 84 (neufs ,initialisation faite) déplacement erratique du servo ,pas dd'allumage des leds ...
bonsoir papyg
Voila un problème qui m'intéresse car j'utilise souvent des ATtiny84.
Si je comprends bien ton message:
-Les potentiomètres sont donc branchés sur les broches 10, 11 et 12,
-commande sur la broche 7
-moteur sur la broche 6
-si tes leds sont branchées en 1 et 2 cela correspond aux broches 12 et 11 qui sont respectivement A1 et A2, problème: c'est deux broches sont déjà reliées à deux potentiomètres!!
Je parle en fait de ce brochage:
ATTiny84-ATTiny44-pinout.png
bonsoir Attiny
merci pour ta réponse.
tu as parfaitement raison, j'ai mis les leds en 4 et 5 , et tout est rentré dans l'ordre ;
je débute en attiny (et arduino);
toutes mes amitiés.
Guy
Bonjour Guy
Un petit conseil, pour t'éviter de nouveau ce genre de problème, rajoute en commentaire au début de programme ces quelques lignes:
/*
Brochage Attiny84
VCC=|1 U 14|= GND
10 =|2 13|= 0 A0
9 =|3 12|= 1 A1
Reset =|4 11|= 2 A2
(pwm)8 =|5 10|= 3 A3
(pwm)A7 7 =|6 9|= 4 A4
(pwm)A6 6 =|7 8|= 5 A5(pwm)
*/Personnellement je le fais systématiquement en symbolisant également les pins en entrée et en sortie, idem pour les ATtiny85:
Brochage ATtiny85
=|1 U 8|= VCC
P1 -->A3 =|2 7|= A1<-- P3
P2 -->A2 =|3 6|= 1--> Servomoteur
GND =|4 5|= 0<-- Commande
Je le répète ce n'est qu'un conseil...
Amuse toi bien avec les ATtiny et bonne continuation :)
Bonsoir Attiny
bonne idée effectivement d'avoir sous la main le brochage des attiny
as-tu connaissance des Attiny 26 ?
Je ne connais pas l'ATtiny26. Je me limite à l'ATtiny85 et 84.
Citation de: Attiny le 22 Février 2023 à 09:52:30Bonjour Guy
Un petit conseil, pour t'éviter de nouveau ce genre de problème, rajoute en commentaire au début de programme ces quelques lignes:
....
Je le répète ce n'est qu'un conseil...
Amuse toi bien avec les ATtiny et bonne continuation :)
Et tu as entièrement raison.
Combien de programmes je vois sans commentaires...
Il faut penser à la maintenance et aux éventuelles modifs futures.
Après 4 mois, c'est mieux de relire le "comment j'ai fait et pourquoi"
:) :)
bonjour a tous.
je m'immisce.
suite a mon post sur la commande de servomoteurs on ma dirigé vers celui ci.
sur le net j'ai trouvé sur le site "franzitrains62 un petit module qui d'après se que j'en vois pourrais faire le job pour commandé des signaux mécanique.
ai-je raison.
non pas que je ne trouve pas le système de Phillipe mauvais mais comme je suis nul en électronique je préfère les petit modules pas chère.
jean Marc
Je viens de consulter le site et visionner la vidéo.
Si tu cherches un montage simple et sans composant à programmer il y a mieux.
Avant d'utiliser l'Arduino et ses dérivés sous forme d'ATtiny j'utilisais cette carte: le Servo Trigger WIG-1318 de Sparkfun. voir ici. (https://www.lextronic.fr/module-sparkfun-servo-trigger-21323.html) (Je précise que je n'ai pas d'intérêt avec ce revendeur). Avec cette carte sur un réseau de mon ancien club, j'ai réalisé l'animation d'une grue et l'ouverture de portail d'un EP et des portes d'une remise sur un autre ...
La commande peut être manuelle avec un simple contact (inter, BP) ou par un signal niveau masse venant d'un capteur.
Le composant principal est un ATtiny84, un grand frère de l'ATtiny85.
Son utilisation est encore plus facile que les deux modules présentés par Fanzitrain62. Et gros avantage à la coupure d'alimentation on ne perd pas les réglages précédents.
Toutes les explications sont sur le site de Sparkfun (https://learn.sparkfun.com/tutorials/servo-trigger-hookup-guide) et facilement traduisibles, une version française, mais limitée, est consultable sur le site d'un autre revendeur. (https://opencircuit.fr/produit/sparkfun-servo-trigger)
La simplicité à forcément un cout, à toi de voir...
Bonne continuation et bonne lecture :D
bonjour.
merci Attiny pour l'info. elle est pas mal du tout cette petite carte et a l'air assez simple d'utilisation.
bon dimanche.
Jean Marc
Je te confirme qu'elle est très simple d'emploi et c'est une très bonne alternative à des montages qu'il faut assembler, donc convient parfaitement à des personnes qui n'ont pas des grandes connaissances en électronique.
Bien sûr c'est à toi de choisir la solution qui te conviendra.
Bonne continuation
Bonjour,
Je recherche la lib SoftwareServo.h elle ne semble plus dispo sur le net !!!
J'ai un code avec la lib Sevo.h qui fonctionne parfaitement sur un Nano mais celle-ci n'est pas compatible avec l'attiny85 !!!
Exécution de 0 à 90° puis 90 à 0° en boucle avec tempo
Si quelqu'un à la lib SoftwareServo.h je suis preneur.
Merci
#include <Servo.h>
int pos = 0;
Servo servo_9;
void setup()
{
servo_9.attach(9, 500, 2500);
}
void loop()
{
// déplacer le servo de 0 à 90 degrés
for (pos = 0; pos <= 90; pos += 1) {
servo_9.write(pos);
// Atteindre la position souhaitée en 50ms
delay(50);
}
{ servo_9.write(pos);
// Rester 3s en position avant la prochaine étape
delay(3000);
}
// déplacer le servo de 90 à 0 degrés
for (pos = 90; pos >= 0; pos -= 1) {
servo_9.write(pos);
// Atteindre la position souhaitée en 50ms
delay(50);
}
{ servo_9.write(pos);
// Rester 3s en position avant la prochaine étape
delay(3000);
}
}
Bonjour,
Peut-être par ici : https://playground.arduino.cc/ComponentLib/Servo/ ?
Je vous fais un retour sur ma recherche.
Je viens de trouver la lib Servo8Bit pour l'attiny85 mon code se compile bien correctement.
Merci
Citation de: guillaumevlv62 le 09 Novembre 2023 à 09:35:25...
Je recherche la lib SoftwareServo.h elle ne semble plus dispo sur le net !!!
...
Tu la trouveras ici: SoftwareServo.h (https://github.com/nicolaskruchten/arduino/tree/master/libraries/SoftwareServo)
Bonne continuation
Bonjour
J'ai parcouru cette rubrique et ce montage a retenu mon intérêt.
J'ai visionné la video et j'aurai une question concernant le sens de rotation.
Il fonctionne dans un sens antihoraire. Néophyte en syntaxe je me demandais quel paramètre serait à modifier pour obtenir une rotation horaire
Modification du map()?
Merci de vos conseils.
Eric
Citation de: papy12 le 13 Novembre 2024 à 10:19:40Bonjour
J'ai parcouru cette rubrique et ce montage a retenu mon intérêt.
J'ai visionné la video et j'aurai une question concernant le sens de rotation.
Il fonctionne dans un sens antihoraire. Néophyte en syntaxe je me demandais quel paramètre serait à modifier pour obtenir une rotation horaire
Modification du map()?
Merci de vos conseils.
Eric
Bonsoir Papy12,
Non, il n'y a rien à modifier.
La résistance variable de position de "repos" fait varier l'angle de 0 à 180° tout comme celle de la position "travail".
On peut donc fixer la position "repos" dans la zone comprise entre 0 à 90° ou dans celle comprise entre 90 à 180°.
La position "travail" sera à régler sur le même principe.
Mais c'est beaucoup de baratin pour expliquer que cela fonctionne aussi dans le sens horaire.
Merci Philippe.
Effectivement j'avais modifié les paramètres concernés en leurs donnant un valeur négative mais j'avais tout simplement omis cette hypothèse. Excuse pour le dérangement.
Effectivement cela fonctionne mais ai perdu le réglage de la vitesse de déplacement.
Je continue à chercher l'éventuelle solution.
Merci et bonne soirée
Eric