- Servomoteur
- Contrôle du servomoteur à l'aide de LPC2148 PWM et ADC
- Broches PWM et ADC dans ARM7-LPC2148
- Composants requis
- Schéma de circuit et connexions
- Programmation ARM7-LPC2148 pour la commande de servomoteur
Dans notre tutoriel précédent, nous avons interfacé le moteur pas à pas avec ARM7-LPC2148. Dans ce tutoriel, nous contrôlerons le servomoteur avec ARM7-LPC2148. Le servomoteur a un faible avantage de consommation d'énergie par rapport au moteur pas à pas. Un servomoteur arrête sa consommation d'énergie lorsque la position souhaitée est atteinte mais le moteur pas à pas continue de consommer de l'énergie pour verrouiller l'arbre dans la position souhaitée. Les servomoteurs sont principalement utilisés dans les projets de robotique en raison de leur précision et de leur manipulation facile.
Dans ce didacticiel, nous en apprendrons davantage sur le servomoteur et sur la manière d'interfacer le servo avec ARM7-LPC2148. Un potentiomètre est également interfacé pour faire varier la position de l'arbre du servomoteur et un écran LCD pour afficher la valeur de l'angle.
Servomoteur
Un servomoteur est une combinaison de moteur à courant continu, de système de contrôle de position et d'engrenages. La rotation du servomoteur est contrôlée en lui appliquant un signal PWM, la largeur du signal PWM décide de l'angle de rotation et de la direction du moteur. Ici, nous utiliserons le servomoteur SG90 dans ce tutoriel, c'est l'un des plus populaires et des moins chers. Le SG90 est un servo à 180 degrés. Donc, avec ce servo, nous pouvons positionner l'axe de 0 à 180 degrés:
- Tension de fonctionnement: + 5V
- Type d'engrenage: plastique
- Angle de rotation: 0 à 180 degrés
- Poids: 9g
- Couple: 2,5 kg / cm
Avant de pouvoir commencer la programmation du servomoteur, nous devons savoir quel type de signal doit être envoyé pour contrôler le servomoteur. Nous devons programmer le MCU pour envoyer des signaux PWM au fil de signal du servomoteur. Il y a un circuit de commande à l'intérieur du servomoteur qui lit le cycle de service du signal PWM et positionne l'arbre des servomoteurs à l'endroit respectif comme indiqué dans l'image ci-dessous
Toutes les 20 millisecondes, le servomoteur vérifie l'impulsion. Donc, ajustez la largeur d'impulsion du signal pour faire tourner l'arbre du moteur.
- Largeur d'impulsion de 1 ms (1 milliseconde) pour la rotation du servo à 0 degré
- Largeur d'impulsion de 1,5 ms pour une rotation à 90 degrés (position neutre)
- Largeur d'impulsion de 2 ms pour la rotation du servo à 180 degrés.
Avant de connecter le servo à ARM7-LPC2148, vous pouvez tester votre servo à l'aide de ce circuit de testeur de servomoteur. Vérifiez également comment un servomoteur peut être interfacé avec d'autres microcontrôleurs:
- Commande de servomoteur à l'aide d'Arduino
- Interfaçage du servomoteur avec le microcontrôleur 8051
- Commande de servomoteur avec MATLAB
- Commande de servomoteur avec Raspberry Pi
- Interfaçage du servomoteur avec le MSP430G2
- Interfaçage du servomoteur avec STM32F103C8
Contrôle du servomoteur à l'aide de LPC2148 PWM et ADC
Un servomoteur peut être contrôlé par LPC2148 en utilisant PWM. En fournissant un signal PWM à la broche PWM de SERVO avec une période de 20 ms et une fréquence de 50 Hz, nous pouvons positionner l'arbre du servomoteur autour de 180 degrés (-90 à +90).
Un potentiomètre est utilisé pour faire varier le cycle de service du signal PWM et faire tourner l'arbre du servomoteur, cette méthode est mise en œuvre en utilisant le module ADC dans LPC2148. Nous avons donc besoin des concepts PWM et ADC à implémenter dans ce didacticiel. Veuillez donc vous référer à nos tutoriels précédents pour apprendre PWM et ADC dans ARM7-LPC2148.
- Comment utiliser PWM dans ARM7-LPC2148
- Comment utiliser ADC dans ARM-LPLC2148
Broches PWM et ADC dans ARM7-LPC2148
L'image ci-dessous montre les broches PWM et ADC dans LPC2148. Les cases jaunes indiquent les (6) broches PWM et la case noire indique les (14) broches ADC.
Composants requis
Matériel
- ARM7-LPC2148
- Module d'affichage LCD (16x2)
- Servomoteur (SG-90)
- Régulateur de tension 3.3V
- Potentiomètre 10k (2 Nos)
- Planche à pain
- Connexion des fils
Logiciel
- Keil uVision5
- Outil magique Flash
Schéma de circuit et connexions
Le tableau ci-dessous montre la connexion entre le servomoteur et l'ARM7-LPC2148:
|
SERVO PINS |
ARM7-LPC2148 |
|
ROUGE (+ 5V) |
+ 5V |
|
MARRON (GND) |
GND |
|
ORANGE (PWM) |
P0.1 |
La broche P0.1 est la sortie PWM du LPC2148.
Le tableau ci-dessous montre les connexions de circuit entre l'écran LCD et l'ARM7-LPC2148.
|
ARM7-LPC2148 |
Écran LCD (16x2) |
|
P0.4 |
RS (sélection de registre) |
|
P0.6 |
E (Activer) |
|
P0.12 |
D4 (broche de données 4) |
|
P0.13 |
D5 (broche de données 5) |
|
P0.14 |
D6 (broche de données 6) |
|
P0.15 |
D7 (broche de données 7) |
|
GND |
VSS, R / W, K |
|
+ 5V |
VDD, A |
Le tableau ci-dessous montre les connexions entre ARM7 LPC2148 et potentiomètre avec régulateur de tension 3.3V.
|
IC régulateur de tension 3.3V |
Fonction Pin |
Broche ARM-7 LPC2148 |
|
1. broche gauche |
- Ve de GND |
Broche GND |
|
2. broche centrale |
Sortie régulée + 3,3 V |
Vers l'entrée du potentiomètre et la sortie du potentiomètre vers P0.28 du LPC2148 |
|
3. broche droite |
+ Ve à partir de 5V CONTRIBUTION |
+ 5V |
Points à noter
1. Un régulateur de tension de 3,3 V est utilisé ici pour fournir une valeur d'entrée analogique à la broche ADC (P0.28) du LPC2148. Comme nous utilisons une puissance de 5 V, nous devons réguler la tension avec un régulateur de tension de 3,3 V.
2. Un potentiomètre est utilisé pour faire varier la tension entre (0 V et 3,3 V) pour fournir une entrée analogique (ADC) à la broche P0.28 de LPC2148
3. La broche P0.1 du LPC2148 fournit une sortie PWM au servomoteur pour contrôler la position du moteur.
4. En fonction de la valeur d'entrée analogique (ADC), la position du servomoteur passe de (0 à 180 degrés) à la broche de sortie PWM à P0.1 de LPC2148.
Programmation ARM7-LPC2148 pour la commande de servomoteur
Pour programmer ARM7-LPC2148, nous avons besoin de l'outil keil uVision & Flash Magic. Nous utilisons un câble USB pour programmer la clé ARM7 via le port micro USB. Nous écrivons du code en utilisant Keil et créons un fichier hexadécimal, puis le fichier HEX est flashé sur le bâton ARM7 à l'aide de Flash Magic. Pour en savoir plus sur l'installation de keil uVision et Flash Magic et comment les utiliser, suivez le lien Premiers pas avec le microcontrôleur ARM7 LPC2148 et programmez-le à l'aide de Keil uVision.
Étapes impliquées dans la configuration du LPC2148 pour PWM et ADC pour contrôler le servomoteur
Étape 1: - Incluez les fichiers d'en-tête nécessaires pour le codage de LPC2148
#comprendre
Étape 2: - La prochaine chose est de configurer la PLL pour la génération d'horloge car elle règle l'horloge système et l'horloge périphérique du LPC2148 selon les besoins des programmeurs. La fréquence d'horloge maximale pour le LPC2148 est de 60 MHz. Les lignes suivantes sont utilisées pour configurer la génération d'horloge PLL.
void initilizePLL (void) // Fonction pour utiliser PLL pour la génération d'horloge { PLL0CON = 0x01; PLL0CFG = 0x24; PLL0FEED = 0xAA; PLL0FEED = 0x55; tandis que (! (PLL0STAT & 0x00000400)); PLL0CON = 0x03; PLL0FEED = 0xAA; PLL0FEED = 0x55; VPBDIV = 0x01; }
Étape 3: - La prochaine chose à faire est de sélectionner les broches PWM et la fonction PWM du LPC2148 en utilisant le registre PINSEL. Nous utilisons PINSEL0 comme nous utilisons P0.1 pour la sortie PWM de LPC2148.
PINSEL0 - = 0x00000008; // Réglage de la broche P0.1 de LPC2148 comme PWM3
Étape 4: - Ensuite, nous devons réinitialiser les minuteries à l'aide de PWMTCR (registre de contrôle de la minuterie).
PWMTCR = 0x02; // Réinitialiser et désactiver le compteur pour PWM
Ensuite, définissez la valeur de pré-échelle qui décide de la résolution de PWM.
PWMPR = 0x1D; // Valeur du registre de pré-échelle
Étape 5: - Ensuite, définissez le PWMMCR (registre de contrôle de correspondance PWM) car il définit le fonctionnement comme la réinitialisation, les interruptions pour PWMMR0 et PWMMR3.
PWMMCR = 0x00000203; // Réinitialiser et interrompre sur match MR0, interrompre sur match MR3
Étape 6: - La période maximale du canal PWM est définie à l'aide de PWMMR0 et la tonne du cycle de service PWM est initialement réglée à 0,65 msec
PWMMR0 = 20000; // Période de temps de l'onde PWM, 20msec PWMMR3 = 650; // Tonne d'onde PWM 0,65 msec
Étape 7: - Ensuite, nous devons définir l'activation du verrouillage sur les registres de correspondance correspondants en utilisant PWMLER
PWMLER = 0x09; // Activation du verrouillage pour PWM3 et PWM0
(Nous utilisons PWMMR0 & PWMMR3) Activez donc le bit correspondant en définissant 1 dans PWMLER
Étape 8: - Pour activer la sortie PWM sur la broche, nous devons utiliser le PWMTCR pour activer les compteurs de minuterie PWM et les modes PWM.
PWMPCR = 0x0800; // Activer PWM3 et PWM 0, PWM PWMTCR = 0x09 contrôlé par front unique; // Activer PWM et compteur
Étape 9: - Nous devons maintenant obtenir les valeurs du potentiomètre pour régler le cycle de service de PWM à partir de la broche ADC P0.28. Donc, nous utilisons le module ADC dans LPC2148 pour convertir l'entrée analogique des potentiomètres (0 à 3,3 V) en valeurs ADC (0 à 1023).
Étape 10: - Pour sélectionner la broche ADC P0.28 dans LPC2148, nous utilisons
PINSEL1 = 0x01000000; // Définition de P0.28 comme ADC INPUT AD0CR = (((14) << 8) - (1 << 21)); // Réglage de l'horloge et du PDN pour la conversion A / N
Les lignes suivantes capturent l'entrée analogique (0 à 3,3 V) et la convertissent en valeur numérique (0 à 1023). Et puis ces valeurs numériques sont divisées par 4 pour les convertir en (0 à 255) et finalement alimentées en sortie PWM dans la broche P0.1 de LPC2148. Ici, nous convertissons les valeurs de 0-1023 à 0-255 en le divisant par 4 car PWM de LPC2148 a une résolution de 8 bits (28).
AD0CR - = (1 << 1); // Sélectionnez le canal AD0.1 dans le temps de retard du registre ADC (10); AD0CR - = (1 << 24); // Démarre la conversion A / N while ((AD0DR1 & (1 << 31)) == 0); // Vérifiez le bit DONE dans le registre de données ADC adcvalue = (AD0DR1 >> 6) & 0x3ff; // Obtient le RÉSULTAT du registre de données ADC dutycycle = adcvalue / 4; // formule pour obtenir les valeurs de cycle de service de (0 à 255) PWMMR1 = cycle de service; // définit la valeur du cycle de service sur le registre de correspondance PWM PWMLER - = (1 << 1); // Activer la sortie PWM avec la valeur du cycle de service
Étape 11: - Ensuite, nous affichons ces valeurs dans le module d'affichage LCD (16X2). Nous ajoutons donc les lignes suivantes pour initialiser le module d'affichage LCD
Void LCD_INITILIZE (void) // Fonction pour préparer l'écran LCD { IO0DIR = 0x0000FFF0; // Définit la broche P0.12, P0.13, P0.14, P0.15, P0.4, P0.6 comme délai de sortie (20); LCD_SEND (0x02); // Initialise l'écran LCD en mode de fonctionnement 4 bits LCD_SEND (0x28); // 2 lignes (16X2) LCD_SEND (0x0C); // Affichage sur curseur désactivé LCD_SEND (0x06); // Curseur d'incrémentation automatique LCD_SEND (0x01); // Affichage clair LCD_SEND (0x80); // Première ligne première position }
Comme nous avons connecté l'écran LCD en mode 4 bits avec LPC2148, nous devons envoyer des valeurs à afficher sous forme de grignotage par grignotage (Upper Nibble & Lower Nibble). Les lignes suivantes sont donc utilisées.
void LCD_DISPLAY (char * msg) // Fonction pour imprimer les caractères envoyés un par un { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Envoie le quartet supérieur IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH pour imprimer les données IO0CLR = 0x00000020; // RW LOW Temps de retard du mode d' écriture (2); IO0CLR = 0x00000040; // EN = 0, RS et RW inchangés (c'est-à-dire RS = 1, RW = 0) temps de retard (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Envoie le quartet inférieur IO0SET = 0x00000050; // RS & EN HAUT IO0CLR = 0x00000020; temps de retard (2); IO0CLR = 0x00000040; temps de retard (5); i ++; } }
Pour afficher ces valeurs ADC et PWM, nous utilisons les lignes suivantes dans la fonction int main () .
LCD_SEND (0x80); sprintf (displayadc, "adcvalue =% f", dutycycle); LCD_DISPLAY (displayadc); // Afficher la valeur ADC (0 à 1023) angle = (adcvalue / 5.7); // Formule pour convertir la valeur ADC en angle (o à 180 degrés) LCD_SEND (0xC0); sprintf (anglevalue, "ANGLE =%. 2f deg", angle); LCD_DISPLAY (anglevalue);
Le code complet et la description vidéo du tutoriel sont donnés ci-dessous