bonjour,
je bricole un peu l'électronique et l'informatique, je me suis mis depuis peu à la prog mais quand j'ai vu un prog écris en C,  je me suis dit trop compliqué pour moi, alors j'ai regardé le language ADA et j'ai trouvé cela plus parlant,  je fais des fonctions sympas, mais je rencontre un problème avec les tableaux, j'aimerai un petit coup de pouce pour faire marcher mon prog..
Ou plustôt, j'aimerais que l'on m'indique ou je dois aller pour trouver les infos qu'il me manque. merci.

ha ! je vois ! Personne pour me donner un coup de pouce, bon je vais vous en dire plus, voilà, j'ai bricolé une petite carte qui fait une mesure de courant aux bornes d'un dipole et qui me renvoie par le port rs232 la tention et le courant mesuré. mais voilà souhaite traiter ses deux infos ensemble pour pouvoir connaître la puissance utilisée aux bornes de ce dipole. j'ai choisis arbitrairement des valeurs de tensions qui vont de 0 à 220v donc si je veux avoir un traitement sur 8 bits, il me faut  une fourchette de 0 à 255 bits. mais voilà en C on trouve tout ce que l'on veut sauf que je ne connais pas le C . J'ai fais une fonction pour essayer de commencer par un coté du problème
qui décompose en mots logiques de 8 bits une valeur numérique, ça a l'air de marcher mais je n'ai pas assez d'infos sur l'affichage de tableaux binaires et la manipulation de données binaires dans les tableaux

explique concretement ce que tu veux faire (en Ada)
mets tes declarations de variables
postes les bouts de code qui te posent probleme

Ha, super, il semble que j'ai eu des pbs avec mon précedent compte mais c'est bien moi.
 
 
 
Bonjour blacksad988,
 
Merci pour la réponse, je vais enfin pouvoir avancer dans ce petit problème, Le but pour le moment est la réalisation d'une application qui reçoit deux valeurs digitales sous forme de mots 8 bits et qui nous affiche ces deux valeurs et pour commencer mon prog par un bout, j'ai écider de prendre le problème dans ce sens, l'évolution du programe sera la saisie de deux valeurs ex : un U := 130V et un I := 15 A,au final je veux afficher la puissance apparente du montage ensuite le but est de tranmètre au montage deux autres valeurs par le biais de deux mots de 8 bits.
c'est vrai que mon code est écris un peu bizard, mais j'écris depuis peu, j'ai commencé par faire un organigrame sur un bout de papier, "façon de parler", recencer mes variables et traduire tout celà en Ada.
Certes c'est peu être pas la bonne solution mais il faut apprendre alors...
Il faut écrire des progs qui tournent.
J'ai débuter mon code par traiter le cas des Intégers, car il me faudra des floats en affichage plus tard.
Mon code débute ainsi :
with Text_Io;
use Text_Io;
with Ada.Integer_Text_Io;
use Ada.Integer_Text_Io;
with Ada.Float_Text_Io; -- Plus tard
use Ada.Float_Text_Io;  -- Plus tard
procedure Convert_Bit is  
   subtype num is Integer range 0..255;
   nb : num;  
   subtype Bit is Integer range 0..1;
   Bit1 : Bit := 0;  
   Bit2 : Bit := 0;  
   Bit3 : Bit := 0;  
   Bit4 : Bit := 0;  
   Bit5 : Bit := 0;  
   Bit6 : Bit := 0;  
   Bit7 : Bit := 0;  
   Bit8 : Bit := 0;  
   type Tab_Bit is array (Integer range 0 .. 7) of Bit;  
   T1          : Tab_Bit ;  
   T2          : Tab_Bit ;  
   T3          : Tab_Bit ;  
   T3_Temp     : Tab_Bit ;
--   T1 := (Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);  
--   T2 := (Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);
--   T3 := (Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);  
--   T3_Temp := (Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);  
 
Je ne sais pas si il est bien de tout énumérer,  
voila il y a peut être de choses !!!?
 
une fonction qui convertit mon num en tableau de bits :
 
function Convert ( nb  : Integer )  
     return Tab_Bit is
    T : Tab_Bit;
    Nb : integer;
   begin
      I := 0;  
      Nb := nb;
      while Nb /= 0 loop
  T1(I) := Nb mod 2;
           Nb := Nb / 2;
        I := I + 1;
       end loop;
       return T(I);
      End with;
