Communication Uart à l'aide du microcontrôleur pic

Dans ce didacticiel, nous apprenons à activer la communication UART avec le microcontrôleur PIC et à transférer des données vers et depuis votre ordinateur. Jusqu'à présent, nous avons couvert tous les modules de base tels que ADC, minuteries, PWM et avons également appris à interfacer les écrans LCD et les écrans 7 segments. Maintenant, nous nous équiperons d'un nouvel outil de communication appelé UART qui est largement utilisé dans la plupart des projets de microcontrôleurs. Consultez ici nos tutoriels complets sur les microcontrôleurs PIC utilisant MPLAB et XC8.

Ici, nous avons utilisé le MCU PIC16F877A, il dispose d'un module appelé «Récepteur et émetteur asynchrone synchrone universel adressable» bientôt appelé USART. USART est un système de communication à deux fils dans lequel les données circulent en série. USART est également une communication en duplex intégral, ce qui signifie que vous pouvez envoyer et recevoir des données en même temps qui peuvent être utilisées pour communiquer avec des périphériques, tels que des terminaux CRT et des ordinateurs personnels.

L' USART peut être configuré dans les modes suivants:

• Asynchrone (duplex intégral)
• Synchrone - Maître (semi-duplex)
• Synchrone - Esclave (semi-duplex)

Il existe également deux modes différents à savoir le mode 8 bits et 9 bits, dans ce tutoriel, nous allons configurer le module USART pour qu'il fonctionne en mode asynchrone avec un système de communication 8 bits, car c'est le type de communication le plus utilisé. Comme il est asynchrone, il n'a pas besoin d'envoyer un signal d'horloge avec les signaux de données. UART utilise deux lignes de données pour envoyer (Tx) et recevoir (Rx) des données. Le sol des deux appareils doit également être rendu commun. Ce type de communication ne partage pas d'horloge commune, par conséquent, un terrain d'entente est très important pour que le système fonctionne.

À la fin de ce tutoriel, vous pourrez établir une communication (UART) entre votre ordinateur et votre microcontrôleur PIC et basculer une LED sur la carte PIC depuis votre ordinateur portable. L'état de la LED sera envoyé à votre ordinateur portable à partir du MCU PIC. Nous allons tester la sortie en utilisant Hyper Terminal sur ordinateur. Une vidéo détaillée est également donnée à la fin de ce tutoriel.

Exigences:

Matériel:

• Carte de performance PIC16F877A
• Module de conversion RS232 vers USB
• Ordinateur
• Programmeur PICkit 3

Logiciel:

• MPLABX
• Hyper Terminal

Un convertisseur RS232 vers USB est nécessaire pour convertir les données série en une forme lisible par ordinateur. Il existe des moyens de concevoir votre propre circuit au lieu d'acheter votre propre module, mais ils ne sont pas fiables car ils sont soumis au bruit. Celui que nous utilisons est illustré ci-dessous

Remarque: chaque convertisseur RS232 vers USB nécessiterait l'installation d'un pilote spécial; la plupart d'entre eux devraient être installés automatiquement dès que vous branchez l'appareil. Mais si ça ne se détend pas !!! Utilisez la section des commentaires et je vous aiderai.

Programmation du microcontrôleur PIC pour la communication UART:

Comme tous les modules (ADC, Timer, PWM), nous devons également initialiser notre module USART de notre MCU PIC16F877A et lui demander de fonctionner en mode de communication UART 8 bits. Définissons les bits de configuration et commençons par la fonction d'initialisation UART.

Initialisation du module UART du microcontrôleur PIC:

Les broches Tx et Rx sont physiquement présentes aux broches RC6 et RC7. Selon la fiche technique, déclarons TX comme sortie et RX comme entrée.

// **** Définition des broches d'E / S pour UART **** // TRISC6 = 0; // Broche TX définie comme sortie TRISC7 = 1; // Broche RX définie comme entrée // ________ Broches d'E / S définies __________ //

Maintenant, le débit en bauds doit être réglé. La vitesse de transmission est la vitesse à laquelle les informations sont transférées dans un canal de communication. Cela peut être l'une des nombreuses valeurs par défaut, mais dans ce programme, nous utilisons 9600 car c'est la vitesse de transmission la plus utilisée.

/ ** Initialise le registre SPBRG pour la vitesse de transmission requise et règle BRGH pour la vitesse de transmission rapide ** / SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1; BRGH = 1; // pour un débit en bauds élevé // _________ Fin du réglage du débit en bauds _________ //

