Communication I2c sur microcontrôleur Nuvoton

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 la partie IIC pour le moment puisque c'est ce que nous allons apprendre dans ce tutoriel. Si vous êtes nouveau ici, consultez les didacticiels Nuvoton où nous avons discuté de chaque périphérique du microcontrôleur N76E003 à partir du didacticiel de démarrage très basique. Si vous souhaitez apprendre à utiliser I2C avec d'autres microcontrôleurs, vous pouvez consulter les liens ci-dessous.

• Comment utiliser I2C dans Arduino: Communication entre deux cartes Arduino
• Communication I2C avec le microcontrôleur PIC PIC16F877
• Interfaçage de l'écran LCD 16X2 avec ESP32 en utilisant I2C
• Communication I2C avec le Launchpad MSP430
• Interfaçage de l'écran LCD avec NodeMCU sans utiliser I2C
• Comment gérer les communications multiples (I2C SPI UART) dans un seul programme d'Arduino

I2C est un protocole de communication important développé par Philips (maintenant NXP). En utilisant ce protocole I2C, une MCU peut être connectée à plusieurs appareils et démarrer la communication. I2C fonctionne avec seulement deux fils, à savoir SDA et SCL. Où SDA signifie Serial data et SCL signifie Serial Clock. Cependant, ces deux broches nécessitent des résistances de rappel au niveau de tension VCC et avec une résistance de rappel adéquate, le bus pourrait prendre en charge 127 appareils avec une adresse unique.

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

Le terme IIC signifie « Inter Integrated Circuits ». Il est normalement désigné comme I2C ou I au carré C ou même comme protocole d'interface à 2 fils (TWI) à certains endroits, mais cela signifie tous la même chose. I2C est un protocole de communication synchrone, ce qui signifie que les deux appareils qui partagent les informations doivent partager un signal d'horloge commun. Il n'a que deux fils pour partager les informations dont l'un est utilisé pour le signal d'horloge et l'autre est utilisé pour l'envoi et la réception de données.

Comment fonctionne la communication I2C?

La communication I2C a été introduite pour la première fois par Phillips. Comme dit précédemment, il a deux fils, ces deux fils seront connectés entre deux appareils. Ici, un appareil est appelé un maître et l'autre appareil est appelé un esclave. La communication doit et se produira toujours entre deux, un maître et un esclave. L'avantage de la communication I2C est que plus d'un esclave peut être connecté à un maître.

La communication complète s'effectue via ces deux fils à savoir, Serial Clock (SCL) et Serial Data (SDA).

Serial Clock (SCL): partage le signal d'horloge généré par le maître avec l'esclave

Serial Data (SDA): envoie les données depuis et vers le maître et l'esclave.

A tout moment, seul le maître pourra initier la communication. Puisqu'il y a plus d'un esclave dans le bus, le maître doit se référer à chaque esclave en utilisant une adresse différente. Lorsqu'elle est adressée, seule la pommade avec cette adresse particulière répondra avec les informations pendant que les autres se taisent. De cette façon, nous pouvons utiliser le même bus pour communiquer avec plusieurs appareils.

Où utiliser la communication I2C?

La communication I2C est utilisée uniquement pour les communications à courte distance. Il est certainement fiable dans une certaine mesure car il a une impulsion d'horloge synchronisée pour le rendre intelligent. Ce protocole est principalement utilisé pour communiquer avec le capteur ou d'autres appareils qui doivent envoyer des informations à un maître. C'est très pratique lorsqu'un microcontrôleur doit communiquer avec de nombreux autres modules esclaves en utilisant un minimum de fils uniquement. Si vous recherchez une communication longue portée, vous devriez essayer RS232 et si vous recherchez une communication plus fiable, vous devriez essayer le protocole SPI.

I2C sur Nuvoton N76E003 - Configuration matérielle requise

Comme l'exigence de ce projet est d'apprendre la communication I2C en utilisant N76E003, nous utiliserons une EEPROM qui sera connectée à la ligne de données I2C. Nous stockerons certaines données dans l'EEPROM et les lirons également et les afficherons à l'aide de l'écran UART.

Comme la valeur stockée sera imprimée dans l'UART, tout type de convertisseur USB vers UART est requis. Vous pouvez également consulter le tutoriel sur UART avec Nuvoton si vous êtes nouveau dans la communication UART sur N76E003. Pour notre application, nous utiliserons le convertisseur CP2102 UART vers USB. Autre que ce qui précède, nous avons également besoin des composants suivants:

1. EEPROM 24C02
2. Résistances 2pcs 4.7k

