Bras7

Comme nous le savons, les microcontrôleurs prennent l'entrée analogique des capteurs analogiques et utilisent ADC (convertisseur analogique-numérique) pour traiter ces signaux. Mais que se passe-t-il si un microcontrôleur veut produire un signal analogique pour contrôler des appareils à commande analogique comme un servomoteur, un moteur à courant continu, etc.? Les microcontrôleurs ne produisent pas de tension de sortie comme 1V, 5V au lieu de cela, ils utilisent une technique appelée PWM pour faire fonctionner les appareils analogiques. Un exemple de PWM est le ventilateur de refroidissement de notre ordinateur portable (moteur à courant continu) qui doit être contrôlé en vitesse en fonction de la température, et la même chose est mise en œuvre en utilisant la technique de modulation de largeur d'impulsion (PWM) dans les cartes mères.

Dans ce tutoriel, nous contrôlerons la luminosité d'une LED à l'aide du PWM dans le microcontrôleur ARM7-LPC2148.

PWM (modulation de largeur d'impulsion)

PWM est un bon moyen de contrôler les appareils analogiques en utilisant une valeur numérique comme le contrôle de la vitesse du moteur, la luminosité d'une LED, etc. Bien que PWM ne fournit pas de sortie analogique pure, mais il génère des impulsions analogiques décentes pour contrôler les appareils analogiques. PWM module en fait la largeur d'une onde d'impulsion rectangulaire afin d'obtenir une variation de la valeur moyenne de l'onde résultante.

Cycle de service du PWM

Le pourcentage de temps pendant lequel le signal PWM reste HAUT (temps d'activation) est appelé comme facteur de marche. Si le signal est toujours activé, il est en cycle de service de 100% et s'il est toujours désactivé, il est en cycle de service de 0%.

Cycle de service = temps d'activation / (temps d'activation + temps d'arrêt)

Broches PWM dans ARM7-LPC2148

L'image ci-dessous indique les broches de sortie PWM de ARM7-LPC2148. Il y a au total six broches pour PWM.

Canal PWM	Broches de port LPC2148
PWM1	P0.0
PWM2	P0.7
PWM3	P0.1
PWM4	P0.8
PWM5	P0.21
PWM6	P0.9

Registres PWM dans ARM7-LPC2148

Avant d'entrer dans notre projet, nous avons besoin de connaître les registres PWM dans LPC2148.

Voici la liste des registres utilisés dans LPC2148 pour PWM

1. PWMPR: registre de pré-échelle PWM

Utilisation: C'est un registre 32 bits. Il contient le nombre de fois (moins 1) que PCLK doit effectuer un cycle avant d'incrémenter le compteur de minuterie PWM (il contient en fait la valeur maximale du compteur de pré-échelle).

2. PWMPC: compteur de prescaler PWM

Utilisation: C'est un registre 32 bits . Il contient la valeur du compteur incrémentiel. Lorsque cette valeur est égale à la valeur PR plus 1, le compteur de minuterie PWM (TC) est incrémenté.

3. PWMTCR: registre de contrôle de la minuterie PWM

Utilisation: il contient les bits de contrôle d'activation du compteur, de réinitialisation du compteur et d'activation PWM. C'est un registre 8 bits.

7: 4	3	2	1	0
RÉSERVÉ	PWM ACTIVER	RÉSERVÉ	RÉINITIALISATION DU COMPTEUR	COMPTEUR ACTIVER

Activation PWM: (Bit-3)
0- PWM désactivé

1- PWM activé
Compteur activé: (Bit-0)
0- Désactiver les compteurs

1- Activer le compteur
Réinitialisation du compteur: (Bit-1)

0- Ne rien faire.

1- Réinitialise PWMTC et PWMPC sur le front positif de PCLK.

4. PWMTC: compteur de minuterie PWM

Utilisation: C'est un registre 32 bits. Il contient la valeur actuelle de la minuterie PWM incrémentée. Lorsque le compteur du Prescaler (PC) atteint la valeur du Prescaler Register (PR) plus 1, ce compteur est incrémenté.

5. PWMIR: registre d'interruption PWM

Utilisation: c'est un registre 16 bits. Il contient les indicateurs d'interruption pour les canaux de correspondance PWM 0-6. Un indicateur d'interruption est défini lorsqu'une interruption se produit pour ce canal (MRx Interrupt) où X est le numéro de canal (0 à 6).

6. PWMMR0-PWMMR6: registre de correspondance PWM

Utilisation: C'est un registre 32 bits . En fait, le groupe Match Channel permet de définir 6 sorties PWM contrôlées à un seul front ou 3 sorties PWM contrôlées à double front. Vous pouvez modifier les sept canaux de correspondance pour configurer ces sorties PWM en fonction de vos besoins dans PWMPCR.

7. PWMMCR: registre de contrôle de correspondance PWM

Utilisation: C'est un registre 32 bits. Il contient les bits d'interruption, de réinitialisation et d'arrêt qui contrôlent le canal de correspondance sélectionné. Une correspondance se produit entre les registres de correspondance PWM et les compteurs de minuterie PWM.

31:21	20	19	18	..	5	4	3	2	1	0
RÉSERVÉ	PWMMR6S	PWMMR6R	PWMMR6I	..	PWMMR1S	PWMMR1R	PWMMR11	PWMMR0S	PWMMR0R	PWMMR01

Ici x est de 0 à 6

PWMMRxI (Bit-0)

ACTIVER OU DÉSACTIVER les interruptions PWM

0- Désactivez les interruptions PWM Match.

1- Activer l'interruption PWM Match.

PWMMRxR: (Bit-1)

RESET PWMTC - Valeur du compteur de minuterie chaque fois qu'elle correspond à PWMRx

0- Ne rien faire.

1- Réinitialise le PWMTC.

PWMMRxS: (Bit 2)

STOP PWMTC & PWMPC lorsque PWMTC atteint la valeur du registre Match

0- Désactivez la fonction d'arrêt PWM.

1- Activez la fonction d'arrêt PWM.

8. PWMPCR: registre de contrôle PWM

Utilisation: C'est un registre 16 bits. Il contient les bits qui activent les sorties PWM 0-6 et sélectionnent une commande à un ou deux fronts pour chaque sortie.

31:15	14: 9	8: 7	6: 2	1: 0
INUTILISÉ	PWMENA6-PWMENA1	INUTILISÉ	PWMSEL6-PWMSEL2	INUTILISÉ

PWMSELx (x: 2 à 6)

Mode Single Edge pour PWMx
1- Mode Double Edge pour PWMx.

PWMENAx (x: 1 à 6)

PWMx désactivé.
1- PWMx activé.

9. PWMLER: registre d'activation de verrouillage PWM

Utilisation: c'est un registre 8 bits. Il contient les bits Match x Latch pour chaque Match Channel.

31: 7	6	5	4	3	2	1	0
INUTILISÉ	LEN6	LEN5	LEN4	LEN3	LEN2	LEN1	LEN0

LENx (x: 0 à 6):

0- Désactiver le chargement de nouvelles valeurs de correspondance

1- Charger les nouvelles valeurs de correspondance à partir du registre PWMMatch (PWMMRx) lorsque le temporisateur est réinitialisé.

Commençons maintenant à construire la configuration matérielle pour démontrer la modulation de largeur d'impulsion dans le microcontrôleur ARM.

Composants requis

Matériel

Microcontrôleur ARM7-LPC2148
IC régulateur de tension 3.3V
Potentiomètre 10k
LED (toute couleur)
Module d'affichage LCD (16x2)
Planche à pain
Connexion des fils

Logiciel

Keil uVision5
Outil magique Flash

Schéma de circuit et connexions

Connexions entre LCD et 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

Connexion entre LED et ARM7-LPC2148

L'ANODE de la LED est connectée à la sortie PWM (P0.0) du LPC2148, tandis que la broche CATHODE de la LED est connectée à la broche GND de LPC2148.

Connexion entre ARM7-LPC2148 et potentiomètre avec régulateur de tension 3,3 V

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) de LPC2148 et parce que 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

Programmation ARM7-LPC2148 pour PWM

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.

Dans ce tutoriel, nous utiliserons la technique ADC et PWM pour contrôler la luminosité de la LED. Ici, le LPC2148 reçoit une entrée analogique (0 à 3,3 V) via la broche d'entrée ADC P0.28, puis cette entrée analogique est convertie en valeur numérique (0 à 1023). Ensuite, cette valeur est à nouveau convertie en valeur numérique (0 - 255) car la sortie PWM du LPC2148 n'a qu'une résolution de 8 bits (2 ⁸). La LED est connectée à la broche PWM P0.0 et la luminosité de la LED peut être contrôlée à l'aide du potentiomètre. Pour en savoir plus sur ADC dans ARM7-LPC2148 suivez le lien.

Étapes impliquées dans la programmation de LPC2148 pour PWM et ADC

Étape 1: - La toute première 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 2: - La prochaine chose est de sélectionner les broches PWM et la fonction PWM de LPC2148 en utilisant le registre PINSEL. Nous utilisons PINSEL0 comme nous utilisons P0.0 pour la sortie PWM de LPC2148.

PINSEL0 = 0x00000002; // Réglage de la broche P0.0 pour la sortie PWM

Étape 3: - Ensuite, nous devons réinitialiser les minuteries à l'aide de PWMTCR (registre de contrôle de la minuterie).

PWMTCR = (1 << 1); // Définition du registre de contrôle de minuterie PWM comme réinitialisation du compteur

Et puis, définissez la valeur de pré-échelle qui décide de la résolution de PWM. Je le mets à zéro

PWMPR = 0X00; // Définition de la valeur de pré-échelle PWM

Étape 4: - Ensuite, nous devons définir le PWMMCR (registre de contrôle de correspondance PWM) car il définit le fonctionnement comme la réinitialisation, les interruptions pour PWMMR0.

PWMMCR = (1 << 0) - (1 << 1); // Définition du registre de contrôle de correspondance PWM

Étape 5: - La période maximale du canal PWM est définie à l'aide de PWMMR.

PWMMR0 = valeur PWM; // Donner la valeur PWM Valeur maximale

Dans notre cas, la valeur maximale est de 255 (pour une luminosité maximale)

Étape 6: - Ensuite, nous devons définir l'activation du verrouillage sur les registres de correspondance correspondants en utilisant PWMLER

PWMLER = (1 << 0); // Loquet Enalbe PWM

(Nous utilisons PWMMR0) Activez donc le bit correspondant en définissant 1 dans PWMLER

Étape 7: - Pour activer la sortie PWM sur la broche, nous devons utiliser le PWMTCR pour activer les compteurs de minuterie PWM et les modes PWM.

PWMTCR = (1 << 0) - (1 << 3); // Activation du compteur PWM et PWM

Étape 8: - 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. Nous utilisons donc le module ADC dans LPC2148 pour convertir l'entrée analogique des potentiomètres (0 à 3,3 V) en valeurs ADC (0 à 1023).

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 (2 ⁸).

Étape 9: - 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.0 de LPC2148 sur laquelle la LED est connectée.

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 10: - 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", adcvalue); LCD_DISPLAY (displayadc); // Affiche la valeur ADC (0 à 1023) LCD_SEND (0xC0); sprintf (sortie led, "PWM OP =%. 2f", luminosité); LCD_DISPLAY (sortie led); // Afficher les valeurs de cycle de service de (0 à 255)

Le code complet et la description vidéo du didacticiel sont donnés ci-dessous.