La valeur de la vitesse de transmission doit être réglée à l'aide du registre SPBRG, la valeur dépend de la valeur de la fréquence du cristal externe, les formules pour calculer la vitesse de transmission sont indiquées ci-dessous:

SPBRG = ((_XTAL_FREQ / 16) / Baud_rate) - 1;

Le bit BRGH doit être rendu haut pour permettre un débit binaire rapide. Selon la fiche technique (page 13), il est toujours avantageux de l'activer, car cela peut éliminer les erreurs lors de la communication.

Comme dit précédemment, nous travaillerons en mode asynchrone, par conséquent, le bit SYNC doit être mis à zéro et le bit SPEM doit être rendu haut pour activer les broches série (TRISC6 et TRICSC5)

// **** Activer le port série asynchrone ******* // SYNC = 0; // SPEN asynchrone = 1; // Activer les broches du port série // _____ Port série asynchrone activé _______ //

Dans ce didacticiel, nous enverrons et recevrons des données entre le MCU et l'ordinateur, nous devons donc activer les bits TXEN et CREN.

// ** Préparons la transmission et la réception ** // TXEN = 1; // activer la transmission CREN = 1; // activer la réception // __ module UART en place et prêt pour la transmission et la réception __ //

Les bits TX9 et RX9 doivent être mis à zéro pour que nous fonctionnions en mode 8 bits. Si une fiabilité élevée doit être établie, le mode 9 bits peut être sélectionné.

// ** Sélectionnez le mode 8 bits ** // TX9 = 0; // Réception 8 bits sélectionnée RX9 = 0; // Mode de réception 8 bits sélectionné // __ Mode 8 bits sélectionné __ //

Avec cela, nous terminons notre configuration d'initialisation. et est prêt à fonctionner.

Transmission de données via UART:

La fonction ci-dessous peut être utilisée pour transmettre des données via le module UART:

// ** Fonction pour envoyer un octet de date à UART ** // void UART_send_char (char bt) {while (! TXIF); // maintient le programme jusqu'à ce que le tampon TX soit libre TXREG = bt; // Charge le tampon de l'émetteur avec la valeur reçue} // _____________ Fin de la fonction ________________ //

Une fois que le module est initialisé, la valeur chargée dans le registre TXREG sera transmise via UART, mais la transmission peut se chevaucher. Par conséquent, nous devrions toujours vérifier l'indicateur d'interruption de transmission TXIF. Ce n'est que si ce bit est bas que nous pouvons passer au bit suivant pour la transmission sinon nous devons attendre que ce drapeau devienne bas.

Cependant, la fonction ci-dessus ne peut être utilisée que pour envoyer un seul octet de données, pour envoyer une chaîne complète, la fonction ci-dessous doit être utilisée

// ** Fonction pour convertir une chaîne en octet ** // void UART_send_string (char * st_pt) {while (* st_pt) // s'il y a un char UART_send_char (* st_pt ++); // le traiter comme une donnée d'octet} // ___________ Fin de la fonction ______________ //

Cette fonction peut être un peu difficile à comprendre car elle a des pointeurs, mais croyez-moi, les pointeurs sont merveilleux et ils facilitent la programmation et c'est un bon exemple de la même chose.

Comme vous pouvez le remarquer, nous avons de nouveau appelé UART_send_char () mais maintenant dans la boucle while. Nous avons divisé la chaîne en caractères individuels, chaque fois que cette fonction est appelée, un caractère sera envoyé au TXREG et il sera transmis.

Recevoir des données avec UART:

La fonction suivante peut être utilisée pour recevoir des données du module UART:

// ** Fonction pour obtenir un octet de date depuis UART ** // char UART_get_char () {if (OERR) // vérifier l'erreur {CREN = 0; // Si erreur -> Réinitialiser CREN = 1; // Si erreur -> Réinitialiser} while (! RCIF); // maintenez le programme jusqu'à ce que le tampon RX soit libre return RCREG; // recevoir la valeur et l'envoyer à la fonction principale} // _____________ Fin de la fonction ________________ //

Lorsqu'une donnée est reçue par le module UART, il la récupère et la stocke dans le registre RCREG. Nous pouvons simplement transférer la valeur vers n'importe quelle variable et l'utiliser. Mais il peut y avoir une erreur de chevauchement ou l'utilisateur peut envoyer des données en continu et nous ne les avons pas encore transférées vers une variable.

