Afficheur (afficher un mot)

Nous allons maintenant nous intéresser au développement d'une application embarqué sur pcDuino afin de gérer l'afficheur AM-03127-LED. Nous avons déjà largement travaillé avec ce système, mais les programmes réalisés jusqu'à présent étaient sous forme structuré programmation fonctionnelle. L'objectif de ce TP est pour l'instant de proposer les mêmes fonctionnalités que précédemment mais avec une programmation plus modulaire en utilisant les objets. Le but est donc de mettre au point une nouvelle classe Afficheur qui s'occupe de la gestion de l'affichage de cet élément physique AM-03127-LED.

Afficheur (afficher plusieurs pages)

Continuons à nous intéresser au développement de l'application embarqué sur le pcDuino afin de gérer l'afficheur AM-03127-LED. Nous allons modifier la structure logicielle du projet précédent afin de permettre l'afiichage de plusieurs pages en même temps limitation de 5 pages sur 26 permises. Cette fois-ci, pour chaque message, nous pouvons choisir la couleur, le clignotement, le défilement ainsi que le temps d'affichage. Afin de permettre cet ensemble de fonctionnalités, l'idéal est de décomposer la gestion de l'affichage sur deux classes : la première, Afficheur qui gère la communication globale avec l'afficheur physique, la deuxième, Page qui comme son nom l'indique, s'occupe de la gestion de chaque message avec la couleur, le défilement, etc.

Diagramme de séquence - Ajouter une page

Entrées sorties sur pcDuino - GPIO

Dans ce chapitre nous allons nous consacrer à l'étude des entrées sorties digitales de la carte pcDuino. Dans cette première étape, notre intention sera de récupérer une impulsion provoquée par un bouton poussoir et d'activer une sortie de la carte afin qu'une led puisse s'éclairer. Vous voyez que notre démarche est très modeste. L'objectif est, comme les projets précédents, de créer une classe qui va encapsuler toute la démarche nécessaire pour que l'utilisation des entrées-sorties tout ou rien de la carte pcDuino soit extrêmement simple à utiliser. La mise en place sera ainsi intuitive et très rapide à expérimenter.

Caractéristiques des broches E/S numériques et analogiques du pcDuino

GPIO : 18 E/S en 3.3V.
Entrées Analogiques : 2 x 6 bits en 0-2V et 4 x 12 bits en 0-3.3V.
Sorties analogiques : 6 x PWM 2 broches « fast » en 520Hz – 8 bits et 4 broches « slow » en 5Hz – 20 niveaux.
Communication Sérielles : I2C, SPI, UART.

Nous retrouvons la plupart des possibilités de l'Arduino à quelques adaptation près.

Le brochage du pcDuino avec l'alimentation et les entrées analogiques

Le brochage des entrées-sorties tout-ou-rien

Fixer le sens d'une broche

Pour fixer le sens d'une broche, c'est simple : il suffit d'ouvrir le fichier et d'écrire la valeur voulue sachant :

0 la broche en entrée = INPUT
1 pour la broche en sortie = OUTPUT
8 pour la broche en entrée avec rappel si plus activé auto-maintien pour les boutons poussoirs.

Mise en oeuvre du codage

Dans un premier temps, vous pouvez réaliser des expériences afin de bien maîtriser cette notion de fichiers et de flot. Une fois que vous aurez compris tous les mécanisme en jeu, vous pouvez coder votre classe GPIO et respecter l'algorithme prévu pour élaborer votre projet.

gpio.pro

TEMPLATE = app
CONFIG += console c++11
CONFIG -= app_bundle qt

SOURCES += main.cpp gpio.cpp
HEADERS += gpio.h

target.path = /home/ubuntu/Public
INSTALLS += target

gpio.h

#ifndef GPIO_H
#define GPIO_H

#include <fstream>
using namespace std;

enum MODE {Entree, Sortie};

class GPIO
{
  fstream broche;
  const MODE mode;
public:
  GPIO(MODE m, unsigned numero);
  ~GPIO();
  bool etat();
  void activer(bool action);
};

#endif // GPIO_H

gpio.cpp

#include "gpio.h"

GPIO::GPIO(MODE m, unsigned numero) : mode(m)
{
  string localisation = "/sys/devices/virtual/misc/gpio/mode/gpio";
  localisation += '0' + numero;
  ofstream modeGPIO(localisation.c_str());
  modeGPIO << (mode==Sortie ? '1' : '0');
  modeGPIO.close();
  localisation = "/sys/devices/virtual/misc/gpio/pin/gpio";
  localisation += '0' + numero;
  broche.open(localisation.c_str());
}

GPIO::~GPIO()
{
  if (mode==Sortie) broche << '0';
  broche.close();
}

void GPIO::activer(bool action)
{
  if (mode==Sortie) {
    broche << (action ? '1' : '0');
    broche.flush();
  }
}

bool GPIO::etat()
{
  broche.seekg(0);
  return broche.peek()=='1';
}

main.cpp

#include <iostream>
#include <unistd.h>
using namespace std;

#include "gpio.h"

int main()
{
  GPIO bouton(Entree, 6);
  GPIO led(Sortie, 3);
  led.activer(true);
  while (!bouton.etat()) usleep(100000);
  return 0;
}

Conclusion sur la programmation orientée objet

Dans le fichier principal, vous remarquez que cette classe GPIO est très très simple à utiliser. Il suffit de déclarer les objets relatifs avec des noms évocateurs comme bouton et led. Toutes les phases délicates se situent dans le constructeur et le destructeur, mais ces deux méthodes particulières ne se voient pas puisqu'elles sont appelées implicitement. Du coup le code correspondant à l'algorithme de fonctionnement est très très court et rapide à construire. Je me répète, mais la programmation modulaire comme l'est la programmation orientée objet nous donne à la fois une conception intuitive et très rapide à mettre en oeuvre. Cela facilite le développement d'applications.