problème de conversion et concaténation des chaines de caractères

Version imprimable

Bonjour tout le monde,

J'ai besoin de vos aides SVP.

Je suis entrain de créer un programme qui reçoit ne entrée un nombre hexadécimal. Le but du programme est de vérifier si ce nombre est écrit sur 8 octets. Sinon il ajoute les zéros manquants au début.

Par exemple: de : AFF12 je veux obtenir 000AFF12.

J'ai commencé par convertir mon nombre en chaine pour déterminer le nombre de caractère et savoir combien de 0 je dois ajouter, et concaténer ensuite cette suite de 0 à la chaine de base.
J'ai crée ce programme mais il plante donc surement il y a une erreur que je n'arrive pas à trouver.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
 
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
 
int main()
{
    int c;
    char *chaine[10] ;
    int c_res;
    unsigned int c_long;
    char *chaine_zero;
    char *chaine_res;
    printf("donner le nombre: \n");
    scanf("%x", &c); 
 
    itoa(c,chaine,16);
    printf("la chaine obtenu est : %s \n", chaine);
 
    c_long=strlen(chaine);
    printf("la longeur est : %d \n", c_long);
 
 
    if(c_long==8)
    {
        c_res=c;
        printf("le  nombre = %x \n", c_res);
 
    }
     else
     {
         unsigned int nbre_zero=(8-c_long);
         printf("nbre_zero= %d \n", nbre_zero);
         switch(nbre_zero)
         {
             case 1:
                 chaine_zero="0";
                 break;
             case 2:
                 chaine_zero="00";
                 break;
             case 3:
                 chaine_zero="000";
                 break;
             case 4:
                 chaine_zero="0000";
                 break;
            case 5:
                chaine_zero="00000";
                break;
            case 6:
                chaine_zero="000000";
                break;
            case 7:
                chaine_zero="0000000";
                break;
     }
     printf("chaine_zero= %s \n", chaine_zero);
     concat(chaine_zero, nbre_zero, chaine, c_long,chaine_res);
     printf("chaine_res= %s \n", chaine_res);
     c_res=atoi(chaine_res);
     printf("le  nombre = %x \n", c_res);
     }
     return 0;
     }
 
 
   void concat(char * str1, unsigned int nbc1, char * str2, unsigned int nbc2,char * rstr)
{
    unsigned int i = 0;
    rstr = (char*)malloc((nbc1+nbc2+1) * sizeof(char));
    for(i = 0; i < nbc1; i++)
        {
            rstr[i]=str1[i];
 
        }
 
 
    for(i = 0; i < nbc2; i++)
        {
            rstr[i+nbc1]=str2[i];
 
        }
 
 
    rstr[nbc1+nbc2+1]='\0';
 
}

Quelqu'un pourra m'aider SVP .
Merci :)

30/06/2017, 16h08
nnovic
Quel est le but de cette "conversion" ? C'est juste pour faire de l'affichage ?
Si c'est le cas, printf fait ça très bien tout seul:
Code:

1 2 3 printf("%08x", 1); --> 00000001
30/06/2017, 16h09
ternel

Et si tu utilisais les nombreuses options de configuration des fonctions *printf?

Effectivement printf("%x", nombre) affiche le nombre brut en hexadécimal, mais en rajoutant les bonnes options entre le % et le x, tu peux obtenir ce que tu veux.
Regarde une documentation officielle.
30/06/2017, 16h12
abyass
Citation:
Envoyé par nnovic

Quel est le but de cette "conversion" ? C'est juste pour faire de l'affichage ?
Si c'est le cas, printf fait ça très bien tout seul:

Code:

1 2 3 printf("%08x", 1); --> 00000001
Non je cherche à récupérer ce nombre par la suite pour le traiter. En fait, j'ai besoin qu'il soit sur 8octets car je vais extraire la partie LSB et MSB par le travail qui suit.

Merci :)
30/06/2017, 16h20
dalfab
Bonjour,

réponse rapide en une ligne :
Code:

1 2 3 char* buffer = malloc(8+1); sprintf( buffer , "%08X" , c ); // pour l'avoir dans une variable printf( "le nombre = %s\n" , buffer );
.

