J’ai commencé à me coder une librairie Java afin de manipuler les GPIO et des modules externes (écrans, capteurs ...) sur un RaspberryPi directement en Java sans avoir besoin de librairie externe. Il faut juste Java et les droits nécessaires pour manipuler les GPIO si nécessaire.

L’envie de me faire ma propre librairie pour mes réalisations est venue du fait que certaines librairies sur le net n’était plus maintenus et disparaissait lors d’une mise à jour pour diverses raisons (devenu trop complexe à maintenir, plus utilisé, composants obsolètes, …).
C’est pas tellement pratique quand on a des RaspberryPi qui tournent 24h/24 depuis quelques années avec des composants électroniques autour et qui, subitement, ont des scripts qui bug jusque parce qu’on a fait la petite mise à jour habituelle et le RaspberryPi ne peux plus communiquer avec les composants.
Rechercher les anciennes librairies dans les dépôts d’archives est une chose mais je ne pense pas que ce soit la meilleure solution.
Me coder quelque chose de façon viable dans le temps, donc qui doit pouvoir fonctionner entre 5 et 10 ans minimum dans trop de difficultés, est le but.

Pour cette première version, j’ai commencé avec des trucs simples : pouvoir manipuler les GPIO et manipuler des afficheurs texte LCD classiques. De quoi me permettre de faire déjà pas mal de choses.

Pour les GPIO, la librairie lit et écrit directement dans les fichiers situés dans "/sys/class/gpio". Ce n’est pas le plus performant mais le plus simple. Pas de librairie externe, on lit et on écrit dans des fichiers, point.
Un objet "GPIOTools", une fois instancié, permet l’initialisation, la lecture et l’écriture sur les GPIO.

Code:1.
2.
3.
4.
5.
6.
7.
8.
9.

GPIOTools gpioTools = new GPIOTools();
gpioTools.init(RasPiPin.GPIO12, GPIODirection.out);
gpioTools.init(RasPiPin.GPIO16, GPIODirection.in);
           
gpioTools.setValue(RasPiPin.GPIO12, true);
boolean value = gpioTools.getValueBoolean(RasPiPin.GPIO16);
           
gpioTools.closeGPIO(RasPiPin.GPIO12);
gpioTools.closeGPIO(RasPiPin.GPIO16);

Les énumérations "RasPiPin" et "GPIODirection" définissent quels GPIO utiliser et dans quel sens (lecture ou écriture).
Les méthodes publiques disponibles sont :
- boolean init(RasPiPin pin, GPIODirection direction)
- boolean init(RasPiPin pin, GPIODirection direction, boolean value)
- boolean init(RasPiPin pin, GPIODirection direction, boolean activeLow, boolean value)
- void setDirection(RasPiPin pin, GPIODirection direction)
- void setActiveLow(RasPiPin pin, boolean activeLow)
- void setValue(RasPiPin pin, boolean value)
- boolean getValueBoolean(RasPiPin pin)
- int getValueInteger(RasPiPin pin)
- void closeGPIO(RasPiPin pin)
Toutes les méthodes peuvent retourner une exception "GPIOException" en cas d’erreur.
Voilà quelque chose de basique mais qui fait le taff pour la grande majorité des cas.

Cette première version de la librairie permet également de gérer les afficheurs LCD texte classiques très connus dans le monde de l’électronique basés sur le composant HD44780. Il en existe de plusieurs tailles mais tous ont pratiquement la même façon d’être manipulés.



L’objet "GenericTextDisplay" permet d’initialiser et de communiquer avec n’importe quel afficheur ayant entre 1 et 4 lignes et 1 et 20 colonnes.

Code:1.


2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

GenericTextDisplay genericTextDisplay = new GenericTextDisplay(4, 20, pinRegisterSelect, 
pinReadWrite, pinEnable, pinData0, pinData1, pinData2, pinData3, pinData4, pinData5, pinData6, 
pinData7, true);

genericTextDisplay.locate(0, 2);
genericTextDisplay.print("LCD Display 20x4");

genericTextDisplay.locate(1, 2);
genericTextDisplay.print("jRaspiTools v0.1");

genericTextDisplay.locate(2, 4);
genericTextDisplay.print("-= Jelora =-");

genericTextDisplay.locate(3, 0);
genericTextDisplay.print("http://www.jelora.fr");

La communication peut être faite en 8 bits ou 4 bits, cela dépendra du nombre de RasPiPin fournis dans le constructeur. La gestion de l’envoi des informations sous forme 8 bits ou 4 bits est gérée automatiquement.
Les méthodes publiques suivantes sont disponibles :
- GenericTextDisplay(int lines, int cols, RasPiPin pinRegisterSelect, RasPiPin pinReadWrite, RasPiPin pinEnable, RasPiPin pinData0, RasPiPin pinData1, RasPiPin pinData2, RasPiPin pinData3, RasPiPin pinData4, RasPiPin pinData5, RasPiPin pinData6, RasPiPin pinData7, boolean ignoreIfBusy)
- GenericTextDisplay(int lines, int cols, RasPiPin pinRegisterSelect, RasPiPin pinReadWrite, RasPiPin pinEnable,RasPiPin pinData0, RasPiPin pinData1, RasPiPin pinData2, RasPiPin pinData3, RasPiPin pinData4, RasPiPin pinData5, RasPiPin pinData6, RasPiPin pinData7)
- GenericTextDisplay(int lines, int cols, RasPiPin pinRegisterSelect, RasPiPin pinReadWrite, RasPiPin pinEnable, RasPiPin pinData4, RasPiPin pinData5, RasPiPin pinData6, RasPiPin pinData7, boolean ignoreIfBusy)
- GenericTextDisplay(int lines, int cols, RasPiPin pinRegisterSelect, RasPiPin pinReadWrite, RasPiPin pinEnable, RasPiPin pinData4, RasPiPin pinData5, RasPiPin pinData6, RasPiPin pinData7)
- boolean checkBusyFlag()
- void sendInstruction(byte code)
- void sendData(byte code)
- void clearDisplay()
- void displayControl(boolean displayOnOff, boolean cursorPositionOnOff, boolean cursorBlinkingOnOff)
- void displayControlDisplay(boolean displayOnOff)
- void displayControlCursorPosition(boolean cursorPositionOnOff)
- void displayControlCursorBlinking(boolean cursorBlinkingOnOff)
- void functionSet(DisplayDataBusMode displayDataBusMode, boolean numberDisplayedLines, boolean characterFont)
- void entryModeSet(boolean direction, boolean accompaniesDisplayShift)
- void setDDRAMAddress(byte address)
- void print(String text)
- void locate(int line, int column)
Toutes les méthodes peuvent retourner une exception "DisplayException" en cas d’erreur.
Lors d’un traitement d’une instruction ou de l’envoi d’une donnée, celle ci peut prendre un certain temps pour être exécuté par l’afficheur. C’est pour cela que la librairie peut attendre que l’écran ait terminé après chaque envoi d’instruction ou de données en vérifiant le BusyFlag. Mais cela est plus chronophage car on envoie une instruction supplémentaire à chaque fois. Il est donc possible d’ignorer cette attente et mettant "ignoreIfBusy" à "true" à l’instanciation mais c’est aux risques et périls. Si une information est envoyée alors que l’écran n’a pas finit de traiter la précédente, l’information est ignorée.
Lors de l’instanciation de l’objet "GenericTextDisplay", l’écran est initialisé avec une configuration basique pour être déjà fonctionnel et qui pourra être modifié par la suite.

Code:1.
2.
3.

functionSet(displayDataBusMode, true, false);
displayControl(true, false, false);
entryModeSet(true, false);

Quelques explications sur les méthodes disponibles :
- checkBusyFlag va récupérer le BusyFlag et le retourner sous forme de boolean.
- Pour exécuter des taches, l’écran dispose de 2 registres, le registre instruction et le registre données. Ces registres peuvent être alimentés avec les méthodes sendInstruction et sendData.
- clearDisplay efface l’écran et replace le curseur à première position.
- displayControl permet définir les paramètres d’affichage : affichage de l’écran, la position du curseur (tiret bas fixe), le curseur clignotant (rectangle noir qui clignote). Les méthodes displayControlDisplay, displayControlCursorPosition et displayControlCursorBlinking reprennent chaque paramètre de façon indépendante.
- functionSet définit les paramètres fonctionnels de l’afficheur avec la taille du bus de communication avec l’énumération "DisplayDataBusMode", le mode de gestion des lignes (false 1 ligne, true 2 lignes) et le type de caractères. Suivant le nombre de lignes affichés par l’écran, il faut utiliser le mode 2 lignes ou non. Mais sur les 4 lignes, comment on fait ? Pour les afficheurs 1 ou 2 lignes, c’est le mode 1 ligne et pour les afficheurs 4 lignes, c’est le mode 2 lignes. Une ligne affichée est une suite d'octets en mémoire. Le mode 1 ou 2 lignes va modifier la façon qu'a l'écran de gérer cette mémoire. Pour aller d’une ligne à l’autre, il suffit de se déplacer dans la DDRAM à un endroit spécifique.
- entryModeSet permet de définir la direction du curseur.
- setDDRAMAddress permet de déplacer le curseur d’un emplacement mémoire à un autre. Chaque ligne commence avec une adresse précise :
-  print envoi du texte et l’affiche sur l’écran.
-  locate change la positon du curseur comme setDDRAMAddress mais avec le numéro de ligne (0 à 3) et le numéro de colonne.

Pour plus d'information, voici la documentation du HD44780.

L’écran été testé avec le simple circuit suivant :



Télécharger : jRaspiTools-0.1.jar / jRasPiTools-0.1-source.zip

Voilà. Cette petite librairie n’a rien d’extraordinaire et n’a pas pour but de dominer toutes les autres.
J’ai fait un truc. Je suis content. Si ça plaît aux autres, c’est cool.