end Convert;
 
Je pense que c'est ça,
la logique n'a pas été trop dificile mais c'est la syntaxe que je ne maitrise pas...
 
Voilà une fonction qui fait l'adition des deux tabs dans une autre, alors la j'ai des questions...
 
Surtout que se pose la des pbs de syntaxe que je ne connais pas encore.
J'ai mis des points pour dire que bit8 appartient à T1 donc j'ai mis T1.bit8 en Ada c'est pas ça ?
la Logique doit être bonne sauf que je ne sais sur une variable que faire
T3.Bit1 :=1.
 
function Add_Tab_Bit (
         Tab1,          
         Tab2 : Tab_Bit )  
     return Tab_Bit is  
      Add_Tab : Add_Tab_Bit;  
   begin
      if T1.Bit8 := 1 and T2.Bit8 := 1 then
         T3.Bit8 := 0;
         T3_Temp.Bit7 := 1;
      elsif
         T1.Bit8 := 0 and T2.Bit8 := 0 then
         T3.Bit8 := 0;
         else
            T3.Bit8 := 1;
         end if;
      end if; -- il semblerait possible de traiter ces blocs par un moyen du genre T1.Bit."Previous" celà devrait être possible il me semble
   if T1.Bit7 := 1 and T2.Bit7 := 1 and T3_Temp.Bit7 := 1 then
      T3.Bit7 := 1;
      T3_Temp.Bit6 := 1;
   elsif
      T1.Bit7 := 1 and T2.Bit7 := 1 and T3_Temp.Bit7 := 0 then
      T3.Bit7 := 0;
      T3_Temp.Bit6 := 1;
   elsif
      T1.Bit7 := 0 and T2.Bit7 := 0 and T3_Temp.Bit7 := 1 then
      T3.Bit7 := 1;
   elsif
      T1.Bit7 := 0 and T2.Bit7 := 0 and T3_Temp.Bit7 := 0 then
      T3.Bit7 := 0;
      else
         T3.Bit7 := 1;
   end if;
   if T1.Bit6 := 1 and T2.Bit6 := 1 and T3_Temp.Bit6 := 1 then
     T3.Bit6 := 1;
     T3_Temp.Bit5 := 1;
   elsif
      T1.Bit6 := 1 and T2.Bit6 := 1 and T3_Temp.Bit6 := 0 then
      T3.Bit6 := 0;
      T3_Temp.Bit5 := 1;
   elsif
      T1.Bit6 := 0 and T2.Bit6 := 0 and T3_Temp.Bit6 := 1 then
      T3.Bit6 := 1;
   elsif
      T1.Bit6 := 0 and T2.Bit6 := 0 and T3_Temp.Bit6 := 0 then
      T3.Bit6 := 0;
      else
         T3.Bit6 := 1;
   end if;
   if T1.Bit5 := 1 and T2.Bit5 := 1 and T3_Temp.Bit5 := 1 then
      T3.Bit5 := 1;
      T3_Temp.Bit4 := 1;
   elsif
      T1.Bit5 := 1 and T2.Bit5 := 1 and T3_Temp.Bit5 := 0 then
      T3.Bit5 := 0;
      T3_Temp.Bit4 := 1;
   elsif
      T1.Bit5 := 0 and T2.Bit5 := 0 and T3_Temp.Bit5 := 1 then
      T3.Bit5 := 1;
   elsif
      T1.Bit5 := 0 and T2.Bit5 := 0 and T3_Temp.Bit5 := 0 then
      T3.Bit5 := 0;
      else
         T3.Bit5 := 1;
   end if;
   if T1.Bit4 := 1 and T2.Bit4 := 1 and T3_Temp.Bit4 := 1 then
      T3.Bit4 := 1;
      T3_Temp.Bit3 := 1;
   elsif
      T1.Bit4 := 1 and T2.Bit4 := 1 and T3_Temp.Bit4 := 0 then
      T3.Bit4 := 0;
      T3_Temp.Bit3 := 1;
   elsif
      T1.Bit4 := 0 and T2.Bit4 := 0 and T3_Temp.Bit4 := 1 then
      T3.Bit4 := 1;
   elsif
      T1.Bit4 := 0 and T2.Bit4 := 0 and T3_Temp.Bit4 := 0 then
      T3.Bit4 := 0;
      else
         T3.Bit4 := 1;
   end if;
   if T1.Bit3 := 1 and T2.Bit3 := 1 and T3_Temp.Bit3 := 1 then
      T3.Bit3 := 1;
      T3_Temp.Bit2 := 1;
   elsif
      T1.Bit3 := 1 and T2.Bit3 := 1 and T3_Temp.Bit3 := 0 then
      T3.Bit3 := 0;
      T3_Temp.Bit2 := 1;
   elsif
      T1.Bit3 := 0 and T2.Bit3 := 0 and T3_Temp.Bit3 := 1 then
      T3.Bit3 := 1;
   elsif
      T1.Bit3 := 0 and T2.Bit3 := 0 and T3_Temp.Bit3 := 0 then
      T3.Bit3 := 0;
      else
         T3.Bit3 := 1;
   end if;
   if T1.Bit2 := 1 and T2.Bit2 := 1 and T3_Temp.Bit2 := 1 then
      T3.Bit2 := 1;
      T3_Temp.Bit1 := 1;
   elsif
      T1.Bit2 := 1 and T2.Bit2 := 1 and T3_Temp.Bit2 := 0 then
      T3.Bit2 := 0;
      T3_Temp.Bit1 := 1;
   elsif
      T1.Bit2 := 0 and T2.Bit2:= 0 and T3_Temp.Bit2 := 1 then
      T3.Bit2 := 1;
   elsif
      T1.Bit2 := 0 and T2.Bit2 := 0 and T3_Temp.Bit2 := 0 then
      T3.Bit2 := 0;
      else
         T3.Bit2 := 1;
   end if;
   if T1.Bit1 := 1 and T2.Bit1 := 1 and T3_Temp.Bit1 := 1 then
      T3.Bit1 := 1;
      T3_Temp.Bit1 := 1;
   elsif
      T1.Bit1 := 1 and T2.Bit1 := 1 and T3_Temp.Bit1 := 0 then
      T3.Bit6 := 0;
      T3_Temp.Bit1 := 1;
   elsif
      T1.Bit1 := 0 and T2.Bit1 := 0 and T3_Temp.Bit1 := 1 then
      T3.Bit1 := 1;
   elsif
      T1.Bit1 := 0 and T2.Bit1 := 0 and T3_Temp.Bit1 := 0 then
      T3.Bit1 := 0;
      else
         T3.Bit1 := 1;
   end if;
   return T3(Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);
   end Add_Tab_Bit;
 
