Codage HDBN en C - C - Programmation
Marsh Posté le 27-10-2006 à 00:07:19
Decapfour a écrit : <code...> |
n a une valeur indéterminée.
Code :
|
Qu'espère-tu exactement de
Code :
|
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 :
|
Pour le décodeur, on fait le contraire : On passe une valeur bipolaire et on retourne un bit.
Code :
|
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 :
|
Les fonctions sont intégrées à l'ADT de cette façon :
Code :
|
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
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é
Merci d'avance
Marsh Posté le 27-10-2006 à 09:21:25
Decapfour a écrit : Pourrais tu m'expliquer ce que veut dire cette partie?
|
Je t'ai passé un lien vers un article sur les ADT. Tu l'as lu ?
Marsh Posté le 27-10-2006 à 16:30:39
Autant pour moi, j'ai cru que c'etait ta signature
Je vennai de me reveiller, et c'est la fin de semaine
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 ) 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
#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 ;
}