Codage HDBN en C

Codage HDBN en C - C - Programmation

Marsh Posté le 26-10-2006 à 22:42:41    

Voila j'explique c'est qu'est le codage hdbn pour ceux qui ne connaissent pas :
 
En gros vous avez un signal numérique, donc des 1 et des 0, par exemple celui la : {1, 0 , 1 , 0 , 0, 0, 1, 1, 1, 1} ; c'est le signal d'entrée.
il faut le transformer avec le codage hdbn. hdb + n, n étant un entier de 2 à 4
 
- Premièrement, le hdbn est bipolaire, c'est à dire que si on trouve un 1 dans le signal d'entrée, le prochain 1 que l'on trouvera sera transformé en -1, sauf dans le cas de la transformation des n+1 zeros que je vais preciser juste après
 
- Deuxiemmement, lorsque n+1 zeros sont detectés a la suite sur le signal d'entrée, ces n+1 zeros sont tranformés en autre chose :  
 
au debut, on fixe v+ a 1 ( v+ = +1, v-=-1, etc)
si v+, on regarde la polarité du dernier bit a 1 sur le signal d'entrée que je vais nommer b+ ou b-
pareil pour v-
 
si on a v- et b- , alors on obtient le couple {b+, (n-1 zeros),v+}, soit {1,0,1} dans le cas d'un hdb2
si v- b+, {(n zeros),v+} soit {0,0,1}
si v+ b +, {b-, (n-1 zeros),v-} soit {-1,0,-1}
si v+ b-, {(n zeros),v-} soit {0,0,-1}
 
dans ce cas la uniquement on peut avoir deux "1" du meme signe a la suite.
 
Voila si ce n'est pas clair ( c'est deja bien le bordel quand on comprend :p ) n'hesitez pas a demander des precisions.
 
Je pense que je dois avoir des problèmes qui sont assez classique en C, style pointeurs, etc, si vous vouyez des choses qui ne vous paraissent pas bonnes ou pas evidentes faites moi signe.
En l'état le code est un peu sans dessus dessous, certaines fonction n'ont que peu d'interet pour le moment, mais vont etre utiles par la suite.
merci d'avance :)
 

Citation :


#include <stdio.h>
#include <stdlib.h>
#define TAILLE 10
 
int hdbn() ;
int reset() ;
int main (void)  
{
     
    int polarite_B = 1 ;
    int compteur, compteur_zeros,compteur2 ;
    int n, signal;
    int signal_in[TAILLE] = {1, 0 , 1 , 0 , 0, 0, 1, 1, 1, 1} ;
    int compteur_bipolaire ;
    int polarite_V;
    int tampon[n+1];
     
    polarite_V = reset();
     
    printf("Donnez l'ordre n du codage hdbn\n" ) ;
    scanf("%d",&n);
       
     
 
    compteur_bipolaire = 0 ;
    compteur_zeros = 0 ;//mise a zero du compteur de zeros
    //definition du signal d'entrée + remise du compteur a zero pour future utilisation
     
       
    for (compteur = 0;compteur <= TAILLE ;compteur++)
    {
        if ( signal_in[compteur] == 1 )
        {
           compteur_zeros = 0 ;//si on detecte un 1 avant que le compteur arrive a n+1, on remet le compteur de zeros à 0
           if ( compteur_bipolaire == 1 )
           {signal_in[compteur] = -1 ;}
           compteur_bipolaire = 1  ;
        }
        else if ( signal_in[compteur] == 0 )
           compteur_zeros = compteur_zeros + 1 ;//si on detecte un zero, on incremente le compteur de zeros
         
        if ( compteur_zeros == n+1 )//si n+1 zeros sont découverts à la suite, on lance le codage hdbn
           {
            polarite_B = signal_in[compteur-(n+1)];
            *tampon = hdbn(n,compteur,polarite_V,polarite_B);
            for ( compteur2 = 0;compteur2 <=n+1; compteur2++)
            {
              signal_in[compteur2+compteur] = *(tampon+compteur) ;  
            }
           }
    }
     
    scanf("%d",&compteur) ;
}
 
int reset()  
{
    int polarite_V ;
    polarite_V = -1 ;
    return polarite_V ;
}
 
 
 
int hdbn ( int n, int *signal_in, int compteur, int polarite_V, int polarite_B  ){
     
 
    int compteur2,compteur3 ;
    //déclaration des signaux de sortie
    int S_plus[TAILLE];
    int S_moins[TAILLE];
   // int S[TAILLE] = S_moins[] + S_plus[]  ;
    int tampon[n+1];
     
    if ( polarite_V < 0 )
    {
         if ( polarite_B < 0)
         {
            for ( compteur2 = 0; compteur2 <= n+1;compteur2++ )
            {
            tampon[compteur2]= 0 ;
            }//mettre des zeros dans le tampon
            //v+ et b+ donnent v- et b-
            tampon[0]= -1 ;
            tampon[n+1]= -1 ;
         }
         if ( polarite_B > 0)
         {
              for ( compteur2 = 0; compteur2 <= n+1;compteur2++ )
              {
                  tampon[compteur2]= 0 ;
              }//mettre des zeros dans le tampon
              //v+ donne v-
              tampon[n+1]= -1 ;
         }
    }
    if ( polarite_V > 0)
    {
         if ( polarite_B < 0)
         {
            for ( compteur2 = 0; compteur2 <= n+1;compteur2++ )
            {
                tampon[compteur2]= 0 ;
            }//mettre des zeros dans le tampon
            //v- et b- donnent v+ et b+
            tampon[0]= 1 ;
            tampon[n+1]= 1 ;
         }
         if ( polarite_B > 0)
         {
              for ( compteur2 = 0; compteur2 <= n+1;compteur2++ )
              {
                  tampon[compteur2]= 0 ;
              }//mettre des zeros dans le tampon
              //v+ donne v-
              tampon[n+1]= -1 ;
         }
    }
 
    for ( compteur2 = 0; compteur2 <= n+1;compteur2++ )
    {
        printf("tampon %d : %d\n",compteur2,*(tampon+compteur2));
    }
    return *tampon ;
 
}  
 

 
         
     
     
     

