Le mouvement synchrone entre plusieurs actionneurs linéaires peut être vital pour le succès de certaines applications client, l'un commun étant deux actionneurs linéaires ouvrant une trappe. Pour ce faire, nous vous recommandons d'utiliser le Firgelli dédié boîtier de commande synchrone FA-SYNC-2 et FA-SYNC-4. Cependant, certains bricoleurs et hackers préfèrent la liberté offerte par un microcontrôleur tel que l'Arduino et préfèrent plutôt écrire leur propre programme de contrôle synchrone. Ce didacticiel vise à fournir un aperçu de la façon d'y parvenir en utilisant le Actionneur linéaire série optique.
Préface
Ce tutoriel n'est pas un traitement rigoureux des étapes nécessaires pour obtenir un contrôle synchrone avec Arduino, mais plutôt un large aperçu pour vous aider à écrire votre propre programme personnalisé. Ce didacticiel est avancé et suppose que vous êtes déjà familiarisé avec le matériel et les logiciels Arduino et que vous avez idéalement de l'expérience avec les signaux de modulation de largeur d'impulsion (PWM), la routine de service d'interruption (ISR), le rebond des capteurs et les encodeurs de moteur. L'exemple fourni dans ce tutoriel est un contrôleur proportionnel primitif. De nombreuses améliorations peuvent être mises en œuvre sur l'exemple suivant, y compris, mais sans s'y limiter: la mise en œuvre d'une boucle de commande PID et la mise à l'échelle à plus de deux actionneurs linéaires. Veuillez noter que nous ne disposons pas des ressources nécessaires pour fournir un support technique pour les applications Arduino et que nous ne déboguerons pas, ne modifierons pas, ne fournirons pas de code ou de schéma de câblage en dehors de ces didacticiels accessibles au public.
Aperçu du contrôle synchrone
La commande synchrone est obtenue en comparant la longueur de deux actionneurs linéaires et en ajustant proportionnellement la vitesse; si un actionneur commence à se déplacer plus rapidement qu'un autre, nous le ralentirons. Nous pouvons lire la position de l'actionneur linéaire via le codeur optique intégré. L'encodeur optique est un petit disque en plastique avec 10 trous qui est connecté au moteur à courant continu de sorte que lorsque le moteur tourne, le disque en plastique le fait aussi. Une LED infrarouge est dirigée vers le disque en plastique de sorte que lorsqu'elle tourne, la lumière soit transmise à travers les trous du disque optique ou bloquée par le plastique du disque. Un capteur infrarouge de l'autre côté du disque détecte le moment où la lumière est transmise à travers le trou et émet un signal carré. En comptant le nombre d'impulsions détectées par le récepteur, nous pouvons à la fois calculer le régime du moteur et la distance parcourue par l'actionneur linéaire. L'actionneur linéaire optique de 35 lb a 50 (+/- 5) impulsions optiques par pouce de déplacement tandis que les actionneurs de 200 lb et 400 lb ont tous deux 100 (+/- 5) impulsions par pouce. En comparant la distance à laquelle chaque actionneur linéaire s'est étendu, nous sommes en mesure d'ajuster proportionnellement la vitesse des deux actionneurs afin qu'ils restent toujours à la même longueur tout en s'étendant.
Composants requis
- Deux actionneurs linéaires optiques
- Deux pilotes de moteur IBT-2
- Arduino Uno
- Source d'alimentation 12V
- 3 boutons momentanés (non vendus par Firgelli)
- Câblage supplémentaire
Schéma de câblage
Effectuez les connexions de câblage ci-dessus. Vérifiez toujours les couleurs des fils sortant de l'actionneur linéaire car la convention de coloration peut changer par rapport à ce qui est montré dans le diagramme ci-dessus.
Tutoriel rapide
Si vous souhaitez simplement que vos deux actionneurs linéaires se déplacent de manière synchrone, procédez simplement comme suit:
- Effectuez les connexions comme indiqué sur le schéma de câblage.
- Téléchargez et exécutez le premier programme ci-dessous.
- Copiez les deux valeurs produites par ce programme dans la ligne 23 du deuxième programme, ci-dessous.
- Téléchargez et exécutez le deuxième programme.
- Affinez votre système en faisant varier la variable K_p (ligne 37, deuxième programme). Cela se fait le plus facilement en attachant un potentiomètre à la broche analogique A0 et en modifiant le code pour lire le potentiomètre et en utilisant la fonction map (): K_p = map (analogRead (A0), 0, 1023, 0, 20000);
Le reste de ce didacticiel passera en revue plus en détail certaines des fonctionnalités clés des programmes. Encore une fois, nous réitérons qu'il ne s'agit pas d'un tutoriel exhaustif, mais plutôt d'un aperçu des éléments à prendre en compte lors de la création de votre propre programme.
Aperçu du programme d'étalonnage
Avant de pouvoir obtenir un contrôle synchrone, nous devons d'abord calibrer le système. Cela implique de compter le nombre d'impulsions par cycle d'actionnement car, comme indiqué dans les spécifications du produit, il existe une tolérance de (+/- 5) impulsions par pouce de course. Téléchargez et exécutez le programme ci-dessous. Ce programme rétractera complètement les actionneurs (ligne 53) et mettra la variable du compteur d'impulsions optique à zéro, il sera alors complètement déployé et complètement rétracté (lignes 63 et 74, respectivement). Pendant ce cycle d'actionnement, le nombre d'impulsions sera compté par le sous-programme de service d'interruption (ISR), lignes 153 et 166. Une fois le cycle d'actionnement terminé, le nombre moyen d'impulsions sera émis, ligne 88, notez ces valeurs pour plus tard.
https://gist.github.com/Will-Firgelli/89978da2585a747ef5ff988b2fa53904
Présentation du programme synchrone
Avant de télécharger le programme de contrôle synchrone, vous devez d'abord copier les valeurs produites par le programme d'étalonnage dans la ligne 23 et remplacer le tableau actuel: {908, 906} par vos propres valeurs. De plus, si vous utilisez l'actionneur linéaire de 35 lb, vous devrez changer la valeur de la variable de la ligne 29 de 20 millisecondes à 8 millisecondes.
Après avoir complètement rétracté une fois (pour identifier l'origine), vous pouvez déplacer les deux actionneurs linéaires de manière synchrone en appuyant sur les trois boutons correspondant aux commandes d'extension, de rétraction et d'arrêt. Les actionneurs resteront synchrones même sous des charges inégales en comparant leurs compteurs d'impulsions relatifs et en ajustant la vitesse entre eux pour rester toujours synchrones. Sachez que le programme actuel implémente un simple contrôleur proportionnel, la ligne 93, en tant que tel, est sujet à un dépassement et à une oscillation autour de l'équilibre. Vous pouvez régler cela en faisant varier la variable K_p, définie à la ligne 37. Cela se fait le plus facilement en attachant un potentiomètre à la broche analogique A0 et en modifiant le code pour lire le potentiomètre et en utilisant la fonction map (): K_p = map (analogRead (A0), 0, 1023, 0, 20000);
Pour de meilleurs résultats, nous suggérons fortement de retirer le régulateur proportionnel et de mettre en œuvre une boucle de régulation PID; Cependant, cela dépasse le cadre de ce didacticiel d'introduction et a été délibérément omis.
https://gist.github.com/Will-Firgelli/44a14a4f3cac3209164efe8abe3285b6
Utilisation d'actionneurs Bullet 36 et Bullet 50 en synchrone
En plus de notre actionneur linéaire de la série optique, nous proposons également deux actionneurs linéaires avec codeurs intégrés: le Bullet 36 Cal. et le Bullet 50 Cal, tous deux dotés d'un encodeur à effet Hall en quadrature interne. L'encodeur à effet Hall fonctionne sur le même principe que l'encodeur optique, mais au lieu d'utiliser la lumière, il utilise le magnétisme. En outre, étant un codeur en quadrature, il dispose de deux sorties de signal, chacune déphasée de 90 degrés. En tant que tel, vous devez utiliser une carte Arduino avec 4 broches d'interruption ou plus (l'Arduino Uno n'en a que deux) et modifier le code pour traiter l'entrée de deux signaux par actionneur. De plus, la variable de temps anti-rebond, falsepulseDelay devra être réglée avec K_p.
Conseils pour rédiger votre propre programme
Plus de deux actionneurs linéaires
Lors de l'utilisation de deux ou plusieurs actionneurs linéaires, l'Arduino Uno ne fonctionnera plus car il ne dispose que de deux broches d'interruption disponibles. Vous devrez utiliser une carte Arduino avec le nombre approprié de broches d'interruption disponibles, plus d'informations: https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/
Deuxièmement, dans un souci d'efficacité, il est conseillé de vectoriser votre programmation en utilisant des tableaux et des boucles for () pour itérer sur chaque actionneur.
Rebondir
Comme avec de nombreux capteurs, il est important d'être conscient des signaux de rebond. Comme pour les interrupteurs mécaniques, les codeurs peuvent également souffrir de rebond. Dans l'exemple ci-dessus, le processus anti-rebond a été géré par un simple délai (défini par la variable falsepulseDelay), il est important de gérer cela dans toutes les modifications logicielles que vous effectuez ou avec des circuits physiques pour filtrer le bruit de rebond.
Manipulation roll over
Si vous modifiez le code, tenez compte du rollover lorsque vous utilisez la fonction millis (). Les deux millis () et le tableau lastDebounceTime sont déclarés comme des variables longues non signées, ce qui signifie qu'ils peuvent stocker des valeurs jusqu'à 4 294 967 295 (32 ^ 2-1). Cela se traduit par une période de roulement d'environ 49,7 jours. Le programme actuel est conçu pour gérer le roulement dans les fonctions ISR (routine de service d'interruption): count_0 & count_1, mais si vous modifiez ce programme, assurez-vous de gérer correctement le roulement de variable, sinon votre programme plantera après ~ 49,7 jours d'utilisation continue. Pour plus d'informations, reportez-vous à: https://www.norwegiancreations.com/2018/10/arduino-tutorial-avoiding-the-overflow-issue-when-using-millis-and-micros/
