–
Mise à jour le 25/09/2019 – Rubrique traitant de la communication I2C entre 3 cartes Arduino Mega , dont 1 maître et 2 esclaves . Niveau de difficulté du tutoriel 4/10
Sommaire :
- Objectif de ce tutoriel .
- Matériel nécessaire pour ce tutoriel .
- Quelques informations sur le bus I2c
- Information complémentaire sur la bibliothéque wire
- Fonction utilisable sur les cartes Arduino pour la communication I2c
- begin()
- requestFrom()
- beginTransmission()
- endTransmission()
- write()
- available()
- read()
- SetClock()
- onReceive()
- onRequest()
- Schéma de principe du montage .
- Programmation de l’ensemble .
- Programme à transférer sur la carte Arduino maître
- Programme à transférer sur la carte Arduino esclave 1
- Programme à transférer sur la carte Arduino esclave 2
- Retour au menu Tutoriel
- Retour au menu principal
Objectif de ce tutoriel |
Le but de ce montage est de vous faire appréhender le principe de fonctionnement de la communication I2C ceci pour le mettre en application dans différents montages qui jalonnent nos rubriques en particulier sur le robot Maya.
Le montage est le suivant :
Nous possédons un maître avec un Arduino Méga qui va dialoguer avec deux esclaves du même type. Chacun des esclaves recevra une Led mais également un bouton poussoir, permettant de modifier la couleur de la Led tant qu’il n’y a pas eu encore de réception I2C.
De son côté, la carte maitre recevra 2 potentiomètres qui agiront sur la couleur de la LED de la carte esclave correspondante, potentiomètre1 pour l’esclave 1 et led une, potentiomètre 2 pour l’esclave 2 LED 2.
Quand on tournera un des 2 potentiomètres, la nouvelle valeur parcourra le bus I2c via la carte correspondante pour le changement de couleur de la LED et uniquement lors du changement de cette valeur afin de ne pas saturer le réseau.
Dès lors qu’une valeur est reçue sur le Bus I2c, le bouton poussoir de la carte esclave correspondante est désactivé, et la couleur de la Led est modifiée en fonction de la valeur reçue.
.
Retour au sommaire
Matériel nécessaire pour ce tutoriel |
- 3 cartes Arduino Mega 2560
- 3 Module Grove Mega Shield V1.2 103020027
- Le module Grove Mega Shield est un e carte d’interface permettant de raccorder facilement sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino Mega.
Module Grove Mega Shield V1.2 103020027
- Le module Grove Mega Shield est un e carte d’interface permettant de raccorder facilement sans soudure les capteurs et les actionneurs Grove de Seeedstudio sur une carte compatible Arduino Mega.
- 2 module Led 8 mm RGB Grove V2.0 104020048
- Ce module led RGB 8 mm est compatible Grove et permet d’obtenir une couleur au choix à partir d’une sortie d’une microcontrôleur .
- 2 Module bouton Grove 111020000
- Ce module compatible Grove est un bouton-poussoir qui fait passer une sortie de l’état bas à l’état haut lors d’une pression. Il peut servir d’entrée digitale pour un microcontrôleur.
- 2 Module potentiomètre Grove 101020017
- Ce module potentiomètre compatible Grove délivre un signal analogique et est équipé d’une résistance de 10 kΩ
.
Retour au sommaire
Information complémentaire sur la bibliothéque wire |
Bibliothèque wire Arduino
La gestion du bus I²C et des fonctions hardware TWI (Two Wire Interface) des processeurs Atmel
est intégré nativement dans l’IDE Arduino et ne nécessite donc pas d’installation de bibliothèques externe.
Par défaut la bibliothèque utilise pour ses variables et buffers interne jusqu’a 220 octets de mémoire Ram et 2.3Ko de mémoire flash programme (bootloader Arduino compris). Certains microcontrôleurs comme les ATtiny peu généreux de ce point de vue limiteront la complexité du logiciel ou les possibilités d’utilisation d’autres fonctions.
Que ce soit pour économiser la quantité de Ram utilisée ou pour obtenir des trames I²C d’une longueur supérieure a 32 octets, il sera possible de modifier la taille des buffers d’émission et de réception utilisée par la bibliothèque en modifiant la valeur de la constante BUFFER_LENGHT declarée dans le fichier Wire.h situé dans le répertoire \hardware\arduino\avr\libraries\Wire. Par défaut cette valeur étant égale a 32 les buffers utilisent 32rx + 32tx = 64 octets de Ram, avec la majorité des circuits I²C il sera possible de diminuer cette valeur a 4 ou 8 en adaptant le logiciel.
Fonctions de base de la bibliothèque wire
Les variables utilisées par la bibliothèque seront déclarées au format uint8_t ou byte, il sera préférable de passer par une constante pour déterminer l’adresse de chaque périphérique. Const uint8_t Add : Adresse du périphérique distant sur 7bits la bibliothèque gérant le bit de poids faible R/W du dialogue I²C, le bit de poids fort de cette valeur est automatiquement mis à 0.
.
Retour au sommaire
Quelques informations sur le bus I2c |
Généralités sur le communication en I2c
- Le bus I2C permet de faire communiquer entre eux des composants électroniques très divers grace à seulement trois fils : Un signal de donnée ( SDA ), un signal d’horloge ( SCL ), et un signal de référence électrique ( Masse ).
- Les données sont transmises en série à 100Kbits/s en mode standard et jusqu’à 400Kbits/s en mode rapide.
- chaque périphérique sur le bus I2C est adressable, avec une adresse unique pour chaque périphérique du bus
- Le nombre maximal d’équipements est limité par le nombre d’adresses disponibles, 7 bits d’adressage et un bit R/W (lecture ou écriture), soit 128 périphériques, mais il dépend également de la capacité (CB) du bus (dont dépend la vitesse maximale du bus). Il faut savoir que des adresses sont réservées pour diffuser des messages en broadcast et que de nombreuses adresses sont déjà attribuées par les fabricants ce qui limite grandement le nombre d’équipements (une variante d’adressage sur 10 bits existe également).
Terminologie du bus I2C
- Emetteur : le composant qui envoie des données sur le bus.
- Récepteur : le composant qui reçoit les données présentes sur le bus.
- Maître : le composant qui initialise un transfert, génère le signal d’horloge et termine le transfert. Un maître peut être soit récepteur soit émetteur.
- Esclave : le composant adressé par un maître. Un esclave peut être soit récepteur soit émetteur.
- Multimaître : plus d’un maître peut tenter de commander le bus en même temps sans en altérer le message.
- Arbitrage : procédure réalisée afin de s’assurer que si plus d’un maître essaie simultanément de prendre la commande du bus, un seul sera autorisé à le faire.
- Synchronisation : procédure réalisée afin de synchroniser les signaux d’horloge fournis par deux ou plusieurs maîtres.
- SDA : ligne des signaux de données (Serial DAta).
- SCL : ligne des signaux d’horloge (Serial CLock).
Les adresses réservées sur le bus I2C :
Les addresses 0000 0xxx ne sont pas utilisées pour l’adressage de composants. Ils ont été résevés par Phillips pour effectuer certaines fonctions spéciales.
Adresse d’appel general
Adresse .0000 0000 : Après l’émission d’un appel général, les circuits ayant la capacité de traiter ce genre d’appel émettent un acquitement.
Le deuxième octet permet definir le contenu de l’appel
Adresse .0000 0010 : Les circuits qui le permettent rechargent leur adresse d’esclave.
Adresse .0000 0100 : Les circuits définissant leur adresse de façon matériel reinitialisent leur adresse d’esclave.
Adresse . 0000 0110 : RESET. Remet tout les registres de circuits connectés dans leur état initial ( Mise sous tension ). Les circuits qui le permettent rechargent leur adresse d’esclave.
Adresse . 0000 0000 : Interdit
Octet de Start .
Adresse . 0000 0001 : Cet octet est utilisé pour synchroniser les périphériques lents avec les périphériques rapides.
.
Retour au sommaire
Fonction utilisable sur les cartes Arduino
|
Bibliothèque ( fonction ) vous permettant de communiquer avec des appareils I2C
- begin()
- Description : Initialise la librairie Wire et se connecte au bus I2C en tant que maître ou esclave. Cette instruction ne doit normalement n’être appelée qu’une seule fois au début du programme.
- Syntaxe :
- Wire.begin()
- Wire.begin(adresse)
- Paramètres :
- addresse : l’adresse 7-bit esclave (optionnel); si non spécifiée, la connexion au bus se fait en mode maître.
.
- requestFrom()
- Description : Fonction utilisée par le périphérique maître, elle sert à demander une information à un esclave. L’argument de cette fonction est l’adresse de l’esclave à interroger.
- Syntaxe :
- Wire.requestFrom(address, quantity)
- Wire.requestFrom(address, quantity, stop)
- Paramètres :
.
Retour au sommaire
- beginTransmission()
- Description : Cette fonction commence la transmission vers un esclave sur le bus de communication. L’adresse de ce périphérique doit être passée en argument.
- Syntaxe :
- Wire.beginTransmission(adresse)
- Paramètres :
.
Retour au sommaire- endTransmission()
- Description : Termine une transmission à un périphérique esclave qui a été commencée par beginTransmission () et transmet les octets qui ont été mis en file d’attente par write () .
- Syntaxe :
- Wire.endTransmission()
- Wire.endTransmission(stop)
- Paramètres :
.
Retour au sommaire
- write()
- Description : Cette fonction écrit le paramètre qu’on lui donne (le premier) sur le bus de communication. Elle est commune aux deux types de périphériques .
- le maître écrit sur le bus ,fonction utilisée entre beginTransmission() et endTransmission() .
- l’esclave écrit sur le bus mais après requête du maître, il ne peut pas écrire de son propre chef.
- Syntaxe :
- Wire.write(value)
- Wire.write(string)
- Wire.write(data, length)
- Paramètres :
- value: une valeur à envoyer en un seul octet .
- string: une chaîne à envoyer en tant que série d’octets.
- data: un tableau de données à envoyer en octets
- length: le nombre d’octets à transmettre
- Description : Cette fonction écrit le paramètre qu’on lui donne (le premier) sur le bus de communication. Elle est commune aux deux types de périphériques .
.
Retour au sommaire
- available()
- Description : Cette fonction retourne le nombre d’octets disponibles à la lecture. Cette fonction est à appeler après requestFrom() sur un maître ou dans dans la fonction onReceive() sur l’esclave. Elle sert à savoir s’il y a quelque chose à lire ou pas et surtout combien d’octets seront à recevoir/stocker et analyser par le programme.
- Syntaxe : Wire.available()
- Paramètres : aucun
.
Retour au sommaire- read()
- Description : Lit un octet qui a été transmis d’un périphérique esclave à un maître après un appel à requestFrom () ou a été transmis d’un maître à un esclave.
- Syntaxe :
- Wire.read ()
- Paramètres : Aucun
.
Retour au sommaire
- SetClock()
-
- Description : Cette fonction modifie la fréquence d’horloge pour la communication I2C . Les appareils esclaves I2C n’ont pas de fréquence minimale d’horloge de travail, mais 100KHz est généralement la ligne de base.
- Syntaxe :
- Wire.setClock(clockFrequency)
- Paramètres : la valeur (en Hertz) de l’horloge de communication souhaitée. Les valeurs acceptées sont 100000 (mode standard) et 400000 (mode rapide). Certains processeurs prennent également en charge 10000 (mode basse vitesse), 1000000 (mode rapide plus) et 3400000 (mode haute vitesse). Reportez-vous à la documentation du processeur spécifique pour vous assurer que le mode souhaité est pris en charge.
-
.
Retour au sommaire
- onReceive()
- Description : Enregistre une fonction à appeler lorsqu’un périphérique esclave reçoit une transmission d’un maître.
- Syntaxe : Wire.onReceive(handler)
- Paramètres :
.
Retour au sommaire
- onRequest()
- Description : Enregistrer une fonction à appeler lorsqu’un maître demande des données à ce périphérique esclave.
- Syntaxe : Wire.onRequest(handler)
- Paramètres :
Information d’aprés le site : Arduino
.
Retour au sommaire
Schéma de principe du montage .
|
Tutoriel 003 sur la communication I2c . Schéma de principe , cablage de la carte maitre – RedOhm –
Tutoriel 003 sur la communication I2c . Schéma de principe , cablage des cartes esclaves – RedOhm –
.
Retour au sommaire
Programme à transférer sur la carte Arduino maître
|
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 |
/* * * Le 04/02/2018 * RedOhm Benoit Bertrand * Mazelin Hervé * * * Programme à transférer sur la carte maitre * * Communication d'un carte maitre vers 2 cartes Arduino Esclave * avec le protocole I2c * * Niveau de difficulté 4/10 * * Pour information * @author <mailto:redohm@bertrand-benoit.net>Bertrand BENOIT</mailto> * * * * */ // je charge la bibliothèque qui nous permet de communiquer // avec les composants utilisant le protocole I2C #include <Wire.h> // Définition des entrées sur lesquelles sont branchés les poentiomètres. #define POTENTIOMETER_LED_PIN 0 #define POTENTIOMETER_ENGINE_PIN 2 // Définition des adresses logiques des esclaves I2C. #define I2C_SLAVE_LED_ADDRESS 1 #define I2C_SLAVE_ENGINE_ADDRESS 2 // Afin de n'envoyer QUE des informations utiles sur le canal I2C, on // mémorise les valeurs précédentes des potentiomètres. int previousPotentiometer1Value = 0; int previousPotentiometer2Value = 0; // --------------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties // --------------------------------------------------------------------------- void setup() { // Ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // Initialise la library Wire et se connecte au bus I2C en tant que maître Wire.begin(); // Déclare les pins de l'arduino POTENTIOMETER_LED_PIN et POTENTIOMETER_ENGINE_PIN // en entrée pinMode(POTENTIOMETER_LED_PIN, INPUT); pinMode(POTENTIOMETER_ENGINE_PIN, INPUT); } // Création d'une Fonction dont l'objectif est de : // - lire la valeur analogique du potentiomètre dont l'adresse est spécifiée via le // paramètre *potentiometerPin* // // - la mettre à l'échelle, car dans cet exemple, on souhaite avoir une plage de // valeurs entre 0 et 255 // // - tester si cette valeur est différente de la précédente; ce qui est possible // avec le paramètre *previousValue* (qui est passé par référence) // // - si et seulement si c'est le cas, on l'envoie sur le bus I2C, pour l'esclave // dont l'adresse est spécifiée via *slaveAddress* // // La subtilité de cette méthode est le passage par adresse (plutôt que par valeur) // du paramètre previousValue, qui permet de lire/modifier la variable en dehors // de cette méthode. // Cela est indispensable pour pouvoir sauvegarder la valeur // lue via le potentiomètre et pouvoir la comparer avec les valeurs suivantes. /* * Creation de la fonction : readRegisterAndSendValue * */ void readRegisterAndSendValue(int potentiometerPin, int *previousValue, int slaveAddress) { // Lecture de la position du potentiomètre. int potValue = analogRead(potentiometerPin); // Mise à l'échelle. // pour cela on utilise la fonction Map // map (variable ,valeur basse de depart,valeur haute de depart ,new valeur basse, new valeur haute ) // valeur basse de depart = 0 // valeur haute de depart = 1023 // new valeur basse = 0 // new valeur haute = 255 potValue = map(potValue, 0, 1023, 0, 255); // Teste : la valeur est elle différente de la lecture précédente (autrement dit, est-ce // que le potentiomètre a été tourné ?). if (*previousValue != potValue) { // C'est le cas => sauvegarde de la valeur, pour les prochaines lectures/testes. *previousValue = potValue; // Envoie de la valeur à l'esclave I2C. // Principe et description : // 1 : Commencez une transmission vers la carte esclave I2C avec l'adresse donnée. // 2 : Ensuite, mettez en file d'attente les octets à transmettre avec la fonction write () // 3 : transmettez-les en appelant la fonction endTransmission () . // débute de la communication avec un esclave (ouvre le stockage données à envoyer avec write) Wire.beginTransmission(slaveAddress); // charge des octets pour une transmission du composant maître vers un composant esclave Wire.write(*previousValue); // Termine la transmission avec un composant esclave sur le bus I2C qui a été débutée avec // la fonction beginTransmission() Wire.endTransmission(); // Affiche un message d'information pour l'operateur ensemble facultatif Serial.print("From [Input"); Serial.print(potentiometerPin); Serial.print("] read/adapted value '"); Serial.print(*previousValue); Serial.print("' and sent it to I2C Slace with logical address '"); Serial.print(slaveAddress); Serial.println("'."); } } // --------------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // --------------------------------------------------------------------------- void loop() { // Grâce à la fonction readRegisterAndSendValue, il est facilement possible // de gérer autant de potentiomètre // (ou autre contrôleur d'entrée), et d'esclave I2C. // Lecture du premier potentiomètre, sauvegarde dans la variable *previousPotentiometer1Value* // (dont l'adresse est transmise grâce à l'opérateur &), // et émission de la valeur lue (si différente), sur le premier escale I2C. readRegisterAndSendValue(POTENTIOMETER_LED_PIN, &previousPotentiometer1Value, I2C_SLAVE_LED_ADDRESS); // Idem pour le second potentiomètre, et le second escale I2C. readRegisterAndSendValue(POTENTIOMETER_ENGINE_PIN, &previousPotentiometer2Value, I2C_SLAVE_ENGINE_ADDRESS); } |
.
Retour au sommaire
Programme à transférer sur la carte Arduino esclave 1
|
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
/* * Le 04/02/2018 * RedOhm Benoit Bertrand * Mazelin Hervé * * * Programme à transférer sur la carte esclave * * Communication d'un carte maitre vers 2 cartes Arduino Esclave * avec le protocole I2c * * Niveau de difficulté 4/10 * * Pour information * @author <mailto:redohm@bertrand-benoit.net>Bertrand BENOIT</mailto> */ // je charge la bibliothèque qui nous permet de communiquer // avec les composants utilisant le protocole I2C #include <Wire.h> //Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove #include <ChainableLED.h> // Définition de l'adresse logique de cet esclave I2C. #define I2C_SLAVE_ADDRESS 1 // Définition des entrées. #define BUTTON_PIN 3 #define LED_PIN1 6 #define LED_PIN2 7 #define NUM_LEDS 1 // Variable booléenne permettant de basculer sur les 2 modes suivants : // - soit c'est la pression du bouton qui permet de modifier la couleur de la LED (par défaut) // - soit c'est le fait de recevoir des signaux sur le bus I2C qui permet de modifier la couleur de la LED // (activé automatiquement dés la réception d'une valeur sur le bus I2C; ce qui désactive totalement // l'effet du bouton, jusqu'à réinitialisation de l'Arduino). bool receivedI2CSignal = false; // Definition des broches de la LED. ChainableLED leds(LED_PIN1, LED_PIN2, NUM_LEDS); // --------------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties // --------------------------------------------------------------------------- void setup() { // Ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // Initialise la library Wire et se connecte au bus I2C en tant que maître Wire.begin(I2C_SLAVE_ADDRESS); // Définition de la fonction qui prendra en charge les informations reçues sur le bus I2C. Wire.onReceive(manageEvent); // Déclare le bouton. pinMode (BUTTON_PIN, INPUT); } void manageEvent() { if (Wire.available() > 0) { // Enregistre le fait qu'au moins une valeur a été reçue sur le bus I2C, ce qui désactive // totalement l'effet du bouton. receivedI2CSignal = true; // Lit la donnée suivante, disponible sur le bus I2C. int readValue = Wire.read(); // Dans notre exemple, on s'assure que la valeur est comprise entre 0 et 255. readValue = readValue < 0 ? 0 : readValue; readValue = readValue > 255 ? 255 : readValue; // On change la couleur de la LED. leds.setColorRGB(0, readValue, 255 - readValue, readValue); // Affiche un message d'information. Serial.print("Valeur lue sur le bus I2C : '"); Serial.print(readValue); Serial.println("'."); } } // --------------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // --------------------------------------------------------------------------- void loop() { // Teste si une réception I2C a déjà eu lieu. if (receivedI2CSignal) { // C'est le cas, cette fonction ne fait donc rien de plus, la gestion de l'I2C est réalisée // dans la fonction manageEvent. return; } // A partir d'ici, on considère que c'est le bouton qui permet de modifier la couleur // de la LED. // Lit l'état du bouton. int buttonState = digitalRead (BUTTON_PIN); // Change la couleur de la LED, en fonction de l'état du bouton. if (buttonState == 0) leds.setColorRGB(0, 255, 0, 0); else leds.setColorRGB(0, 0, 0, 255); // Temporise légèrement.( 500 millseconde) delay(500); } |
.
Retour au sommaire
Programme à transférer sur la carte Arduino esclave 2
|
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
/* * Le 04/02/2018 * RedOhm Benoit Bertrand * Mazelin Hervé * * * Programme à transférer sur la carte esclave 2 * * Communication d'un carte maitre vers 2 cartes Arduino Esclave * avec le protocole I2c * * Niveau de difficulté 4/10 * * Pour information * @author <mailto:redohm@bertrand-benoit.net>Bertrand BENOIT</mailto> */ // je charge la bibliothèque qui nous permet de communiquer // avec les composants utilisant le protocole I2C #include <Wire.h> //Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove #include <ChainableLED.h> // Définition de l'adresse logique de cet esclave I2C. #define I2C_SLAVE_ADDRESS 2 // Définition des entrées. #define BUTTON_PIN 3 #define LED_PIN1 6 #define LED_PIN2 7 #define NUM_LEDS 1 // Variable booléenne permettant de basculer sur les 2 modes suivants : // - soit c'est la pression du bouton qui permet de modifier la couleur de la LED (par défaut) // - soit c'est le fait de recevoir des signaux sur le bus I2C qui permet de modifier la couleur de la LED // (activé automatiquement dés la réception d'une valeur sur le bus I2C; ce qui désactive totalement // l'effet du bouton, jusqu'à réinitialisation de l'Arduino). bool receivedI2CSignal = false; // Definition des broches de la LED. ChainableLED leds(LED_PIN1, LED_PIN2, NUM_LEDS); // --------------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties // --------------------------------------------------------------------------- void setup() { // Ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // Initialise la library Wire et se connecte au bus I2C en tant que maître Wire.begin(I2C_SLAVE_ADDRESS); // Définition de la fonction qui prendra en charge les informations reçues sur le bus I2C. Wire.onReceive(manageEvent); // Déclare le bouton. pinMode (BUTTON_PIN, INPUT); } void manageEvent() { if (Wire.available() > 0) { // Enregistre le fait qu'au moins une valeur a été reçue sur le bus I2C, ce qui désactive // totalement l'effet du bouton. receivedI2CSignal = true; // Lit la donnée suivante, disponible sur le bus I2C. int readValue = Wire.read(); // Dans notre exemple, on s'assure que la valeur est comprise entre 0 et 255. readValue = readValue < 0 ? 0 : readValue; readValue = readValue > 255 ? 255 : readValue; // On change la couleur de la LED. leds.setColorRGB(0, readValue, 255 - readValue, readValue); // Affiche un message d'information. Serial.print("Valeur lue sur le bus I2C : '"); Serial.print(readValue); Serial.println("'."); } } // --------------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // --------------------------------------------------------------------------- void loop() { // Teste si une réception I2C a déjà eu lieu. if (receivedI2CSignal) { // C'est le cas, cette fonction ne fait donc rien de plus, la gestion de l'I2C est réalisée // dans la fonction manageEvent. return; } // A partir d'ici, on considère que c'est le bouton qui permet de modifier la couleur // de la LED. // Lit l'état du bouton. int buttonState = digitalRead (BUTTON_PIN); // Change la couleur de la LED, en fonction de l'état du bouton. if (buttonState == 0) leds.setColorRGB(0, 255, 0, 0); else leds.setColorRGB(0, 0, 0, 255); // Temporise légèrement.( 500 millseconde) delay(500); } |
.
Retour au sommaire.
Pour tout probléme |
Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .
.
Retour au sommaire.