Communication Spi avec microcontrôleur pic pic16f877a

Les microcontrôleurs PIC sont une plate-forme puissante fournie par micropuce pour les projets embarqués; sa nature polyvalente lui a permis de trouver des voies dans de nombreuses applications et n'a pas encore beaucoup évolué. Si vous avez suivi nos tutoriels PIC, vous auriez remarqué que nous avons déjà couvert un large éventail de tutoriels sur le microcontrôleur PIC à partir des bases. Dans le même flux, nous allons apprendre les protocoles de communication disponibles avec PIC et comment les utiliser. Nous avons déjà couvert I2C avec PIC Microcontroller.

Dans le vaste système d'applications embarquées, aucun microcontrôleur ne peut effectuer toutes les activités par lui-même. À un moment donné, il doit communiquer avec d'autres appareils pour partager des informations, il existe de nombreux types de protocoles de communication pour partager ces informations, mais les plus utilisés sont USART, IIC, SPI et CAN. Chaque protocole de communication a ses propres avantages et inconvénients. Concentrons-nous sur le protocole SPI pour le moment puisque c'est ce que nous allons apprendre dans ce tutoriel.

Qu'est-ce que le protocole de communication SPI?

Le terme SPI signifie « Serial Peripheral Interface ». Il s'agit d'un protocole de communication courant utilisé pour envoyer des données entre deux microcontrôleurs ou pour lire / écrire des données d'un capteur vers un microcontrôleur. Il est également utilisé pour communiquer avec des cartes SD, des registres à décalage, des contrôleurs d'affichage et bien plus encore.

Comment fonctionne le protocole SPI?

La communication SPI est une communication synchrone, ce qui signifie qu'elle fonctionne à l'aide d'un signal d'horloge qui est partagé entre les deux périphériques qui échangent les données. Il s'agit également d'une communication en duplex intégral car il peut envoyer et recevoir des données en utilisant un bus séparé. La communication SPI nécessite 5 fils pour fonctionner. Un simple circuit de communication SPI entre un maître et un esclave est illustré ci-dessous

Les cinq fils nécessaires à la communication sont SCK (Serial Clock), MOSI (Master Out Slave In), MISO (Master In Slave Out) et SS (Slave Select). La communication SPI n'a toujours lieu qu'entre un maître et un esclave. Un maître peut avoir plusieurs esclaves connectés. Le maître est responsable de la génération de l'impulsion d'horloge et celle-ci est partagée avec tous les esclaves. De plus, toutes les communications ne peuvent être initiées que par le maître.

La broche SCK (également appelée horloge série SCL) partage le signal d'horloge généré par le maître avec les esclaves. La broche MOSI (alias SDA –Serial Data Out) est utilisée pour envoyer les données du maître vers le pommade. La broche MISO (aka SDI - Serial Data In) est utilisée pour obtenir les données du baume au maître. Vous pouvez également suivre la flèche de la figure ci-dessus pour comprendre le mouvement des données / signal. Enfin, la broche SS (alias CS –Chip select) est utilisée lorsqu'il y a plus d'un module esclave connecté au maître. Cette entrée peut être utilisée pour sélectionner l'esclave requis. Un exemple de circuit où plus d'un esclave est connecté au maître pour la communication SPI est illustré dans le circuit ci-dessous.

Différence entre la communication I2C et SPI

Nous avons déjà appris la communication I2C avec PIC et nous devons donc être familiarisés avec le fonctionnement d'I2C et où nous pouvons les utiliser, comme I2C peut être utilisé pour interfacer le module RTC. Mais maintenant, pourquoi avons-nous besoin du protocole SPI alors que nous avons déjà I2C. La raison en est que les communications I2C et SPI sont des avantages à leur manière et sont donc spécifiques à l'application.

Dans une certaine mesure, la communication I2C peut être considérée comme présentant certains avantages par rapport à la communication SPI car I2C utilise moins de broches et devient très pratique lorsqu'il y a un grand nombre d'esclaves connectés au bus. Mais l'inconvénient d'I2C est qu'il dispose du même bus pour l'envoi et la réception de données et qu'il est donc relativement lent. C'est donc purement basé sur l'application de décider entre le protocole SPI et I2C pour votre projet.

SPI avec PIC16F877A utilisant le compilateur XC8:

Assez de bases, apprenons maintenant comment nous pouvons utiliser la communication SPI sur le microcontrôleur PIC16F877A en utilisant le compilateur MPLABX IDE et XC8. Avant de commencer, il est clair que ce tutoriel ne parle que de SPI dans PIC16F877a en utilisant le compilateur XC8, le processus sera le même pour les autres microcontrôleurs mais de légères modifications peuvent être nécessaires. Rappelez-vous également que pour les microcontrôleurs avancés comme la série PIC18F, le compilateur lui-même peut avoir une bibliothèque intégrée pour utiliser les fonctionnalités SPI, mais pour PIC16F877A, rien de tel n'existe, alors construisons-en une nous-mêmes. La bibliothèque expliquée ici sera donnée sous forme de fichier d'en-tête à télécharger en bas qui peut être utilisé pour PIC16F877A pour communiquer avec d'autres périphériques SPI.

Dans ce tutoriel, nous allons écrire un petit programme qui utilise la communication SPI pour écrire et lire des données à partir du bus SPI. Nous vérifierons ensuite la même chose en utilisant la simulation Proteus. Tout le code lié aux registres SPI sera créé dans le fichier d'en-tête appelé PIC16f877a_SPI.h. De cette façon, nous pouvons utiliser ce fichier d'en-tête dans tous nos projets à venir dans lesquels une communication SPI est requise. Et à l'intérieur du programme principal, nous utiliserons simplement les fonctions du fichier d'en-tête. Le code complet ainsi que le fichier d'en-tête peuvent être téléchargés ici.

Explication du fichier d'en-tête SPI:

Dans le fichier d'en-tête, nous devons initialiser la communication SPI pour PIC16F877a. Comme toujours, le meilleur point de départ est la fiche technique PIC16F877A. Les registres qui contrôlent la communication SPI pour PIC16F8777a sont le SSPSTAT et le registre SSPCON. Vous pouvez les connaître aux pages 74 et 75 de la fiche technique.

De nombreuses options de paramètres doivent être choisies lors de l'initialisation de la communication SPI. L'option la plus couramment utilisée est que la fréquence d'horloge sera réglée sur Fosc / 4 et sera effectuée au milieu et l'horloge sera réglée comme basse à l'état idéal. Nous utilisons donc également la même configuration pour notre fichier d'en-tête, vous pouvez facilement les modifier en modifiant les bits respectifs.

SPI_Initialize_Master ()

La fonction SPI initialize Master est utilisée pour démarrer la communication SPI en tant que maître. Dans cette fonction, nous définissons les broches respectives RC5 et RC3 comme broches de sortie. Ensuite, nous configurons le SSPTAT et le registre SSPCON pour activer les communications SPI

void SPI_Initialize_Master () { TRISC5 = 0; // SSPSTAT = 0b00000000; // pg 74/234 SSPCON = 0b00100000; // pg 75/234 TRISC3 = 0; // Définir comme sortie pour le mode esclave }

SPI_Initialize_Slave ()

Cette fonction est utilisée pour configurer le microcontrôleur pour qu'il fonctionne en mode esclave pour la communication SPI. En mode esclave, la broche RC5 doit être définie comme sortie et la broche RC3 doit être définie comme entrée. Le SSPSTAT et le SSPCON sont définis de la même manière pour l'esclave et le maître.

void SPI_Initialize_Slave () { TRISC5 = 0; // La broche SDO doit être déclarée comme sortie SSPSTAT = 0b00000000; // pg 74/234 SSPCON = 0b00100000; // pg 75/234 TRISC3 = 1; // Définir comme in out pour le mode maître }

SPI_Write (caractère entrant)

La fonction SPI Write est utilisée pour écrire des données dans le bus SPI. Il obtient les informations de l'utilisateur via la variable entrante, puis les utilise pour passer au registre Buffer. Le SSPBUF sera effacé dans l'impulsion d'horloge consécutive et les données seront envoyées dans le bus bit par bit.

void SPI_Write (caractère entrant) { SSPBUF = entrant; // Ecrit les données données par l'utilisateur dans le tampon }

SPI_Ready2Read ()

La fonction SPI prêt à lire est utilisée pour vérifier si les données du bus SPI sont reçues complètement et si elles peuvent être lues. Le registre SSPSTAT a un bit appelé BF qui sera mis à 1 une fois que les données ont été reçues complètement, donc nous vérifions si ce bit est défini s'il n'est pas défini, nous devons attendre qu'il soit configuré pour lire quoi que ce soit à partir du bus SPI.

non signé SPI_Ready2Read () { if (SSPSTAT & 0b00000001) renvoie 1; sinon retourner 0; }

SPI_Read ()

La lecture SPI est utilisée pour lire les données du bus SPI dans le microcontrôleur. Les données présentes dans le bus SPI seront stockées dans le SSPBUF, nous devons attendre que les données complètes soient stockées dans le Buffer et ensuite nous pouvons les lire dans une variable. Nous vérifions le bit BF du registre SSPSTAT avant de lire le tampon pour nous assurer que la réception des données est terminée.

char SPI_Read () // Lire les données reçues { while (! SSPSTATbits.BF); // Maintenir jusqu'à ce que le bit BF soit mis, pour s'assurer que les données complètes sont lues return (SSPBUF); // retourne les données lues }

Explication du programme principal:

Les fonctions expliquées dans la section ci-dessus seront dans le fichier d'en-tête et peuvent être appelées dans le fichier c principal. Alors écrivons un petit programme pour vérifier si la communication SPI fonctionne. Nous allons simplement écrire quelques données dans le bus SPI et utiliser la simulation proteus pour vérifier si les mêmes données sont reçues dans le débogueur SPI.

Comme toujours, commencez le programme en définissant les bits de configuration, puis il est très important d'ajouter le fichier d'en-tête que nous venons d'expliquer dans le programme comme indiqué ci-dessous

#comprendre #include "PIC16F877a_SPI.h"

Si vous avez ouvert le programme à partir du fichier zip téléchargé ci-dessus, le fichier d'en-tête sera par défaut présent dans le répertoire du fichier d'en-tête de votre fichier de projet. Sinon, vous devez ajouter le fichier d'en-tête manuellement dans votre projet, une fois ajoutés, vos fichiers de projet ressembleront à ceci ci-dessous

Dans le fichier principal, nous devons initialiser le PIC en tant que maître pour la communication SPI, puis dans une boucle while infinie, nous écrirons trois valeurs hexadécimales aléatoires dans le bus SPI pour vérifier si nous recevons la même chose pendant la simulation.

void main () { SPI_Initialize_Master (); tandis que (1) { SPI_Write (0X0A); __delay_ms (100); SPI_Write (0X0F); __delay_ms (100); SPI_Write (0X15); __delay_ms (100); } }

Notez que les valeurs aléatoires utilisées dans le programme sont 0A, 0F et 15 et ce sont des valeurs hexadécimales donc nous devrions voir la même chose pendant la simulation. C'est-à-dire que le code est terminé, ce n'est qu'un exemple mais nous pouvons utiliser la même méthodologie pour communiquer avec d'autres MCU ou avec d'autres modules de capteurs fonctionnant sur le protocole SPI.

Simulation de PIC avec le débogueur SPI:

Maintenant que notre programme est prêt, nous pouvons le compiler puis procéder à la simulation. Proteus a une fonctionnalité pratique appelée débogueur SPI , qui peut être utilisée pour surveiller les données sur un bus SPI. Nous utilisons donc la même chose et construisons un circuit comme indiqué ci-dessous.

Comme il n'y a qu'un seul périphérique SPI dans la simulation, nous n'utilisons pas la broche SS et lorsqu'elle n'est pas utilisée, elle doit être mise à la terre comme indiqué ci-dessus. Chargez simplement le fichier hexadécimal dans le microcontrôleur PIC16F877A et cliquez sur le bouton de lecture pour simuler notre programme. Une fois la simulation commencée, vous obtiendrez une fenêtre contextuelle qui affiche les données dans le bus SPI comme indiqué ci-dessous

Examinons de plus près les données qui arrivent et vérifions si elles sont les mêmes que celles que nous avons écrites dans notre programme.

Les données sont reçues dans le même ordre que nous avons écrit dans notre programme et la même chose est mise en évidence pour vous. Vous pouvez également essayer de simuler un programme pour communiquer avec deux microcontrôleurs PIC en utilisant le protocole SPI. Vous devez programmer un PIC comme maître et l'autre comme esclave. Tous les fichiers d'en-tête requis à cet effet sont déjà donnés dans le fichier d'en-tête.

Ceci n'est qu'un aperçu de ce que SPI peut faire, il peut également lire et écrire des données sur plusieurs appareils. Nous aborderons plus en détail SPI dans nos prochains tutoriels en interfaçant divers modules qui fonctionnent avec le protocole SPI.

J'espère que vous avez compris le projet et en avez appris quelque chose d'utile. Si vous avez des doutes, postez-les dans la section des commentaires ci-dessous ou utilisez les forums pour obtenir de l'aide technique.

Le code principal complet a été donné ci-dessous; vous pouvez télécharger les fichiers d'en-tête avec tout le code d'ici