Bonjour,
 
Ce topic est étroitement lié à celui se trouvant dans la catégorie C puisqu'il vise à implémenter le même algorithme avec les même paramètres, mais avec Ada cette fois. Je suis un peu désolé de devoir ouvrir un topic alors que j'aurais a priori tout ce qu'il faut pour que ça fonctionne, mais non.
Vous trouverez le sujet avec C ici : [ Divers / C ] Ecrire pour un afficheur LCD
 
Pour réaliser ce projet avec Ada, j'ai d'abord implémenté les primitive d'entrée et sortie sur le port parallèle, lesquelles vous trouverez dans cet autre sujet : [Ada/Asm] Accéder au port parallèle avec Ada sur Gnu/Linux
 
J'ai ensuite suivi la procédure d'initialisation de mon afficheur LCD pour obtenir un simple curseur clignotant après avoir écrit quelque routines de base, comme le basculement des différents bits de contrôles.
Malheureusement, j'essuie un échec ; C'est pourquoi je viens vous demander votre avis, sur ce que j'ai fais.
 
Les routine sont de simple basculement de bit dans un unsigned_8 qu'il faut encore écrire sur le port parallèle.
 
exemple de routine : (ici Set_En)

function Set_En(Control : in Unsigned_8) return Unsigned_8 is
      New_Control : Unsigned_8 := 0;
   begin
      New_Control := Control and 16#FE#;
      return New_Control;
   end Set_En;

 
 
 
Et voici mon algo pour initialiser et afficher un curseur clignotant.
 

-- 
procedure LCD_Display(On : in Boolean; Cursor : in Boolean; Blink : in boolean) is
      Command : Unsigned_8 := 8;
      Control : Unsigned_8 := 0;
   begin
      Control := Clear_Rs(Control);
      Lp_Io.Put(Pp.Ctrl, Control);        -- valeur du registre de control = 16#C8#
      Lp_Io.Put(Pp.Data, 0);
      Control := Control and  16#D0#;
      Control := Control or 16#0B#;
 
      Lp_Io.Put(Pp.Ctrl, Control);        -- valeur du registre de control = 16#CB#
      Wait_Lcd;
      ----
       Control := Clear_Rs(Control);
       Lp_Io.Put(Pp.Ctrl, Control);
       Command := 16#38#;
       Lp_Io.Put(Pp.Data, Command);        -- valeur du registre de control = 16#CB#
       Control := Set_En(Control);
       Lp_Io.Put(Pp.Ctrl, Control);        -- valeur du registre de control = 16#CA#
       Wait_LCD;
       Control := Clear_En(Control);
       Lp_Io.Put(Pp.Ctrl, Control);        -- valeur du registre de control = 16#CB#
      ----
      Wait_Lcd;
      Control := Clear_Rs(Control);
      Lp_Io.Put(Pp.Ctrl, Control);        -- valeur du registre de control = 16#CB#
      
      Lp_Io.Put(Pp.Data, 16#0F#);
      Control := Set_En(Control);
      Lp_Io.Put(Pp.Ctrl, Control);        -- valeur du registre de control = 16#CA#
      Wait_LCD;
      Control := Clear_En(Control);
      Lp_Io.Put(Pp.Ctrl, Control);         -- valeur du registre de control = 16#CB#
 
      Lp_Io.Put(Pp.Data, 16#06#);
      Control := Set_En(Control);
      Lp_Io.Put(Pp.Ctrl, Control);        -- valeur du registre de control = 16#CA#
      Wait_LCD;
      Control := Clear_En(Control);
      Lp_Io.Put(Pp.Ctrl, Control);        -- valeur du registre de control = 16#CB#
 
 
   end LCD_Display;

Wait_LCD contient une temporisation de 0.0004 seconde.
 
 
A priori je devrais être bon, puisque je ne  fais que transcrire du C vers Ada. Mais bon, ça marche pas ; Au mieux ça efface ce qui est affiché couramment sur l'afficheur ; Et comme je ne sais pas quoi faire, voila, un appel au secours.
Merci pour votre aide.

J'ai écris la procédure pour écrire du texte. Ca marche sur un afficheur pré-initialisé. Mais je ne parviens toujours pas à initialiser.
J'ai testé avec l'envoi immédiat du registre de contrôle dans les routine telles que Set_En, ou Set_Rs, ça change rien à l'exécution. J'ai également testé la procédure qui consiste à envoyer 3 ou 4 fois 16#03# pour l'initialisation ; Marche pas non plus.
 

J'ai trouvé mon erreur.
J'avais mis 5 millième de seconde de délay entre chaque opération, ce qui fait beaucoup trop, puis qu'un opération doit s'effectuer en 500nano seconde. Et voilà. Je savais que c'était tout con, justement.

Je finalise le sujet avec un petit paquet : LcdParAda-0.0.0a.tar.gz
Comme mon afficheur est légèrement défectueux, j'ai implémenté une procédure de finalisation dont vous devez pouvoir vous passer.
Mon afficheur est un Xiamen Ocular GDM2004D.
J'ai implémenté les fonction suivantes : (j'ai pas tout testé)
 

--
   procedure LCD_Init;
   procedure LCD_WriteChar(Char : in Character);
   procedure LCD_Clear;
   procedure LCD_Home;
   procedure LCD_Mode(Size8 : in Boolean; Line2 : in Boolean; Bigfont : in Boolean);
   procedure LCD_EntryMode(Direction : in Boolean; Shift : in Boolean);
   procedure LCD_Display(On : in Boolean; Cursor : in Boolean; Blink : in boolean);

 
Ainsi que les sous routine nécessaire à leur fonctionnement.
Un grand merci à Gilou pour l'aide que tu m'as apporté dans le petit projet.  

Bonjour ou re- bonjour,  
 
J'ai écrit un petit bout de code C pour calculer l'usage CPU et j'ai mis en boucle l'affichage de celui-ci.
J'ai réduit le délais d'attente entre deux commandes à exactement 0.000_000_000_003 seconde.
Voici un paquet de sources pour Windows : LcdParAda_windows-0.0.0b.zip
 
Ce programme affiche l'usage CPU et le nom de machine local.
Un petit bout de C pour calculer l'usage CPU, le reste et écrit avec Ada, code dans lequel on charge inpout32 pour les accès au port parallèle.
 
Pour compiler, deux commande :
 

• gcc -c -o monitor.o src\lib\C\monitor.c pour obtenir le calculateur d'usage CPU
• gnatmake src\main -aIsrc\lib\Ada -largs monitor.o pour obtenir le main

J'oubliais, vous devez pouvoir vous passer de l'instruction "LCD_Finalize" dans le main. Et peut-être même sortir toutes ls commande d'initialisation de la boucle.