Cours:TPheritageIO

Nous allons utiliser un gpio expander en i2c qui permet d'ajouter facilement un grand nombre d'entrées/sorties sur un système.

Le composant utilisé, un mcp23008, possède 8 gpio. Son @i2c est réglable à l'aide de 3 broches (sur la carte utilisée avec les 3 switchs) ce qui permet au maximum d'en utiliser 8 sur le même bus i2c.

On peut donc ajouter jusqu'à 64 entrées/sorties en utilisant ce composant.

Nous souhaitons écrire un programme qui permet de piloter des lampes/leds, certaines connectées directement sur les gpio de la carte programmable, d'autres branchées sur le gpio expander.

Dans tous les cas, il s'agit de Lampe, qu'elle soit une LampeI2c ou une LampeGPIO.

Chaque Lampe présente :

• la propriété ou attribut suivant :
  • isAllumee
• les fonctionnalités ou méthodes suivantes :
  • allumer
  • eteindre
  • changer

"Diagramme" de classe

classe abstraite Lampe

Faire une classe Lampe qui:

• hérite de QObject
• a un attribut protected :
  • isAllumee : bool
• a des slots public :
  • allumer
  • eteindre
  • changer
• a une méthode protected
  • virtual void setValue(bool nouvelEtat)

Remarque :

• setValue est la seule méthode qui sera redéfinie dans les classes filles
• du coup il est nécessaire de la déclarer comme virtual
• les méthodes(slots plutôt) allumer/eteindre/changer doivent utiliser la méthode setValue

classe LampeGPIO

Ecrivez maintenant la classe LampeGPIO :

• elle hérite de Lampe
• le constructeur doit permettre d'indiquer le numéro de broche
• elle a un attribut protected
  • numGpio de type int

• elle doit redéfinir setValue
  • on ajoute le mot clé override dans la déclaration :
  • virtual void setValue(bool nouvelEtat) override
  • virtual n'est pas indispensable, il est utile si on souhaite spécialiser la classe LampeGPIO
  • dans la définition de la méthode, on pourra éventuellement appeler la méthode de la classe mère : Lampe::setValue(nouvelEtat)

Remarque :

• on utilise la librairie pigpio pour accéder aux gpio => ajouter au projet LIBS += -lpigpio
• penser à initialiser la librairie pigpio gpioInitialise
• il convient de définir la broche en sortie ( fonction gpioSetMode ) ... oui oui dans le constructeur !
• pour modifier la sortie, on utilisera la fonction gpioWrite

Peut-être le moment de tester un peu tout ça ??

classe LampeI2c

Et c'est parti pour la dernière classe LampeI2c :

• elle spécialise également la classe Lampe
• on ajoute des attributs
  • pinMCP : int le numéro du GPIO, par ex 2 si on utilise PA2
  • i2c de type QI2cDevice
    • ça va servir ... à utiliser le bus i2c c'est ça ;-)
    • chercher à la fin de l'énoncé, il doit y avoir les fichiers
    • sur les cartes raspberry-pi on utilise le bus I2C1
• il faut évidemment redéfinir setValue comme pour la classe LampeGPIO
  • dans la définition de la méthode, on pourra appeler la méthode de la classe mère : Lampe::setValue(etat)
• Le constructeur devra permettre d'indiquer :
  • le port i2c à utiliser ( I2C0 I2C1 I2C2 ...)
  • l'@ i2c du composant (valeur entre 0x20 et 0x27 suivant position des 3 switchs A0/A1/A2)
  • le numéro de gpio

Remarques :

• les registres du mcp23008

    enum regAd {IODIR = 0 ,
                IPOL = 1,
                GPINTEN = 2,
                DEFVAL = 3,
                INTCON = 4,
                IOCON = 5,
                GPPU = 6,
                INTF = 7,
                INTCAP = 8,
                GPIO = 9,
                OLAT = 10,
               };