En effet c'est le cas du dépassement de pile,  T3_Temp.Bit1 := 1; mon prog devrait utiliser cette donnée.
 
j'ai fais aussi une fonction qui me retourne un entier à partir d'un enregistrement de mes tableaux
 
Maintenant avec la logique ça donne ça ...
 
function Bit_vers_num (
      T1,                
      T2,                
      T3,                
      T3_Temp : Tab_Bits )
      return num Is
      B_num1 : num;
      B_num2 : num; -- ne peut on faire un objet unique qui travaille suivant les trois cas ?
      B_num3 : num;
   Begin
      If T1(Bit1) := 1 Then   -- l'écriture de tous les T(bit) on depuis été réécris en T.Bit n , je pense que ça doit être ça ???
         B_num1 := 128;
      ElsIf T1(Bit2) := 1 Then
         B_num1 := B_num1 + 64;
      ElsIf T1(Bit3) := 1 Then
         B_num1 := B_num1 + 32;
      ElsIf T1(Bit4) := 1 Then
         B_num1 := B_num1 + 16;
      ElsIf T1(Bit5) := 1 Then
         B_num1 := B_num1 + 08;
      ElsIf T1(Bit6) := 1 Then
         B_num1 := B_num1 + 04;
      ElsIf T1(Bit7) := 1 Then
         B_num1 := B_num1 + 02;
      ElsIf T1(Bit8) := 1 Then
         B_num1 := B_num1 + 01;
      End If;
      If T2(Bit1) := 1 Then
         B_num2 := 128;
      ElsIf T2(Bit2) := 1 Then
         B_num2 := B_num2 + 64;
      ElsIf T2(Bit3) := 1 Then
        B_num2 := B_num2 + 32;
      ElsIf T2(Bit4) := 1 Then
         B_num2 := B_num2 + 16;
      ElsIf T2(Bit5) := 1 Then
      B_num2 := B_num2 + 08;
      ElsIf T2(Bit6) := 1 Then
      B_num2 := B_num2 + 04;
      ElsIf T2(Bit7) := 1 Then
      B_num2 := B_num2 + 02;
      ElsIf T2(Bit8) := 1 Then
      B_num2 := B_num2 + 01;
      End If;
