circuits

Programmation des microcontrôleurs PIC

Les microcontrôleurs PIC sont un outil très utile et polyvalent pour une utilisation dans de nombreux projets électroniques. Ils sont très peu coûteux et faciles à trouver. Ils sont également très puissants et beaucoup sont capables de vitesses allant jusqu'à 64 MIPS en utilisant le bloc oscillateur interne, environ 16 fois plus rapide que la plupart des microcontrôleurs AVR comparables. Les PIC sont également faciles à programmer, mais la mise en place du projet peut parfois être délicate. Ces instructions vous guideront tout au long du processus de configuration du logiciel, de création d'un nouveau projet et de programmation de fonctions très simples pour tester la configuration et vous assurer que tout fonctionne. Ils sont conçus pour être très ouverts; une fois le projet créé et les bases terminées, le lecteur est encouragé à explorer toutes les fonctionnalités et extras non couverts dans ces instructions. Vous constaterez également que ces instructions commenceront pas à pas, mais à mesure que les instructions approchent de la fin, le lecteur est encouragé à explorer d'autres façons d'accomplir les tâches et à s'approprier le projet.

Ce dont vous aurez besoin Pour construire un projet avec un microcontrôleur PIC, il suffit de quelques éléments.

Microcontrôleur PIC
- Ces instructions concernent la programmation d'un MCU de la série PIC18F, bien que d'autres soient similaires.
- Obtenu sur le site Web de Microchips.
- Microchip permet aux étudiants possédant des adresses e-mail .edu valides de consulter gratuitement des PIC!
- Le PIC que j'utilise pour créer ces instructions est un PIC18F22K80
Débogueur en circuit PICkit 3
- Disponible auprès de Microchip.
- Coûte 45 $ pour le grand public et # 34 avec réduction pour les étudiants si vous avez une adresse e-mail .edu.
- Il existe également d'autres programmeurs qui fonctionneront tout aussi bien; cependant, c'est le meilleur pour commencer.
Fils de planche à pain et planche à pain
LED, boutons, potentiomètres ou tout autre élément que vous souhaitez connecter au PIC

Étape 1: créer du matériel

Avant de faire toute programmation, la première étape consiste à construire le matériel. Bien que le portefeuille PIC18F soit très important, de nombreuses puces ont plusieurs points communs. Pour des informations plus détaillées, consultez la section «Consignes de mise en route avec les microcontrôleurs PIC18Fxxxx» dans la fiche technique de vos appareils. Pour des brochages détaillés du microcontrôleur PIC, consultez la section "Diagramme des broches" dans la fiche technique de votre appareil.

Remarque: VDD = tension positive et VSS = masse.

Connectez la broche MCLR via une résistance de 1 kΩ au VDD.
Connectez un condensateur de 0, 1 μF entre chaque paire de paires VDD-VSS adjacentes ou paires AVDD-AVSS.
Connectez un condensateur 10μF entre VCAP et Vss.
Connectez la broche MCLR à la broche 1 du PICkit 3.
Connectez le VDD à la broche 2 du PICkit 3.
Connectez VSS à la broche 3 du PICkit 3.
Connectez la broche PGD à la broche 4 du PICkit 3.
Connectez la broche PGC à la broche 5 du PICkit 3.
Laissez la broche 6 du PICkit 3 non connectée.
Connectez toutes les entrées analogiques aux broches avec la fonctionnalité ANx où x est un nombre.
Connectez toutes les entrées ou sorties numériques aux broches avec la fonctionnalité Rxy où x est une lettre identifiant le port, et y est un nombre identifiant le bit.

Pour mon exemple, j'ai une LED connectée entre RA0 et la masse, l'essuie-glace d'un potentiomètre connecté à AN1 et un interrupteur DPST connecté à RA2. Vous pouvez trouver plus facile de programmer le PIC si vous avez esquissé un schéma de votre circuit.

Étape 2: obtenir un logiciel