Sans oublier que, outre les composants ci-dessus, nous avons besoin d'une carte de développement basée sur un microcontrôleur N76E003 ainsi que du programmeur Nu-Link. De plus, des fils de montage et de raccordement sont également nécessaires pour connecter tous les composants.

Interfaçage de l'AT24LC64 avec le Nuvoton N76E003 - Schéma du circuit

Comme nous pouvons le voir dans le schéma ci-dessous, l'EEPROM est connectée dans la ligne I2C avec deux résistances de rappel. À l'extrême gauche, la connexion de l'interface de programmation est affichée.

J'ai utilisé une carte d'expérimentation pour le CI AT24LC64 et j'ai connecté le CI à ma carte de programmation nuvoton à l'aide de fils de cavalier. Ma configuration matérielle avec le programmeur nu-ink est illustrée ci-dessous.

Broches I2C sur Nuvoton N76E003

Le schéma des broches du N76E003 peut être vu dans l'image ci-dessous-

Comme nous pouvons le voir, chaque broche a des spécifications différentes et chaque broche peut être utilisée à des fins multiples. Cependant, la broche 1.4 est utilisée comme broche SDA I2C, elle perdra le PWM et d'autres fonctionnalités. Mais ce n'est pas un problème car une autre fonctionnalité n'est pas requise pour ce projet. La même chose se produira pour le P1.3 est la broche SCL de I2C.

Étant donné que les broches I2C agissent comme un GPIO, il doit être configuré. Toutes les broches GPIO peuvent être configurées dans le mode décrit ci-dessous.

Selon la fiche technique, PxM1.n et PxM2. n sont deux registres qui sont utilisés pour déterminer le fonctionnement de contrôle du port d'E / S. Dans la fiche technique, il est indiqué que pour utiliser la fonctionnalité I2C, les modes d'E / S doivent être utilisés comme Open-drain pour les communications liées à I2C.

Communication I2C dans N76E003

Le périphérique I2C est une chose importante pour toute unité de microcontrôleur prenant en charge les fonctionnalités I2C. De nombreux types de microcontrôleurs différents sont livrés avec un périphérique I2C intégré. Cependant, dans certains cas, I2C peut être configuré manuellement à l'aide du contrôle logiciel lorsque la prise en charge matérielle liée à I2C n'est pas disponible (par exemple, de nombreux microcontrôleurs 8051). Cependant, le nuvoton N76E003 est livré avec un support périphérique I2C.

Le M76E003 prend en charge quatre types d'opérations dans les modes I2C: émetteur maître, récepteur maître, émetteur esclave et récepteur esclave. Il prend également en charge les vitesses standard (100 kbps) et rapides (jusqu'à 400 kbps) pour la ligne I2C. I2C fonctionne avec quelques règles génériques dans les lignes de signaux SCL et SDA.

Condition de démarrage et d'arrêt:

C'est une chose importante dans la communication I2C. Lorsque les données sont transférées vers la ligne I2C, elles commencent par une condition de début et se terminent par une condition d'arrêt.

La condition de démarrage est la transition haut-bas sur le SDA lorsque la ligne SCL est haute et la condition d'arrêt est la transition bas-haut sur le SDA lorsque la ligne SCL est haute. Ces deux conditions sont générées par le maître (le MCU ou tout ce qui contrôle les autres appareils esclaves). La ligne de bus reste occupée à cet état lorsque la condition de démarrage est initiée et reste à nouveau libre lorsque la condition d'arrêt est initiée.

La condition de démarrage et d'arrêt est parfaitement représentée dans la perspective du signal dans la fiche technique N76E003-

Adresse 7 bits avec format de données:

Le N76E003 prend en charge une adresse 7 bits et un format de données. Une fois la condition de démarrage initiée, le périphérique maître doit envoyer les données à la ligne I2C. Les premières données sont importantes. Si ces données ne sont pas correctement créées ou transmises, l'appareil connecté ne sera pas identifié et d'autres communications ne pourront pas être effectuées.

Les données se composent d'une adresse d'esclave de 7 bits, désignée SLA. Cette adresse de 7 bits doit être unique pour chaque périphérique si plusieurs périphériques sont connectés sur le bus. Après l'adresse 7 bits, le 8ème bit est le bit de direction des données. Cela signifie que, en fonction du 8ème bit, le maître envoie les informations à l'équipement esclave pour savoir si les données seront écrites dans l'équipement esclave ou si les données seront lues à partir de l'équipement esclave. Le 8ème bit est le bit R / W appelé notificateur de lecture ou d'écriture. Comme nous le savons tous, les informations 8 bits peuvent être de 128 types, prenant ainsi en charge 128 périphériques, mais I2C prend en charge 127 types de périphériques sur le même bus mais pas 128. Parce que l'adresse 0x00 est une adresse réservée qui est appelée une adresse d'appel générale. Si le maître souhaite envoyer des informations à tous les appareils,il adressera 0x00 et chaque appareil rejouera de la même manière que pour les configurations logicielles individuelles.

Ainsi, la transmission de données ressemble à ci-dessous-

Reconnaître:

Dans l'image d'adresse de données ci-dessus, le 9ème bit suivi du bit R / W est appelé bit d'accusé de réception. C'est important car en utilisant ce bit, le maître ou l'esclave répond à l'émetteur de données en tirant la ligne SDA vers le bas. Pour obtenir le bit d'acquittement, l'émetteur doit libérer la ligne SDA.

Programmation N76E003 pour la communication I2C

Le programme complet utilisé dans ce didacticiel se trouve au bas de cette page. L'explication des segments importants du code est la suivante:

Définissez les broches comme drain ouvert et configurez-les pour I2C:

Commençons par la section des broches I2C. Comme décrit précédemment, les ports I2C SCL et SDA doivent être configurés et définis comme configuration à drain ouvert. Pour ce faire, nous utilisons un fichier d' en- tête I2C.h avec un fichier source I2C.c . L'extrait de code ressemble à ceci:

faire {P13_OpenDrain_Mode; P14_OpenDrain_Mode; clr_I2CPX;} tandis que (0)

Le code ci-dessus définit les broches P13 et P14 comme broche Open-Drain et clr_I2CPX est utilisé pour sélectionner P13 et P14 comme broche SCL sur P1.3 et la broche SDA sur P1.4.

Cet I2CPX est le 0ème bit du registre de contrôle I2C I2CON. Si ce I2C_PX est mis à 1, les broches sont changées en P0.2 comme SCL et P1.6 comme SDA. Cependant, nous utiliserons P13 et P14. Les broches alternatives ne sont pas utilisées ici.

Registre de contrôle I2C I2CON:

Le registre de contrôle I2C I2CON est utilisé pour contrôler les opérations I2C. Le premier bit est le bit de sélection de broche I2C. Le régler sur 0 configure la broche I2C comme P13 et P14.

Le bit AA est l'indicateur d'assertion d'acquittement, si l'indicateur AA est positionné, un ACK sera renvoyé pendant l'impulsion d'horloge d'acquittement de la ligne SCL. S'il est effacé, un NACK (niveau haut sur SDA) sera renvoyé pendant l'impulsion d'horloge acquittée de la ligne SCL.

Le bit suivant est SI qui est l'interruption d'état I2C. Si l'interruption d'état I2C est activée, l'utilisateur doit vérifier le registre I2STAT pour déterminer quelle étape a été réussie et doit entreprendre l'action.

Le STO est l'indicateur STOP défini en mode maître. STO est automatiquement effacé par le matériel une fois que la condition STOP a été détectée.

Le bit suivant est le bit STA. Si cet indicateur est défini, I2C génère une condition START si le bus est libre. Si le bus est occupé, l'I2C attend une condition STOP et génère une condition START à la suite. Si STA est défini alors que l'I2C est déjà en mode maître et qu'un ou plusieurs octets ont été transmis ou reçus, l'I2C génère une condition START répétée. Le STA doit être effacé manuellement par le logiciel.

Le dernier, I2CEN est le bit d'activation ou de désactivation du bus I2C.

EEPROM 24C02:

Maintenant, arrivons au 24C02. Le package de support de carte de N76E003 a un code I2C pour le 24LC64 et peut être modifié facilement. Cependant, nous utiliserons une méthode simple pour comprendre la fonction I2C.

Si quelqu'un souhaite utiliser l'interfaçage détaillé avec l'EEPROM 24C02, le programme EEPROM dans le BSP peut être utilisé.

Nous ne connecterons le 24C02 qu'en I2C où le N76E003 sera maître et l'EEPROM sera un esclave. Ainsi, nous écrirons toutes les données dans l'adresse EEPROM et lirons la même chose.

Le brochage de l'EEPROM 24C02 est illustré ci-dessous.

A0, A1 et A2 sont trois broches de sélection d'adresse. Les broches WP sont des broches de protection en écriture et doivent être connectées à VSS pour permettre l'écriture dans l'EEPROM.

La fonctionnalité d'écriture d'octet est illustrée dans l'image ci-dessous.

Le cycle d'écriture complet se produit avec un bit de démarrage. Après cela, l'octet de contrôle doit être soumis. Dans l'octet de contrôle, les éléments suivants sont requis:

Après le bit de démarrage, se compose de l'adresse de l'esclave. 1010 est l'adresse statique et A0, A1 et A2 sont l'adresse basée sur la connexion matérielle. Si les trois broches sont connectées avec une alimentation GND ou VSS, elles seront lues comme 0. Sinon, si elles sont connectées avec VCC, elles seront lues comme 1. Dans notre cas, tous les A0, A1 et A2 sont connectés à VSS. Ainsi, tous ceux-ci seront 0.

Dépenses sur la condition de lecture ou d'écriture. La valeur de l'adresse avec le bit de lecture ou d'écriture sera - 0xA0 pour l'écriture et 0xA1 pour la lecture. Vient ensuite le bit d'acquittement et après cela, une adresse de 8 bits sera transmise où les données doivent être stockées et enfin, les données qui seront stockées à l'emplacement respectif. Ces choses sont effectuées dans un format étape par étape dans la fonction principale.

Fonction principale et boucle While:

void main (void) {char c = 0x00; InitialUART0_Timer3 (115200); TI = 1; // Important, utiliser la fonction prinft doit définir TI = 1; I2C_init (); tandis que (1) {EEPROM_write (1,0x55); c = EEPROM_read (1); printf ("\ n La valeur lue est% x", c & 0xff); }; }

La fonction principale est simple, elle écrit en permanence des valeurs dans l'EEPROM à l'adresse 1 et lit les données. Les données sont ensuite imprimées à l'aide de la fonction printf. Le printf imprime la valeur en hexadécimal.

La fonction d'écriture EEPROM comprend les éléments suivants qui ont été décrits dans la section EEPROM:

void EEPROM_write (adresse de caractère non signé, valeur de caractère non signé) {I2C_start (); I2C_write (0xA0); I2C_write (adresse); I2C_write (valeur); I2C_stop (); }

La fonction de démarrage I2C comprend les éléments suivants:

void I2C_start (void) {signé int time = timeout; set_STA; clr_SI; while ((SI == 0) && (temps> 0)) {temps--; }; }

Dans cette fonction, l'état du SI est vérifié avec la période de temporisation prédéfinie (définie dans I2C.h où le temps prédéfini est défini sur 1000). La fonction de démarrage commence par le réglage du STA et l'effacement du SI.

void I2C_stop (void) {signé int time = timeout; clr_SI; set_STO; while ((STO == 1) && (temps> 0)) {temps--; }; }

Identique à la fonction Démarrer, arrêter est utilisée. La fonction d' arrêt est lancée en configurant le STO suivi de l'effacement du SI. La fonction ci-dessous est la fonction de lecture I2C-

unsigned char I2C_read (unsigned char ack_mode) {signé int time = timeout; valeur de caractère non signé = 0x00; set_AA; clr_SI; while ((SI == 0) && (t> 0)) {temps--; }; valeur = I2DAT; if (ack_mode == I2C_NACK) {t = timeout_count; clr_AA; clr_SI; while ((SI == 0) && (t> 0)) {temps--; }; } valeur de retour; }

Le ack_mode et I2C_NACK , les deux sont définis dans le fichier d' en- tête I2C à 0 et 1 respectivement.

De même, la fonction d'écriture est créée -

void I2C_write (unsigned char value) {signed int time = timeout; I2DAT = valeur; clr_STA; clr_SI; while ((SI == 0) && (temps> 0)) {temps--; }; }

Flasher le code et la sortie

Le code a renvoyé 0 avertissement et 0 erreurs et a été flashé en utilisant la méthode de clignotement par défaut par le Keil. Si vous êtes nouveau, consultez le didacticiel de mise en route de nuvoton pour comprendre comment télécharger du code. Les informations de compilation du code peuvent être trouvées ci-dessous.

Construire la cible 'I2C_EEPROM' compilant I2C_EEPROM.c… compilant I2C.c… liaison… Taille du programme: data = 59.2 xdata = 0 code = 2409 création d'un fichier hexadécimal à partir de ". \ Output \ I2C_EEPROM"… ". \ Output \ I2C_EEPROM "- 0 Erreur (s), 0 Avertissement (s). Temps de construction écoulé: 00:00:04 Résumé de construction par lots: 1 réussi, 0 échoué, 0 ignoré - Temps écoulé: 00:00:04

Le matériel est en cours de configuration sur une maquette et fonctionne comme prévu. Comme vous pouvez le voir dans l'image ci-dessous, nous avons pu écrire une valeur sur l'EEPROM et la relire depuis la mémoire et l'afficher sur le moniteur série.

Regardez la vidéo ci-dessous pour une démonstration complète du fonctionnement du tableau pour ce code. J'espère que vous avez apprécié le didacticiel et appris quelque chose d'utile si vous avez des questions, laissez-les dans la section commentaires ci-dessous. Vous pouvez également utiliser nos forums pour publier d'autres questions techniques.