Cours:TPS 2103 tp mcp23017

De troyesGEII
Aller à : navigation, rechercher

Fiche résumé

Retour à la liste des Tds/Tps

Éléments de correction

Arduino-nano-pinout.png

matériel

  • carte arduino nano
  • shield arduino nano
  • shield i2c
  • plaque à essais
  • fils M-M
  • 2 bps
  • 2 leds 5mm
  • 1 résistance 10k
  • 2 résistances 330

GPIO expander

Lorsque le nombre d'entrées/sorties disponibles sur un µcontrôleur n'est pas suffisant, il est possible d'utiliser un périphérique/composant pour en ajouter.

On parle de GPIO (General Purpose Input Output / Entrée-Sortie à usage générique) expander


Le mcp23017 que nous allons utiliser (cf datasheet), possède une liaison i2c (Inter Integrated Circuit Bus), aussi nommé TWI (Two Wire Interface).

Pour rappel, le bus i2c est une liaison série, synchrone, half-duplex, qui nécessite 2 fils SDA (données) et SCL (l'horloge), en plus de la masse.

Identification des adresses i2c

Le principe de connexion sur le bus i2c est représenté sur la figure ci-dessous.

Les résistances de pull-up sont indispensables, elles imposent la tension représentant le niveau logique 1.

Pour votre culture, d'un point de vue logique, nous avons :

  • un niveau logique 0 dominant
  • un niveau logique 1 récessif

c'est à dire que si plusieurs composants veulent imposer des niveaux logiques différents sur les lignes SDA et SCL, le niveau logique 0 l'emporte.

I2cMasterSlave.png

L'adresse des composants i2c est codée sur 7 bits, donc 2^7 adresses possibles. En pratique certaines adresses sont réservées, se référer par ex à la page wikipedia pour plus de détails : https://fr.wikipedia.org/wiki/I2C

Nous utiliserons ce "shieldI2c", qui comporte 2 composants I2c (mcp23017 et mcp3424).

Le bus i2c est présent sur le connecteur rouge. Il convient de relier la carte arduino Nano que nous programmons à ce connecteur, en utilisant le shield fabriqué en début d'année.


Attention, le cavalier bleu permet de choisir la tension d'alimentation (3,3V ou 5V). Par ex:

  • arduino Nano : 5v
  • raspberry pi : 3.3V


 ShieldEcran.png


On rappelle que l'@ d'un composant i2c (sauf cas particuliers) est définie sur 7 bits.

Question.jpg Trouver dans la datasheet les différentes adresses possibles du composant MCP23017 et compléter le tableau suivant

Adresse
Binaire Hexa Décimal
A6 A5 A4 A3 A2 A1 A0

Sur la carte, les valeurs des entrées A2,A1,A0 du mcp23017 sont déterminées par la position des 3 switchs.

Question.jpg Sachant que les GPIOs du MCP23017 sont séparés en 2 (PORTA / PORTB) comportant chacun 8 broches, en déduire :

  • le nombre de composants mcp23017 utilisables sur le même bus i2c
  • le nombre maximum de gpio que l'on peut ajouter avec des mcp23017


Remarque :

La figure ci-contre représente le début de la trame i2c pour s'adresser à une cible.

Il s'agit d'une valeur sur 8 bits, composée de :

  • 7 bits d'adresse
  • 1 bit de lecture ou d'écriture

On trouve alors la notion d'adresse sur 8 bits en considérant cet ensemble de 8 bits.

TrameAddresseI2c.png


Question.jpg Utiliser le programme I2cScanner pour lister les adresses des 2 composants reliés sur le bus I2c

En déduire

  • Les valeurs des bits A2/A1/A0 pour le mcp23017
  • l'adresse du CAN i2c (MCP3424)

Les registres du mcp23017

Comme la plupart des composants i2c, nous devons lire/écrire des valeurs dans des registres, principe vu dans le td i2c registres.

Attention : les registres des targets i2c ne sont pas réinitialisées lorsque le µcontrôleur redémarre. Pour les réinitialiser vous devez couper l'alimentation du/des composants. (par ex en débranchant le cordon usb)

La correspondance adresses<=>registre est modifiable selon 2 configurations pour le mcp23017 (cf datasheet page 12). On utilisera le mode par défaut :

Adresse Nom du registre Valeur par défaut description
0x00 IODIRA 0b11111111 PORTA : broche en entrée (1) ou sortie (0)
0x01 IODIRB 0b11111111 PORTB : idem
0x02 IPOLA 0b00000000 PORTA : si à 1, inverse la valeur des entrées
0x03 IPOLB 0b00000000 PORTB : idem
0x04 GPINTENA 0b00000000 PORTA : si à 1, un changement d'état de l'entrée active la sortie d'interruption
0x05 GPINTENB 0b00000000 PORTB : idem
0x06 DEFVALA 0b00000000 PORTA : valeur de comparaison des entées pour générer une interruption (cf INTCONA)
0x07 DEFVALB 0b00000000 PORTB : idem
0x08 INTCONA 0b00000000 PORTA : si 1, génère une interruption si l'entrée est différente de la valeur de comparaison (DEFVALA)
0x09 INTCONB 0b00000000 PORTB : si à 0, génère une interruption si la valeur de l'entrée change
0x0A IOCON 0b00000000 registre général de configuration
0x0B IOCON 0b00000000 registre général de configuration
0x0C GPPUA 0b00000000 PORTA : activer(1) ou désactiver(0) la résistance de pull-up (100k)
0x0D GPPUB 0b00000000 PORTB : idem
0x0E INTFA 0b00000000 PORTA : indique (bit à 1) quelle(s) broches ont générées l'interruption
0x0F INTFB 0b00000000 PORTB : idem
0x10 INTCAPA 0b00000000 PORTA : mémorise la valeur du PORT au moment de l'interruption
0x11 INTCAPB 0b00000000 PORTB : idem
0x12 GPIOA 0b00000000 PORTA : modifier/lire l'état des broches
0x13 GPIOB 0b00000000 PORTB : idem
0x14 OLATA 0b00000000 PORTA : OUTPUT LATCH REGISTER, modifier/lire l'état des latch
0x15 OLATB 0b00000000 PORTB : idem



lecture d'une entrée

SchemaShieldNano.png

Comme indiqué dans le tableau précédent, toutes les GPIOs sont configurées en entrée.

La correspondance entre la sérigraphie de la carte et le numéro de GPIO est le suivant :

  • broche numérotée 2 -> GPB0
  • broche numérotée 3 -> GPB1
  • ...
  • broche numérotée 9 -> GPB7
  • broche numérotée 10 -> GPA0
  • broche numérotée 11 -> GPA1
  • ...
  • broche numérotée 17 -> GPA7


On connecte un bouton avec sa résistance de tirage sur la GPA2.

Question.jpg Faire en sorte que la LED1 (PD5) (cf schéma ci-contre) s'allume si le bouton est appuyé

Rque : Vous pouvez utiliser la fonction donnée en bas de TP pour afficher la valeur des registres.

On ajoute un 2ème bouton sur GPB6, sans mettre de résistance de tirage, il faudra utiliser celle du mcp23017.

Question.jpg Compléter votre programme pour que la LED (PB5) s'allume en fonction de l'état du 2ème bouton

gestion des sorties

On ajoute 2 leds sur les gpios du mcp23017, sur les broches GPA7 et GPB7.

Pensez aux résistances pour régler la valeur du courant dans les leds (environ 10mA)

Question.jpg Faire clignoter ces leds

Question.jpg Associer l'état d'un bouton à chaque led


utilisation de l'interruption du MCP23017

Lorsqu'on souhaite exécuter une action lors du changement d'état d'une entrée, les 2 solutions sont :

  • par scrutation
    • on observe en permanence l'état de l'entrée
    • la charge processeur est très importante
  • par interruption
    • un signal nous préviens d'un changement
    • la charge processeur est très faible


Le mcp23017 possède 1 sortie d'interruption par port :

  • INTA, pour les GPIOs du port A (broche 0 du shield i2c)
  • INTB, pour les GPIOs du port B (broche 1 du shield i2c)

Ces 2 sorties sont configurables de différentes façon (cf registre IOCON page 21).

Par défaut la sortie d'interruption est à l'état HAUT et passe à l'état BAS lorsqu'une entrée change d'état.

Sur le shield arduinoNano que nous utilisons, les 2 broches associées aux INT0 et INT1 ne sont pas disponibles. Nous allons utiliser les broches PD6 et PD7 (ECHO et TRIG sur le schéma de la carte).

Todo.jpg Relier ces 2 broches sur les broches centrales du connecteur pour le module Ultrason. (connecteur noir à 4 broches)

Le code suivant permet d'autoriser l'interruption de changement d'état associée aux broches PD6(PCINT22) et PD7 (PCINT23) : 

ISR(PCINT2_vect) // Interruption sur changement d'état
{
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // attention, ne pas utiliser les fonctions i2c dans l'interruption !!!!!!
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}
int main()
{
  ...
  PCMSK2 |=(1<<PCINT23)|(1<<PCINT22);
  PCICR |=(1<<PCIE2);
  sei();
  readI2cReg(mcp23017Ad,GPIOB); // permet d'acquitter une interruption en attente
  readI2cReg(mcp23017Ad,GPIOA); // permet d'acquitter une interruption en attente
  ...
}


Question.jpg Ecrire un programme qui utilise les interruption du MCP23017 pour qu'à l'appui sur l'un des boutons les 2 leds s'allument, et s'éteignent à l'appui sur l'autre bouton.

Rque: vous pouvez utiliser les registres

  • INTCAP(A/B) qui mémorise l'état des entrées lors de l'interruption
  • GPIO(A/B) qui donne la valeur actuelle des entrées

Pour aller plus loin

Vous pouvez essayer de reprendre le TP sur le clavier matriciel en le connectant directement au GPIO expander.

Ressources

Adresses des registres

#define IODIRA    0x00
#define IODIRB    0x01
#define IPOLA     0x02
#define IPOLB     0x03
#define GPINTENA  0x04
#define GPINTENB  0x05
#define DEFVALA   0x06
#define DEFVALB   0x07
#define INTCONA   0x08
#define INTCONB   0x09
#define IOCON1    0x0A
#define IOCON2    0x0B
#define GPPUA     0x0C
#define GPPUB     0x0D
#define INTFA     0x0E
#define INTFB     0x0F
#define INTCAPA   0x10
#define INTCAPB   0x11
#define GPIOA     0x12
#define GPIOB     0x13
#define OLATA     0x14
#define OLATB     0x15

Ecrire une valeur dans un registre

void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)
{
    Wire.beginTransmission(targetAddress); // start transmitting
    Wire.write(regAddress);                // sends @ registre
    Wire.write(regValue);                  // sends value registre
    Wire.endTransmission();                // stop transmitting
}

Lire une valeur dans un registre

uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)
{
    uint8_t regValue=0;
    Wire.beginTransmission(targetAddress); // start transmitting
    Wire.write(regAddress);          // sends @ registre
    Wire.endTransmission();    // stop transmitting
    Wire.requestFrom(targetAddress,(uint8_t) 1);
    while (Wire.available()) regValue = Wire.read();
    return regValue;
}

Affichage des registres du mcp23017

Voici une fonction pour afficher la valeur des registres du MCP23017. Il faut passer en paramètre de la fonction l'adresse i2c du composant. 

void serialPrintRegistresMCP23017(uint8_t targetAddress)
{
  const uint8_t nbRegister = 22;
  const char* nameRegister[nbRegister] ={ "IODIRA","IODIRB","IPOLA","IPOLB","GPINTENA","GPINTENB","DEFVALA",
                        "DEFVALB","INTCONA","INTCONB","IOCON","IOCON","GPPUA","GPPUB",
                        "INTFA","INTFB","INTCAPA","INTCAPB","GPIOA","GPIOB","OLATA","OLATB"
                      }; 
  Serial.print("Registres MCP23017, @:");
  Serial.println(targetAddress);
  Wire.beginTransmission(targetAddress);
  Wire.write((uint8_t)0x00);  // register pointer to zero  
  Wire.endTransmission();
  // attention, ne fonctionne que si le pointeur de registre
  // est configuré pour une incrémentation automatique dans le  mcp23017
  Wire.requestFrom(targetAddress, nbRegister); // lecture de tous les registres
  uint8_t regAddress=0;
  while(Wire.available())     // slave may send less than requested
  {
    uint8_t regValue = Wire.read();     // receive a byte as number
    Serial.print((String)"Register : ");  
    Serial.print(regAddress ,HEX);
    int length = strlen(nameRegister[regAddress]) ;  // longueur du nom du registre
    Serial.print((String) "\t" + nameRegister[regAddress]);

    // Format d'affichage suivant longeur du nom du registre
    if(length>7) {
      Serial.print("  ");
      Serial.println(regValue);
    }  
     else {
      Serial.print("\t  ");
      Serial.println(regValue);
    }
    regAddress++;
  }
  Serial.write('\n');    
}

documents

Récupérée de « http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:TPS_2103_tp_mcp23017&oldid=18779 »