Ces instructions utiliseront le compilateur XC8 et l'IDE MPLAB X de Microchip. Cette étape vous expliquera comment obtenir ces outils et vous assurer qu'ils ont été installés correctement.

Pour obtenir la dernière version du logiciel, visitez le site Web de Microchips à //www.microchip.com/pagehandler/en-us/family/mplabx/
Sélectionnez le logiciel pour votre système d'exploitation et suivez les instructions d'installation standard.

Remarque: Si vous utilisez Windows 8, vous devrez peut-être exécuter les programmes d'installation en mode de compatibilité pour Windows 7.

Une fois le logiciel installé, démarrez MPLAB X
Dans la barre de menu, sélectionnez Outils-> Options
Dans la boîte de dialogue Options, sélectionnez l'onglet Embedded et assurez-vous que XC8 est répertorié dans la liste de la chaîne d'outils.
S'il est répertorié, sélectionnez OK et passez à l'étape suivante.
S'il n'est pas répertorié, assurez-vous que l'instillation est terminée, puis cliquez sur le bouton Rechercher les outils de génération.
S'ils ne sont toujours pas répertoriés, consultez le forum Microchips pour obtenir de l'aide avec votre problème spécifique.

Étape 3: créer un nouveau projet

Dans cette étape, nous allons créer un nouveau projet basé sur un modèle de Microchip.

Dans la barre de menus, sélectionnez Fichier-> Nouveau projet ...
Dans la boîte de dialogue du nouveau fichier, développez Samples et sélectionnez Microchip Embedded
Dans la zone de projet, sélectionnez le modèle PIC18 C
Sélectionnez Suivant
Donnez au projet le nom que vous voulez
Choisissez un emplacement dans lequel enregistrer le projet dans la zone Emplacement du projet
Laissez le dossier de projet comme options par défaut
Cochez la case "Définir comme projet principal"
Sélectionnez Terminer

Le projet apparaîtra maintenant dans Project Explorer sur le côté gauche de l'écran.

Étape 4: Créer des paramètres

Avant de commencer la programmation, nous devons définir les paramètres de construction.
Créer une configuration

Cliquez avec le bouton droit sur le nom du projet dans la barre d'outils des projets.
Dans la boîte de dialogue Propriétés du projet, sélectionnez Gérer les configurations ...
Dans la boîte de dialogue Configurations, sélectionnez Nouveau
Dans la boîte de dialogue Nouveau nom de configuration, entrez Par défaut et cliquez sur OK
Dans la boîte de dialogue Configurations, assurez-vous que Default est sélectionné et cliquez sur Set Active
Cliquez sur OK dans la boîte de dialogue Configurations

Définir les propriétés de configuration

Dans la boîte de dialogue Propriétés du projet, sélectionnez "Conf: [Par défaut]" dans la liste Catégories
1. Dans la zone Périphérique, saisissez le nom du périphérique que vous utilisez. Dans mon cas PIC18F26K80
2. Dans la liste des outils matériels, sélectionnez PICkit3
3. Dans la chaîne d'outils du compilateur, sélectionnez XC8 (v ...) Où ... est la version que vous avez installée.
4. Sélectionnez Appliquer
Sous Conf: [par défaut] sélectionnez PICkit 3
1. Pour les catégories d'options, sélectionnez Power
2. Cochez "Circuit cible d'alimentation de PICkit3
3. Sélectionnez Appliquer.
Sous Conf: [par défaut] sélectionnez le compilateur XC8
1. Pour les catégories d'options, sélectionnez Optimisations
2. Définissez "Optimization Set" sur "none"
3. Sélectionnez Appliquer
Cliquez sur OK pour fermer la boîte de dialogue

Tester la configuration Pour tester la configuration, cliquez sur le bouton nettoyer et construire (celui avec le marteau et le balai). Le texte commencera à défiler dans la fenêtre de sortie au bas de la page. Si tout réussit, ce texte indiquera BUILD SUCCESSFUL (temps total: ...) . Si vous obtenez une erreur, recommencez cette étape en vous assurant que vous n'avez rien manqué et que tout a été appliqué.