Dans ce cas, le bit de drapeau de réception RCIF vient à la rescousse. Ce bit passera à l'état bas chaque fois qu'une donnée est reçue et n'est pas encore traitée. Par conséquent, nous l'utilisons dans la boucle while créant un délai pour maintenir le programme jusqu'à ce que nous traitions cette valeur.

Commutation de la LED à l'aide du module UART du microcontrôleur PIC:

Venons-en maintenant à la dernière partie du programme, la fonction void main (void) , où nous allons faire basculer une LED à travers l'ordinateur en utilisant la communication UART entre PIC et l'ordinateur.

Lorsque nous envoyons un caractère «1» (depuis l'ordinateur), la LED sera allumée et le message d'état «LED ROUGE -> ON» sera renvoyé (depuis PIC MCU) à l'ordinateur.

De même, nous envoyons un caractère «0» (de l'ordinateur), la LED sera éteinte et le message d'état «LED ROUGE -> OFF» sera renvoyé (de PIC MCU) à l'ordinateur.

while (1) // Boucle infinie {get_value = UART_get_char (); if (get_value == '1') // Si l'utilisateur envoie "1" {RB3 = 1; // Allume la LED UART_send_string ("LED ROUGE -> ON"); // Envoi d'une notification à l'ordinateur UART_send_char (10); // La valeur ASCII 10 est utilisée pour le retour chariot (pour imprimer dans une nouvelle ligne)} if (get_value == '0') // Si l'utilisateur envoie "0" {RB3 = 0; // Éteint la LED UART_send_string ("RED -> OFF"); // Envoie une notification à l'ordinateur UART_send_char (10); // la valeur ASCII 10 est utilisée pour le retour chariot (pour imprimer dans une nouvelle ligne)}}

Simuler notre programme:

Comme d'habitude, simulons notre programme en utilisant proteus et découvrons s'il fonctionne comme prévu.

L'image ci-dessus montre un terminal virtuel dans lequel il affiche un message de bienvenue et l'état de la LED. On peut remarquer que la LED de couleur rouge est connectée à la broche RB3. Le fonctionnement détaillé de la simulation peut être trouvé dans la vidéo à la fin.

Configuration matérielle et test de la sortie:

La connexion pour ce circuit est vraiment simple, nous utilisons notre carte PIC Perf et connectons simplement les trois fils au convertisseur RS232 vers USB et connectons le module à notre ordinateur à l'aide d'un câble de données USB comme indiqué ci-dessous.

Ensuite, nous installons l' application Hyper Terminal (téléchargez-la ici) et l'ouvrons. Il devrait montrer quelque chose comme ça

Maintenant, ouvrez le Gestionnaire de périphériques sur votre ordinateur et vérifiez à quel port Com votre module est connecté, le mien est connecté au port COM 17 comme indiqué ci-dessous

Remarque: le nom du port COM de votre module peut changer en fonction de votre fournisseur, ce n'est pas un problème.

Revenez maintenant à l'application Hyper Terminal et accédez à Configurer -> Configuration du port ou appuyez sur Alt + C, pour obtenir la boîte de dialogue suivante et sélectionnez le port souhaité (COM17 dans mon cas) dans la fenêtre contextuelle et cliquez sur connecter.

Une fois la connexion établie, allumez votre carte PIC perf et vous devriez voir quelque chose comme ceci ci-dessous

Gardez votre curseur dans la fenêtre de commande et entrez 1 puis appuyez sur Entrée. La LED sera allumée et l'état sera affiché comme indiqué ci-dessous.

De la même manière, gardez votre curseur dans la fenêtre de commande et entrez 0 puis appuyez sur Entrée. La LED sera éteinte et l'état sera affiché comme indiqué ci-dessous.

Vous trouverez ci-dessous le code complet et une vidéo détaillée, qui montrera comment la LED répond en temps réel pour «1» et «0».

Voilà les gars, nous avons interfacé PIC UART avec notre ordinateur et transféré les données pour faire basculer la LED en utilisant Hyper terminal. J'espère que vous avez compris, sinon, utilisez la section commentaires pour poser votre question. Dans notre prochain tutoriel, nous utiliserons à nouveau UART mais le rendrons plus intéressant en utilisant un module Bluetooth et en diffusant les données en direct.

Vérifiez également la communication UART entre deux microcontrôleurs ATmega8 et la communication UART entre ATmega8 et Arduino Uno.