Sinon dans ta version (un peu plus longue), ligne 87 il faut plutôt faire rstr[nbc1+nbc2]='\0';, et ne pas oublier de libérer la mémoire qui a été allouée au moment du concat.
30/06/2017, 16h30
nnovic

Citation:

Envoyé par abyass

Non je cherche à récupérer ce nombre par la suite pour le traiter. En fait, j'ai besoin qu'il soit sur 8octets car je vais extraire la partie LSB et MSB par le travail qui suit.

Merci :)

Mais tu vas travailler sur des valeurs numériques ou sur des chaines de caractères ? Je pige pas, là ! :?
30/06/2017, 16h36
abyass

Citation:

Envoyé par nnovic

Mais tu vas travailler sur des valeurs numériques ou sur des chaines de caractères ? Je pige pas, là ! :?

effectivement je travaille avec valeurs numériques donc je dois convertir les chaines en entiers par la suite. Et c'est mon problème déjà là. Quand j'applique atoi le résultat revient sans les 0 ajoutés.
Merci :)
30/06/2017, 16h41
nnovic

Dans ce cas il ne faut surtout pas chercher à passer par des chaines de caractères. Ton entier est dans la variable 'c', qui est de type int. Un simple jeu de masques et de décalages de bits te permettront d'isoler la partie 'haute' de la partie 'basse'. Les fameux zéros que tu veux ajouter sont une simple convention d'affichage, ça n'apporte rien à ton programme.
30/06/2017, 17h04
abyass

Je vous explique en gros mon problème.

Je suis entrain de récupérer des contenus des registres sur un port COM depuis carte. Ces registres contiennent des informations de tension, courant, puissance.. Les registres sont sur 8octets.
En fait il y a des registres où l'information de courant est stocké dans les 17 bits de poids plus fort et la tension dans les 15bits plus faibles ( pas vraiment MSB(16 bits) et LSB(16bits)) donc je dois extraire ces deux parties à part pour les traiter par la suite.
J'ai réalisé ça dans un tableau excel: STXT, .. et ça marche . Mais je n'arrive pas à traduire ces formules en C .

Merci :)

Alors il faut utiliser un type adapté uint32_t pour un registre 32 bits (ca semble mieux correspondre à 15+17 que les 64bits de tes "8 octets"). Ce type est présent dans l'entête standard #include <stdint.h>.

Une fois cela fait, il faut jongler avec les opérateurs bit-à-bit (bitwise).
Par exemple, 0xFFFF8000 est un nombre dont les 17 bits de poids fort valent 1, et les 15 de poids faible valent 0.
Code:

1 2 3 4 5 6 7 8 9 10 11 typedef uint32_t registre_t; int get_intensity(registre_t registre) { registre_t const bitmask_17 = UINT_32C(0x1FFFF); return ((registre & (bitmask_17<<17) >> 17)) & bitmask_17; } int get_voltage(registre_t registre) { registre_t const bitmask_15 = UINT_32C(0x7FFF); return ((registre & (bitmask_15<<15)) >> 15) & bitmask_15; }

Bonjour,
Pour récupérer deux données sur 17 et 15 bits, on peut utiliser les champs de bits et les union qui peuvent être anonymes.

Code:

1
2
3
4
5
6
7
8
9
union {
    uint32_t  valeur;        // valeur et la struct partagent le même espace
    struct {
        unsigned intensite : 17;     // 17 premiers bits sont intensite
        unsigned tension   : 15;     // 15 bits qui suivent sont tension
    };
};
valeur = c;  // on écrit dans l'union, et il ne reste qu'à lire les résultats
printf("intensite = %d, tension = %d\n" , intensite , tension );

On peut sinon créer une fonction qui extrait un nombre de bits à une position donnée

Code:

1
2
3
4
5
6
7
8
9
unsigned extraitBits( uint32_t val , unsigned bitsOffset , unsigned nbBits ) {
    return (val >> bitsOffset) & ((1u<<nbBits) - 1u);
}
unsigned lit_intensite( uint32_t val ) {
    return extraitBits( val , 15 , 17 );     // 17 bits à partir du bit15
}
unsigned lit_tension( uint32_t val ) {
    return extraitBits( val , 0 , 15 );      // 15 bits à partir du bit0
}

03/07/2017, 14h45
abyass

Merci pour votre réponse :)