Étape 5: définir les bits de configuration

L'étape suivante consiste à définir les bits de configuration. Les bits de configuration indiquent au MCU ses conditions initiales de mise sous tension. Ils sont utilisés pour définir la source et la vitesse de l'horloge, la configuration de l'heure du chien de garde et d'autres fonctionnalités similaires. Les bits de configuration dépendent de l'appareil, vérifiez donc la fiche technique de la puce que vous utilisez pour plus d'informations.

Dans l'explorateur de projet, développez Fichiers source et ouvrez configuration_bits.c
Supprimez tout le texte sous la ligne #endif
Notez qu'un nouvel onglet s'est ouvert en bas de l'écran
Réglez les bits selon vos besoins pour votre projet. Étant donné que ceux-ci dépendent de la puce, consultez la fiche technique pour plus d'informations sur ce que chacun fait. Certains paramètres courants suivent:
1. Jeu d'instructions étendu - Doit être réglé sur OFF lors de l'utilisation du modèle
2. Oscillateur - Utilisé pour sélectionner le processeur. Sauf si vous utilisez un cristal externe, laissez-le défini comme oscillateur RC interne. Voir la fiche technique pour d'autres configurations d'oscillateur. Remarque: CLKOUT permettra un débogage plus facile et devrait être activé s'il est disponible.
3. PLL Enable - Permettra une utilisation future de la PLL. Remarque: cela n'activera pas la PLL, cela ne fera que l'activer. Il est recommandé de l'activer.
4. Horloge de surveillance - La horloge de surveillance est utilisée pour garantir que le processeur ne se verrouille pas. Il est cependant beaucoup plus difficile à déboguer. Il est recommandé de le désactiver lors de la programmation initiale et de ne l'activer qu'une fois le projet presque terminé.
5. Protections en écriture / lecture de code / table - Utilisées pour désactiver l'écriture ou la lecture dans certaines plages de mémoire. Laissez tous ces éléments désactivés.
6. En cas de doute sur un paramètre, il est généralement prudent de le laisser par défaut.
Une fois tous les bits de configuration définis, cliquez sur le bouton "Générer le code source pour la sortie" en bas du panneau.
Le panneau passe maintenant à l'onglet Sortie. Sélectionnez tout le texte dans cet onglet et copiez-le dans le presse-papiers
Collez-le en bas du fichier configuration_bits.c et pres enregistrez.
Nettoyez et reconstruisez le projet en cliquant sur l'icône du balai et du marteau.
Assurez-vous que la construction a réussi. Vérifiez également qu'il n'y a pas eu d'erreurs dans la sortie

Si tout a fonctionné, passez à l'étape suivante. S'il y a des erreurs ou des avertissements, corrigez-les avant de continuer.

Étape 6: configurer l'oscillateur

L'étape suivante consiste à commencer la programmation; cependant, avant d'arriver au code d'application, nous devons programmer le code système. Le code système sont les fonctions de bas niveau telles que la configuration de l'oscillateur et les fonctions de retard de base.

Détermination des paramètres

Avant de pouvoir programmer les paramètres, nous devons choisir la vitesse à laquelle nous aimerions fonctionner. Pour cet exemple, j'utiliserai 16 MHz car la plupart des PIC peuvent fonctionner à cette vitesse. Pour ma configuration, j'utiliserai le post-appeleur 4 MHz du HF-INTOSC, et le 4x PLL donnant une fréquence de sortie de 4 MHz * 4x = 16 MHz

Dans la fiche technique, trouvez la section intitulée Configurations des oscillateurs
La première chose répertoriée dans cette section est les types d'oscillateur. Si vous utilisez l'oscillateur interne, utilisez les paramètres relatifs à INTIO1
Sur la page suivante ou deux, vous trouverez un schéma de l'oscillateur similaire à celui illustré. Il est utile de tracer le signal sur ce dessin pour vous assurer que la bonne vitesse est sélectionnée.
L'étape suivante consiste à programmer ces paramètres sur le MCU. Cela se fait en définissant des registres. Le premier registre à définir est OSCCON.
1. IDLEN - utilisé pour contrôler l'action de la commande sleep. Peut être laissé par défaut.
2. IRCF - Sélection de l'oscillateur. Étant donné que j'utilise HF-INTOSC / 4 (4 MHz), je devrai le régler sur une valeur binaire de 101
3. OSTS - Bit en lecture seule
4. HFIOFS - Bit en lecture seule
5. SCS - bits de sélection d'horloge. Puisque j'utilise l'oscillateur interne, je vais régler à 1x où x peut être 0 ou 1
Le prochain registre est OSCCON2; cependant, ce registre est principalement en lecture seule et n'est pas important à ce stade
Le dernier registre de configuration d'oscillateur est OSCTUNE. Nous ne réglerons pas la fréquence de ce projet, cependant nous devons utiliser ce registre pour activer la PLL en utilisant le bit PLLEN.

Application des paramètres

Retour à MPLAB
Dans l'explorateur de projets sous Fichiers source, ouvrez system.c
Au bas de ce fichier se trouve la fonction ConfigureOscillator. Supprimez les commentaires de cette fonction.
Pour définir les bits d'un registre, saisissez en majuscules le nom du registre, suivi des bits du mot en minuscule, puis d'un point et du nom du bit.
Pour régler les bits, suivez cela avec un signe égal. Pour utiliser le type binaire 0bXXXX où XXXX est le nombre binaire. Enfin, terminez la ligne avec un point-virgule.
Définissez tous les bits comme déterminé ci-dessus pour le registre OSCCON. Exemple: OSCCONbits.IRCF = 0b101;
Faites de même pour tous les autres registres d'oscillateur nécessaires. Voir ci-dessous pour un exemple de fonction ConfigureOscillator terminée.
Une fois la construction terminée et vérifiez les avertissements / erreurs

 / ** * Configurer la source d'horloge et la vitesse * / void ConfigureOscillator (void) {OSCCONbits. IRCF = 0b101; OSCCONbits. SCS = 0b00; OSCTUNEbits. PLLEN = 0b1; }

Étape 7: Attendre la fonction milliseconde

Une des fonctions les plus utiles est wait_ms. Ce n'est cependant pas une fonction dans la bibliothèque standard, et devra être programmé par vous. Pour cette implémentation, il y aura une boucle qui maintiendra le processeur jusqu'à ce que le temps donné se soit écoulé.

Les microcontrôleurs PIC18F ont besoin de 4 cycles d'horloge pour exécuter une ligne de code d'assemblage. Par conséquent, avec une horloge de 16 MHz, les lignes seront exécutées à 4 millions de lignes par seconde = 4000 lignes par milli-seconde. Puisqu'une boucle for prendra une instruction à chaque fois pour la comparaison, et deux pour l'opération une pour le corps de la boucle, cela fonctionnera parfaitement. Nous avons juste besoin de la boucle for pour boucler 1000 fois par milli-seconde.

Dans system.c, créez une nouvelle fonction en bas du fichier de type void wait_ms (uint16_t time)
Voici la fonction terminée

 / ** * Attendez un nombre donné de millisecondes en utilisant le schéma d'attente occupée. * @param time - temps d'attente en ms. * / void wait_ms (uint16_t time) {statique long timel = 0; timel = time * 1000l; for (; timel; timel -); // pas de condition initiale, alors que le temps est> 0, décrémente le temps à chaque boucle}

Ouvrez system.h dans le dossier Header Files du navigateur de projet
À la fin, ajoutez la ligne void wait_ms (uint16_t); pour prototyper la fonction.
Changer la ligne 8 de 8000000L à 16000000L
Créez et vérifiez les erreurs / avertissements

Étape 8: clignoter une LED

La meilleure façon de vérifier que tout est correctement configuré est de faire clignoter une lumière LED. Si le voyant clignote au rythme attendu, alors tout a été configuré correctement. Dans cet exemple, la LED est connectée au PORT A, broche 0 (RA0 sur la fiche technique). Si votre LED est connectée à une broche différente, utilisez les registres et bits appropriés.

Ouvrez main.c dans la visionneuse de projet sous les fichiers source.

La fonction void main (void) est le principal point d'entrée du programme. Lorsque le MCU est mis sous tension pour la première fois, il entre dans cette fonction. La première ligne appelle la fonction ConfigureOscillator que vous avez remplie pour définir la source d'horloge et la vitesse. La ligne suivante appelle InitApp, une fonction que nous remplirons sous peu, et enfin elle entre dans une boucle infinie. Puisqu'il n'y a pas de système d'exploitation pour que la fonction revienne, il n'y a pas d'appel de retour à la fin.
La fonction terminée devrait ressembler à ceci:

Immédiatement au-dessus de la boucle while, ajoutez le code suivant.
1. Réglez la broche LED comme sortie - TRISAbits.TRISA0 = 0; // définir un bit TRIS à 0 définit comme sortie, définit à 1 définit comme entrée
Dans la boucle while, ajoutez le code suivant
1. Réglez la LED sur OFF - LATAbits.LATA0 = 0; // les bits LAT contrôlent la sortie d'une broche. 0 = BAS, 1 = HAUT
2. Attendez 1/2 seconde - wait_ms (500);
3. Réglez la LED sur ON - LATAbits.LATA0 = 1;
4. Attendez 1/2 seconde - wait_ms (500);

 void main (void) {/ * Configurer l'oscillateur pour l'appareil * / ConfigureOscillator (); / * Initialiser les E / S et les périphériques pour l'application * / InitApp (); TRISAbits.TRISA0 = 0; // définit la broche comme sortie while (1) {LATAbits.LATA0 = 0; // définir la broche LOW wait_ms (500); // attend 0, 5 secondes LATAbits.LATA0 = 1; // définir la broche HIGH wait_ms (500); // attend 0, 5 seconde}}

Générez le programme et recherchez les erreurs ou les avertissements
Assurez-vous que le PICkit est correctement connecté au PIC et à l'ordinateur
Cliquez sur le bouton créer et programmer le périphérique (le bouton à droite du bouton nettoyer et créer)
Si vous y êtes invité, sélectionnez PICkit 3 et cliquez sur OK
Lorsque l'avertissement montre une double vérification, vous avez le bon PIC dans le circuit et cliquez sur OK
Si un avertissement s'affiche sur l'ID de périphérique cible, cliquez sur OK pour l'ignorer

Étape 9: lecture d'une valeur analogique

Jusqu'à présent, le programme peut faire clignoter une LED. Permet ensuite de lui donner une entrée utilisateur. Nous utiliserons un potentiomètre pour créer un signal analogique qui changera la vitesse de la LED. L'ADC prend une tension analogique et émet une valeur numérique.

Dans le navigateur de projet, ouvrez user.c sous Fichiers source
Au-dessus de la fonction InitApp, créez une nouvelle fonction void init_adc(void)
Entrez le code suivant pour initialiser le module ADC

 / ** * Initialise le convertisseur analogique-numérique. * / void init_adc (void) {TRISAbits. TRISA1 = 0b1; // définit la broche comme entrée ANCON0bits. ANSEL1 = 0b1; // définir la broche comme ADCON1bits analogiques. VCFG = 0b00; // définit la référence v + sur Vdd ADCON1bits. VNCFG = 0b0; // définit v- référence à GND ADCON1bits. CHSN = 0b000; // définit l'entrée négative sur GND ADCON2bits. ADFM = 0b1; // justifie à droite la sortie ADCON2bits. ACQT = 0b110; // 16 TAD ADCON2bits. ADCS = 0b101; // utilise Fosc / 16 pour la source d'horloge ADCON0bits. ADON = 0b1; // allume l'ADC}

Créez ensuite une autre fonction immédiatement après appelée uint16_t adc_convert(uint8_t channel)

 / ** * Préformez une conversion analogique-numérique. * @param channel Le canal d'entrée ADC à utiliser. * @return La valeur de la conversion. * / uint16_t adc_convert (canal uint8_t) ADRESL; // retourne le résultat

Dans la fonction InitApp, ajoutez la ligne init_adc()
Dans le fichier user.h ajoutez le prototype uint16_t adc_convert(uint8_t);
Changez principal pour qu'il corresponde à ce qui suit:

 void main (void) {uint16_t adc_value; // variable pour contenir le résultat de la conversion ADC dans / * Configure l'oscillateur pour le périphérique * / ConfigureOscillator (); / * Initialiser les E / S et les périphériques pour l'application * / InitApp (); TRISAbits. TRISA0 = 0; // définit la broche comme sortie tandis que (1) {LATAbits. LATA0 = 0; // définir la broche LOW adc_value = adc_convert (1); // préforme la conversion A / N sur le canal 1 wait_ms (adc_value>> 2); // attend 0, 5 secondes LATAbits. LATA0 = 1; // définir la broche HIGH adc_value = adc_convert (1); // préforme la conversion A / N sur le canal 1 wait_ms (adc_value>> 2); // attend 0, 5 seconde}}

Créez et téléchargez le code. Lorsque vous tournez le POT, la vitesse à laquelle le voyant clignote doit changer

Étape 10: lire une valeur numérique

Permet ensuite d'obtenir une entrée numérique à partir du commutateur. Lorsque l'interrupteur est éteint, le programme fait ce qu'il a toujours fait et lorsque l'interrupteur est activé, le programme allume la LED jusqu'à ce que l'interrupteur soit à nouveau éteint.

Pour définir une broche comme entrée, écrivez un 1 à ce bit de registre TRIS de broches - TRISAbits.TRISA2 = 1;
Si une broche partage des fonctions analogiques, il peut être nécessaire de la régler sur numérique en effaçant le bit approprié dans le registre ANCONx
Lors de l'écriture d'une valeur sur une broche, utilisez le registre LAT; cependant, lors de la lecture d'une valeur à partir d'une broche, utilisez le registre PORT - value = PORTAbits.RA2;
Remplacez le principal par le suivant:

 void main (void) {uint16_t adc_value; // variable pour contenir le résultat de la conversion ADC dans / * Configure l'oscillateur pour le périphérique * / ConfigureOscillator (); / * Initialiser les E / S et les périphériques pour l'application * / InitApp (); TRISAbits. TRISA0 = 0; // définit la broche comme TRISAbits en sortie. TRISA2 = 1; // définit la broche comme entrée ANCON0bits. ANSEL2 = 0; // définir la broche comme numérique while (1) {if (PORTAbits. RA2) // si la broche est haute {LATAbits. LATA0 = 1; // définir la broche comme haut} else // si la broche est basse {// clignoter les LED LATAbits. LATA0 = 0; // définir la broche LOW adc_value = adc_convert (1); // préforme la conversion A / N sur le canal 1 wait_ms (adc_value>> 2); // attend un certain temps LATAbits. LATA0 = 1; // définir la broche HIGH adc_value = adc_convert (1); // préforme la conversion A / N sur le canal 1 wait_ms (adc_value>> 2); // attendez un peu}}}

C'est ça! Vous avez maintenant les connaissances de base pour configurer un nouveau projet, lire et écrire sur des broches numériques et lire sur des broches analogiques. Ces trois fonctionnalités vous permettront de réaliser 90% des projets utilisant des PIC sur Internet. De plus, au fur et à mesure que vous poursuivez votre exploration des microcontrôleurs PIC, vous constaterez que la plupart des autres fonctionnalités nécessitent des étapes très similaires pour configurer les périphériques et lire et accéder directement aux registres.