If T3(Bit1) := 1 Then
         B_num3 := 128;
      ElsIf T3(Bit2) := 1 Then
         B_num3 := B_num3 + 64;
      ElsIf T3(Bit3) := 1 Then
         B_num3 := B_num3 + 32;
      ElsIf T3(Bit4) := 1 Then
         B_num3 := B_num3 + 16;
      ElsIf T3(Bit5) := 1 Then
         B_num3 := B_num3 + 08;
      ElsIf T3(Bit6) := 1 Then
         B_num3 := B_num3 + 04;
      ElsIf T3(Bit7) := 1 Then
         B_num3 := B_num3 + 02;
      ElsIf T3(Bit8) := 1 Then
         B_num3 := B_num3 + 01;
      End If;
      Return B_num1 , B_num2 , B_num3;
   End Bit_vers_num;
 et un début de programme, pas fini encore mais je pense que tout n'est pas fini, il y a des fautes dans tous les sens si ça se trouve.
 
I : Integer;  
   J   : Integer;
   Nb1 : Integer;
   Nb2 : Integer;
   begin
   Put ("Entrez U (Volts) : " );
   Get (Nb1);
   num := (Nb1);
   if num < 0 then
      Put ("Défaut nombre négatif: essayez encore une fois" );
      exit;
   else
      do
      (Convert ( num ));
      for I in Integer range '0' .. '7' loop
      Put (Tab1(I));
   end if;
      New_Line;
      Put ("Entrez I (Ampères) : " );
      Get (Nb2);
      num := (Nb2);
      if num < 0 then
         Put ("Défaut nombre négatif: essayez encore une fois" );
         exit;
      else
         do
         Convert ( num );
         for J := 0 .. 7 loop
            Put (Tab2 (I));
         end if;
      end Convert_Bit;
 
maintenant je dois faire évoluer ce code vers la saisie de mots de 8 bits
et enregistrer ces mots dans Tab 1 et 2.
Voilà, ha! j'oubliais, je vais faire un bout de code pour la puissance là pour commencer je vais faire ma multiplication en bas, après on fera une fonction.
mais j'écris comme un cochon, d'autres dirons " le cours" mais oui ...
j'ai pas trouvé...
pas bien cherché non plus...
 
Merci pour tes conseils,

 
à premiere vue, tu programmes "LARGE".
pas trop le temps de regarder ce matin, mais j'essaye de te repondre cet AM ou ce soir.  
 
mais à premiere vue, tu utilises beaucoup trop le copier/coller, tu devrais facilement pouvoir reformater ton prog en quelques lignes
 
j'essaye de t'aider le plus tôt possible...

Merci à toi, si tu peux me signaler mes erreurs exemple erreur sur les problèmes de type ou de passage de param.
Merci beaucoup, je suis en train d'écrire la suite...
A bientôt...

deja rapidement:
je crois que tu t'emmeles un peu les pinceaux avec tes bit1,bit2,... et ton utilisation de T1, T2,...
 
 
T1 est de type Tab_bit
Tab_bit est un type defini par "array (Integer range 0 .. 7) of Bit" c.a.d. un tableau indexé de 0 à 7 d'elements de type bit
Bit est un entier appartenant à [0;1] (donc 0 ou 1)
 
l'utilisation de T1 sera donc:
 
T1(x):=  ...
avec x appartenant à [0..7]
 
si je reprend qques lignes de ton programme:
"function Add_Tab_Bit (  
         Tab1,            
         Tab2 : Tab_Bit )  
     return Tab_Bit is  
      Add_Tab : Add_Tab_Bit;    
   begin  
      if T1.Bit8 := 1 and T2.Bit8 := 1 then ..."
 
ca ne vas pas
Deja en parametre tu passes Tab1 et Tab2 --> du coup dans ta fonction, tu utiliseras Tab1 au lieu de T1
De plus tu utilisera Tab1(7) au lieu de T1.bit8
 

Bon, quelques indications: (tu as peut etre des raisons de coder comme ça, alors c'est à prendre avec des pincettes)
 
procedure Convert_Bit is  
   subtype num is Integer range 0..255;
   nb : num;  
   subtype Bit is Integer range 0..1;
   Bit1 : Bit := 0;  
   Bit2 : Bit := 0;  
   Bit3 : Bit := 0;  
   Bit4 : Bit := 0;  
   Bit5 : Bit := 0;  
   Bit6 : Bit := 0;  
   Bit7 : Bit := 0;  
   Bit8 : Bit := 0;  
 
8 variables? pourquoi autant? d'autant plus que tu utilises un tableau derriere...
Soit tu as besoins de 8 variables pour cause d'interface circuit-ordinateur, et là ok! sinon contentes toi d'utiliser des tableaux comme ceux que tu declares aprés (T1: Tab_bit remplace largement bit1,bit2,...  avec T1(0)=Bit1,...)
 
 
   type Tab_Bit is array (Integer range 0 .. 7) of Bit;  
   T1          : Tab_Bit ;  
   T2          : Tab_Bit ;  
   T3          : Tab_Bit ;  
   T3_Temp     : Tab_Bit ;
--   T1 := (Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);  
--   T2 := (Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);
--   T3 := (Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);  
--   T3_Temp := (Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7, Bit8);  
 
je suppose que ta remarque correspond à une initialisation de ton tableau
 
une fonction qui convertit mon num en tableau de bits :
 
function Convert ( nb  : Integer )  
     return Tab_Bit is
    T : Tab_Bit;
    Nb-->nb_dec : integer; n'utilises pas de variables avec des noms identique à ceux entrée en parametre
   begin
      I := 0;  
      Nb_dec := nb;
      while Nb /= 0 loop
  T1(I) := Nb mod 2;
           Nb := Nb / 2;
        I := I + 1;
       end loop;
       return T(I);
      End with;
end Convert;
 
 
Surtout que se pose la des pbs de syntaxe que je ne connais pas encore.
J'ai mis des points pour dire que bit8 appartient à T1 donc j'ai mis T1.bit8 en Ada c'est pas ça ? -->T1(7)
la Logique doit être bonne sauf que je ne sais sur une variable que faire
T3.Bit1 :=1. -->  T3(0):=1;
 
function Add_Tab_Bit (
         Tab1,          
         Tab2 : Tab_Bit ) --tu nomme les parametres d'entrée Tab1 et Tab2
     return Tab_Bit is  
      Add_Tab : Add_Tab_Bit;  -->??? non,  add_tab: Tab_bit
   begin
      if T1.Bit8 := 1 and T2.Bit8 := 1 then
         T3.Bit8 := 0;
         T3_Temp.Bit7 := 1;
      elsif
         T1.Bit8 := 0 and T2.Bit8 := 0 then
         T3.Bit8 := 0;
         else
            T3.Bit8 := 1;
         end if;
      end if; -- il semblerait possible de traiter ces blocs par un moyen du genre T1.Bit."Previous" celà devrait être possible il me semble
   ...   end Add_Tab_Bit;
 

      pfiou, en utilisant une variable "retenue" et Tab1(i), Tab2(i), une petite boucle "For" ca dois pouvoir tenir en quelques lignes (regardes ta conversion decimal-binaire)
 
verdict: assurement à refaire  
 
En effet c'est le cas du dépassement de pile,  T3_Temp.Bit1 := 1; mon prog devrait utiliser cette donnée.
 
j'ai fais aussi une fonction qui me retourne un entier à partir d'un enregistrement de mes tableaux
 
Maintenant avec la logique ça donne ça ...
 
function Bit_vers_num (
    ...
   End Bit_vers_num;
 
 
   tu est sur que tu veux faire un programme? tu pourrais faire les calculs à la main, ca irai plus vite    
 
serieusement, pareil qu'au dessus
 
essayes un truc du style:
function puis_deux(n:integer) return integer is
nb:integer:=1;
begin
 for i:=1..n loop    
   nb:=nb*2;
 end loop;
return nb;
end pui_deux    
 
-- puis...
-- la conversion de T1 (ton binaire) à nb (ton decimal) se resoud par :
 
for i:=0..7 loop
nb:nb+T1(i)*puis_deux(i);
end loop;
 
(c'est à verifier, nottament au niveau de la correspondance indice- numero de bit)
 
 
 
et un début de programme, pas fini encore mais je pense que tout n'est pas fini, il y a des fautes dans tous les sens si ça se trouve.
 
I : Integer;  
   J   : Integer;
   Nb1 : Integer;
   Nb2 : Integer;
   begin
   Put ("Entrez U (Volts) : " );
   Get (Nb1);
   num := (Nb1);
   if num < 0 then
      Put ("Défaut nombre négatif: essayez encore une fois" );
      exit; -->   essayes un "repeat until"
   else
      do
      (Convert ( num )); --> convert est une fonction, donc tu dois l'utiliser comme telle, avec par ex: T1:=convert(num);
   
...
 
maintenant je dois faire évoluer ce code vers la saisie de mots de 8 bits
et enregistrer ces mots dans Tab 1 et 2. je ne me souviens plus de la syntaxe, mais ca dois pouvoir se faire en 3 lignes. Grosso modo, tu saisie une chaine de caracteres de taille 8, puis, via l'attribus 'value tu pourras faire
 
for i:=0..7 loop
T1(i):=integer'value(chaine_saisie(i+1));
end loop;
 
(la syntaxe c'est peut etre pas ça, il faut que rejette un coup d'oeil sur mes vieux cours )
 
 
 
 
 
[/citation]
 
quelques remarques generales:
- pour eviter de t'embrouiller avec les indices et les numeros de bit, tu devrais harmoniser des indices de tableau avec tes numeros (type tab_bit: array(1..8)... au lieu de (0..7)).  
- de la meme maniere fixes toi un ordre pour ton tableau (je crois que tu consideres que tab(0) est le bit de poids faible) --> attention lors de l'affichage à inverser
- tu utilises mal les fonctions ( par exemple, pour utiliser la fonction convert tu dois faire tab1:=convert(num) avec tab1 de type tab_bit et num de type integer)
- si ton algoritme necessite 50 "if" successifs c'est forcement que tu es passé à coté d'une enorme simplification
- je n'ai pas encore regarder la fin de ton prog, mais peut etre (à discuter) serait-il utile de passer ton type tab_bit à une taille de 9 ou 10 bits--> tu n'aurais plus à gerer les depacements de pile. simplement tu n'aurai qu'à tester les valeurs de bit9 et 10 pour savoir si tes operations t'on fais depacer la taille critique de 8bits (c'est une idée, mais peut etre a tu besoin de T3_tmp pour la suite de ton prog).
- tu utilises "exit" --> à bannir en ada (au pire utilises une exception, mais y d'autres moyens plus propres)
- penses à utiliser des unités (peut etre plus tard), histoire de stocker ensemble les procedures et functions de meme type (une unité pour les conversions...)
 
VOILA, Bonne continuation   et prends mes propos avec des pincettes, parcequ'il y a un paquet de remarques qui peuvent etre en innadequation avec le but de ton programme
 
ps: si j'ai le temps, ce soir ou ce weekend, j'essayerai le code en utilisant un compilateur, ca m'evitera de te dire des grosses conneries question syntaxe.

Alors voilà, j'ai réfléchis un peu plus en voyant mon prog, que je pouvais faire ainsi :
 
Pour ma fonction Convert,
 
function Convert ( nb  : Integer )  
     return Tab_Bit is
    T : Tab_Bit;
    Nb : integer;
   begin
      I := 0;  
      Nb := nb;
      while Nb /= 0 loop
  T(I) := Nb mod 2;
           Nb := Nb / 2;
        I := I + 1;
       end loop;
       return T(I);
      End with;
end Convert;
 
sachant que seul la valeur de nb change, la fonction retourne de toute façon un Tab_Bit.
 
Et pour ma fonction Bit_vers_Num :
 
function Bit_vers_num (
      T : Tab_Bit )
      return num Is
      Tab : Tab_Bit;
      B_Num : num;
   Begin
      Tab := T;
      If Tab.Bit1 = 1  Then
         B_Num := 128;
      ElsIf Tab.Bit2 = 1 Then
         B_Num := B_Num + 64;
      ElsIf Tab.Bit3 = 1 Then
         B_Num := B_Num + 32;
      ElsIf Tab.Bit4 = 1 Then
         B_Num := B_Num + 16;
      ElsIf Tab.Bit5 = 1 Then
         B_Num := B_Num + 08;
      ElsIf Tab.Bit6 = 1 Then
         B_Num := B_Num + 04;
      ElsIf Tab.Bit7 = 1 Then
         B_Num := B_Num + 02;
      ElsIf Tab.Bit8 = 1 Then
         B_Num := B_Num + 01;
      End If;
      Return B_Num;
   End Bit_Vers_Octet;
 
ça fait une bonne cure d'amaigrissement...
 
Mon code pour le prog principal à lui aussi subit la loi ...
 
   I : Integer;  
   Nb1 : Integer;  
   Nb2 : Integer;  
   begin  
   Put ("Entrez U (Volts) : " );  
   Get (Nb1);  
   num := (Nb1);  
   if num < 0 then  
      Put ("Défaut nombre négatif: essayez encore une fois" );  
      exit;  
   else  
      T1 := (Convert ( num ));
      Put ("La representation digitale est : " );
      New_Line;  
      for I in Integer range '0' .. '7' loop  
            Put (T1(I));  
      End Loop;
   end if;  
      New_Line;  
      Put ("Entrez I (Ampères) : " );  
      Get (Nb2);  
      num := (Nb2);  
      if num < 0 then  
         Put ("Défaut nombre négatif: essayez encore une fois" );  
         exit;  
      else
         T2 := (Convert ( num ));
         Put ("La representation digitale est : " );
         New_Line;  
         for I := 0 .. 7 loop  
            Put (T2 (I));
         End Loop;  
      end if;
      New_Line;
      T3 := (Add_Tab_Bit(T1, T2));
      Put ("La somme de ses deux représentations est : " );
      For I in 0 .. 7 Loop
              Put (T3(I));
      End Loop;
      New_Line;
      Put ("Sa représentation numérique est : " );
      New_Line;  
      Put (Bit_Vers_Octet(T3));
      New_Line;  
end Convert_Bit;  
 
Voilà, je pense que j'ai résolu quelques problèmes mais ce n'est pas fini,  
 
J'ai des messages : invalid préfix in sélected coponent "Tab" et tous mes T1 T2 T3 T3_ temp
 
Il faut que je creuse la question plus profond.
A oui, aussi dans ma fonct bit_ver_num,  
le compil me dit Tab_Bit        ... résolu...
 
deux erreurs encore dans fonct. Convert :
 Il me dit, Expeted type "Tab_Bit" defined at line 17
et found type " Standard Integer  pour T(I)
 à la ligne Return T(I);
oui, je suis d'accord avec toi,
 j'ai eu lors de mon premier jet une erreur dans l'appellation de certaines données
c'est corrigé

Bonjour blacksad988,
 
J'ai bien pris note de tes recommandations, et j'ai corrigé, les erreurs de jeunesse du code que j'ai pondu,
Je l'ai compilé,
il m'affiche de warning, à propos de T et T3_Temp is never assigned a value. Dans la définition de type tab_bit is array.
Sinon le programe tourne disons sur trois cylindres, car il y a encore un élément qui cloche dans ma fonction de conversion des mots de bits en numérique.

Warnings corrigés, mais il y a encore un bug dans ma fonction de conversion cette fois fonction convert, qui fait n'importe quoi, par exemple conversion de 5 : voilà ce qu'il me trouve : 1    0     1     426346  38010564   0   0   19, alors là il faut que j'aille me faire une séance de méditation trancendentale car mon cerveau se met en grève...

 
tu peux me mailler tes fichiers sources?
je compile et essaye de t'aider
 
(pour les warning que tu avais, cela signifie simplement que tu declarer des valeurs que tu n'utilisais pas, ca fais pas planter, ca t'indique juste que tu peux t'en passer
 
 
ps: je te file un email en private
 

Bonsoir blacksad988
 
merci du conseil, j'ai repris le boulot aujourhui, je te donne tout ça ce soir, une fois réécris toutes les modifs,  
à tout de suite...

 
je t'ai retourné ton programme corrigé et annoté
 
Tes methodes de conversion sont toutes bonnes, il sagissait seulement d'erreurs "betes" de codage + quelques pavés à simplifier. Mais dans l'ensemble c'etait bon. (il y a toujours quelques bout de code qui font tout planter, au debut )
 
 
on attend la suite