• le numéro de gpio (ainsi que l'@ i2c du composant) ne changeant pas, on peut les déclarer comme constante à condition de procéder de la façon suivante (ex pour le numéro de gpio) :
  • déclaration : const int pinMCP;
  • définition :
    LampeI2c::LampeI2c( int _pinMCP, ...): Lampe{parent},pinMCP{_pinMCP} ....
• pour déclarer la broche en sortie:

    unsigned char value=i2c.readRegister(IODIR);
    value&=~(1<<pinMCP);
    i2c.writeRegister(IODIR,value);

• pour modifier la valeur de la sortie

    unsigned char value=i2c.readRegister(GPIO);
    if (isAllumee==false) value|= (1<<pinMCP);
    else                  value&=~(1<<pinMCP);
    i2c.writeRegister(GPIO,value);

Vérifier le fonctionnement de cette classe LampeI2c

Utilisation : polymorphisme

Au besoin vous pouvez utiliser les fichiers suivants pour continuer : Media:TdHeritage1.zip

Nous allons créer une classe Controleur qui pourra agir sur n'importe quel type de Lampe.

Un Controleur permet de faire clignoter une Lampe à l'aide d'un QTimer.

Comme le type de Lampe dépend du Controleur, nous allons devoir créer un objet de type Lampe(ou d'une classe fille !) à l'extérieur du Controleur

Le Controleur doit posséder un attribut pour ce voyant, il peut s'agir :

• d'une référence
• d'un pointeur

Par référence

L'utilisation de références permet d'éviter les erreurs de manipulation de pointeurs, mais peut être impossible dans certaines situations.

Le principe est le suivant :

class Controleur { Controleur(Lampe &l); Lampe & led; }	class Utilisation { // attention l'ordre est important, // on doit créer l'objet de type Lampe avant le Controleur LampeGPIO l1; Controleur c1; }
//on doit donner la référence //avant le début du code du constructeur Controleur::Controleur(Lampe &l) :led{l} { }	//exécution dans l'ordre des //constructeurs des attributs l1 et c1 //avec passage de la référence sur l1 Utilisation::Utilisation() :l1{10}, c1{l1} { }

Par pointeur

L'intérêt des pointeurs est de pouvoir créer des objets lorsque bon nous semble ... et aussi de faire n'importe quoi !

Voici une possibilité :

class Controleur { Controleur(Lampe * l); Lampe * led = nullptr; }	class Utilisation { // on ne peut pas créer le Controleur // avant d'avoir créer une Lampe // du coup on utilise également un pointeur Controleur * c1 = nullptr; }
Controleur::Controleur(Lampe * l) { // on pointe sur l'objet de type led dont on a passé l'adresse led = l; }	Utilisation::Utilisation() { // on crée un objet de type Lampe Lampe * l = new LampeGPIO(5); // on peut ensuite créer un controleur c1 = new Controleur(l); }

A vous de jouer

Vous pouvez écrire 2 classes Controleur différentes pour mettre en pratique ces 2 approches

Ressources

carte d'extension mcp23008

Les numéros sérigraphiés sous les boutons poussoirs indiquent les numéros de GPIO.

Les cavaliers JPxx permettent de positionner le GPIO en entrée ou en sortie.

Classe QI2cDevice

qi2cdevice.h #ifndef QI2CDEVICE_H #define QI2CDEVICE_H #include <QObject> enum I2C_BUS{ I2C0, I2C1, I2C2 }; class QI2cDevice : public QObject { Q_OBJECT public: explicit QI2cDevice(I2C_BUS bus, unsigned char device,QObject *parent = nullptr); virtual int writeRegister(unsigned int registerAddress, unsigned char value); virtual int write(unsigned char value); virtual unsigned char readRegister(unsigned int registerAddress); virtual bool readRegisters(unsigned char number, unsigned char data[] , unsigned char fromAddress = 0); private: virtual void open(); unsigned char bus; unsigned char device; unsigned char nbConnectionsErrors; int file = {-1}; signals: }; #endif // QI2CDEVICE_H

qi2cdevice.cpp #include "qi2cdevice.h" #include <string> #include<fcntl.h> #include<unistd.h> #include<sys/ioctl.h> #include<linux/i2c-dev.h> using namespace std; QI2cDevice::QI2cDevice(I2C_BUS bus, unsigned char device, QObject *parent) : QObject(parent),bus(bus),device(device) { open(); } void QI2cDevice::open() { string devname; if (bus==I2C_BUS::I2C0) devname = "/dev/i2c-0"; else if (bus==I2C_BUS::I2C1) devname = "/dev/i2c-1"; else if (bus==I2C_BUS::I2C2) devname = "/dev/i2c-2"; else throw runtime_error("undefined I2C port !"); // ouverture du périphérique i2c if((this->file=::open(devname.c_str(), O_RDWR)) < 0) { throw runtime_error("unable to open I2C dev file"); } // connection au composant if(ioctl(this->file, I2C_SLAVE, this->device) < 0) { ::close(this->file); this->file = -1; throw runtime_error("unable to open I2C port"); } } int QI2cDevice::writeRegister(unsigned int registerAddress, unsigned char value) { unsigned char buffer[2]; buffer[0] = registerAddress; buffer[1] = value; if(::write(this->file, buffer, 2)!=2){ perror("I2C: Failed write to the device\n"); return 1; } return 0; } int QI2cDevice::write(unsigned char value) { unsigned char buffer[1]; buffer[0]=value; if (::write(this->file, buffer, 1)!=1){ perror("I2C: Failed to write to the device\n"); return 1; } return 0; } unsigned char QI2cDevice::readRegister(unsigned int registerAddress) { this->write(registerAddress); unsigned char buffer[1]; if(::read(this->file, buffer, 1)!=1){ perror("I2C: Failed to read in the value.\n"); return 1; } return buffer[0]; } bool QI2cDevice::readRegisters(unsigned char number, unsigned char data[] , unsigned char fromAddress) { this->write(fromAddress); if(::read(this->file, data, number)!=(char)number){ perror("IC2: Failed to read in the full buffer.\n"); return false; } return true; }

Activer l'i2c sur les rpi

• installer les logiciels ic2detect/i2cset/i2cget
  • apt install i2c-tools
  • i2cdetect -y 1 (pour scanner les périphériques connectés sur le bus i2c1)
  • attention, débrancher la connexion i2c avec l'écran (fils vert et jaune : il ne doit y avoir que les 2 fils d'alimentation)
• activer l'i2c au démarrage
  • raspi-config
  • interfacing options
  • i2c