Reply

Marsh Posté le 26-10-2006 à 22:42:41   

Reply

Marsh Posté le 27-10-2006 à 00:07:19    


n a une valeur indéterminée.  

Code :
  1. int n, signal;


Qu'espère-tu exactement de  

Code :
  1. int tampon[n+1];


A part n'importe quoi ?
 
C'est pas un jouet le C. Il y a des regles... on ne code pas au hasard comme ça...
 
Si j'ai bien compris, tu veux faire un codeur HDBn. OK. Pour le codeur, je suggère une fonction qui reçoit le bit à coder (0 ou 1) et qui retourne la valeur du signal bipolaire correspondant, soit 1, 0 ou -1.

Code :
  1. int hdb_encode (int bit);


Pour le décodeur, on fait le contraire : On passe une valeur bipolaire et on retourne un bit.

Code :
  1. int hdb_decode (int bip);


 
Je suggère de créer un type de donnée abstrait de données (TAD ou ADT[1]) nommé HDB, paramétré avec une valeur 2,3 ou 4 selon le type d'encodage souhaité.

Code :
  1. typedef struct hdb HDB;
  2. HDB *hdb_create (int type_encodage);
  3. hdb_delete (HDB *this);


Les fonctions sont intégrées à l'ADT de cette façon :  

Code :
  1. int hdb_encode (HDB *this, int bit);
  2. int hdb_decode (HDB *this, int bip);


 
Une fois que le code sera organisé, on pourra attaquer l'algo d'encodage, qui est séquentiel et nécessite une mémoire d'état (ça tombe bien, avec un ADT, on a tout ce qu'il faut).
 
Après création de l'ADT en mode 2, par exemple, je propose un programme de test avec des points d'observation :  
 
- Une séquence de test prédéfinie comme {1, 0 ,1 ,0 ,0, 0, 1, 1, 1, 1} (dépend du mode)
 
- Dans une boucle,  
-- l'appel de hdb_encode() avec chaque bit du tableau
-- la récupération de la valeur bipolaire et sa comparaison avec une séquence de valeurs bipolaires attendue à définir (1er point d'observation).
-- l'appel de hdb_decode() avec la valeur bipolaire
-- la récupération de la valeur binaire et sa comparaison avec la séquence initiale. (2 ème point d'observation)
 
On aura ainsi simulé complètement un encodage/decodage HDBn.
----------------------
[1] http://mapage.noos.fr/emdel/tad.htm


Message édité par Emmanuel Delahaye le 27-10-2006 à 00:08:33

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 27-10-2006 à 07:25:43    

Merci de t'interesser a mon problème :)
 
Pour le signal non defini, c'est surement parce que j'ai pas encore revu tout le code, il y en a un peu de partout.
Pour le tampon[n+1], c'est pour créér une zone de traitement ou je remplace les valeurs des n+1 zeros par un truc du genre {1,0,1} et après je renvoie cette partie la dans signal_in au bon endroit, et le code continue.
 
le problème, c'est que la suite de n zeros est prioritaire par rapport au bipolaire du signal, on ne peux pas convertir d'abord le signal en entier en bipolaire, la suite dependra des derniers v(-,+) et b(-,+)
 
Pourrais tu m'expliquer ce que veut dire cette partie?
   
      typedef struct hdb HDB;
   
      HDB *hdb_create (int type_encodage);
   
      hdb_delete (HDB *this);  
 
je comprends la definition d'une strcture mais le reste je suis un peu largué :p
 
Merci d'avance

Reply

Marsh Posté le 27-10-2006 à 09:21:25    

Decapfour a écrit :

Pourrais tu m'expliquer ce que veut dire cette partie?

   
      typedef struct hdb HDB;
   
      HDB *hdb_create (int type_encodage);
   
      hdb_delete (HDB *this);  


je comprends la definition d'une strcture mais le reste je suis un peu largué :p


Je t'ai passé un lien vers un article sur les ADT. Tu l'as lu ?


Message édité par Emmanuel Delahaye le 27-10-2006 à 09:42:06

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Marsh Posté le 27-10-2006 à 16:30:39    

Autant pour moi, j'ai cru que c'etait ta signature :p
Je vennai de me reveiller, et c'est la fin de semaine :D

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed