Error [1151] struct or union object designator expected [Résolu]

Signaler
Messages postés
9
Date d'inscription
mercredi 1 août 2007
Statut
Membre
Dernière intervention
4 septembre 2007
-
Messages postés
9
Date d'inscription
mercredi 1 août 2007
Statut
Membre
Dernière intervention
4 septembre 2007
-
bonjour tout le monde,

je travail l'implémentation d'un programme dans un pic 18F et j'ai des erreurs lors de la compilation.

c'est erreurs sont :

C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:565:Warning [2054] suspicious pointer conversion
C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:653:Error [1151] struct or union object designator expected
C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:653:Warning [2054] suspicious pointer conversion
C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:653:Error [1151] struct or union object designator expected
C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:653:Warning [2054] suspicious pointer conversion
C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:654:Error [1151] struct or union object designator expected
C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:654:Warning [2054] suspicious pointer conversion
C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:654:Error [1151] struct or union object designator expected
C:\PPPalege\Microchip\Include\TCPIP Stack\PPP.h:654:Warning [2054] suspicious pointer conversion

et les ligne aux quelles cela correspond :

BOOL get_lword(DWORD *lwp)
{

    BYTE n=4, b;

    DEBUG_PUTC('.');
#ifdef HI_TECH_C
    while (n && get_byte(&b))
        lwp->b[--n] = b;
    return(n==0);
#else
    if (get_byte(&lwp->b[3]) && get_byte(&lwp->b[2]) &&  /////////////////c'est ici l'erreur
        get_byte(&lwp->b[1]) && get_byte(&lwp->b[0]))    ///////////////// et la également
        return(1);
    return(0);
#endif
}

j'ai a peine 1 mois de programmation en C dans les doigts lol....

si qq1 peut m'aiguiller se serais bien sympathique

8 réponses

Messages postés
966
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
4 mars 2010
4
lwp est de type pointeur sur DWORD (unsigned long) donc d'où est-ce-que sort le membre lwp->b? Je comprends pas trop ce que tu veux faire mais si c'est accéder à un élément du tableau lwp la syntaxe est lwp[i]; si tu veux, comme j'ai l'impression, séparer le DWORD pointé en octets, il faut utiliser des masques et des décalages :
octet de poids faible : (BYTE)(lwp[0]&0xFF) // équivalent : (BYTE)((*lwp)&0xFF)
octet 2 : (BYTE)((lwp[0]&0xFF00)>>8)
octet 3 : (BYTE)((lwp[0]&0xFF0000)>>16)
octet de poids fort : (BYTE)((lwp[0]&0xFF000000)>>24)
Messages postés
9
Date d'inscription
mercredi 1 août 2007
Statut
Membre
Dernière intervention
4 septembre 2007

oki merci pour ta réponse,
donc lorsque j'écris :

BOOL get_lword(DWORD *lwp)
{

    BYTE n=4, b;

    DEBUG_PUTC('.');
#ifdef HI_TECH_C
    while (n && get_byte(&b))
        lwp->b[--n] = b;
    return(n==0);
#else
  //  if (get_byte(&lwp->b[3]) && get_byte(&lwp->b[2]) && get_byte(&lwp->b[1]) && get_byte(&lwp->b[0]))   /////////////////
    if (get_byte(&lwp[3]) && get_byte(&lwp[2]) && get_byte(&lwp[1]) && get_byte(&lwp[0]))
        return(1);
    return(0);
#endif
}

//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////

/* Put a longword in the network buffer, then add to checksum */
 void put_lword(DWORD *lwp)
{
    /*
   put_byte(lwp->b[3]);
   put_byte(lwp->b[2]);
   put_byte(lwp->b[1]);
   put_byte(lwp->b[0]);*/

   put_byte(lwp[3]);
   put_byte(lwp[2]);
   put_byte(lwp[1]);
   put_byte(lwp[0]);
 
}

cela marche tres bien.

En ce qui concerne le fonctionnemant du code, je sais ce qu'il doit faire d'une facon générale, je décrypte certaine fonctions, quant à certaines autre je ne les comprend pas trop (ex : celle ci dessus ) je suis débutant (- d'1 mois de C).

je vais essayer de faire un masque comme tu le préconises...
Messages postés
966
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
4 mars 2010
4
Je comprends pas trop à quoi sert ce code à vrai dire...que fait la fonction get_byte?
Une petite remarque, tu peux remplacer &lwp[2] par lwp+2 par exemple.
Messages postés
9
Date d'inscription
mercredi 1 août 2007
Statut
Membre
Dernière intervention
4 septembre 2007

programme entier permet de faire ube liaison PPP.
pour cela on doit verifier la valeur des octet qui arrive, la fonction get_byte permet cela.

elle est implementée si dessous

BOOL get_byte(BYTE *bp)
{
    BYTE b;

    if (rxbuffout >= rxbuffin)
        load_rxbuff(RXMARGIN, RXBUFFLEN);
    if (rxbuffout >= rxbuffin)
        return(0);
    b = rxbuff[rxbuffout++];
    rxout++;
    if (!rx_checkoff)
        check_byte(b);
    *bp = b;
#if DEBUG
    disp_hexbyte(b);
#endif
    return(1);
}
Messages postés
966
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
4 mars 2010
4
OK j'ai compris tu testes chaque octet et tu remplis le DWORD buffer avec, et bien c'est OK comme cela.
Messages postés
1137
Date d'inscription
lundi 17 novembre 2003
Statut
Membre
Dernière intervention
23 janvier 2016
20
J'ai pas l'impression que quant tu fais :

get_byte(&lwp[3]);    //(avec DWORD* lwp)

ce soit le pointeur vers le byte voulu que tu passes mais le premier byte du 4ième long int

// a l'origine tu reconstruit un DWORD avec 4 byte
get_byte(&lwp->byte[3]) //adresse du byte de poids fort
get_byte(&lwp->byte[2]) // ect...
get_byte(&lwp->byte[1])
get_byte(&lwp->byte[0])

// alors que là tu prends un byte de 4  DWORD d'on ne sait ou
get_byte(&lwp[3])   // ?
get_byte(&lwp[2])   // ?
get_byte(&lwp[1])   // ?
get_byte(&lwp[0])   // heu, bon

Le premier bloc marcherait si tu avait
struct DWORD
{
   BYTE byte[4];
};
Ce qui doit exister et etre inclu depuis un .h de ton PIC.
Messages postés
9
Date d'inscription
mercredi 1 août 2007
Statut
Membre
Dernière intervention
4 septembre 2007

oki merci
pour vos réponse

je vais m'y repenché
Messages postés
9
Date d'inscription
mercredi 1 août 2007
Statut
Membre
Dernière intervention
4 septembre 2007

bonjour,

j'aimerais avoir votre avis, enfin surtout vos explication,

voila 2 fonctions
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Put a longword in the network buffer, then add to checksum */
 /*void put_lword(DWORD *lwp)
{
   
//   put_byte(lwp->b[3]);///////////////////////// c'est  lignes retournais une erreur a la
compilation je les es donc remplacer par la ligne suivante.
//   put_byte(lwp->b[2]);/////////////////
//   put_byte(lwp->b[1]);///////////////
//   put_byte(lwp->b[0]);///////////////

   put_byte(lwp[3]); ////// cela marche
   put_byte(lwp[2]);
   put_byte(lwp[1]);
   put_byte(lwp[0]);
 
}*/ cette meme fonction a été réimplémenté de la facon suivante par un colègue doué en C...lol mais cela fait il la meme chose?
void put_lword(DWORD *lwp)
{
    DWORD w;
    w = *lwp;
    put_byte((BYTE)(w >> 24));
    put_byte((BYTE)(w >> 16));
    put_byte((BYTE)(w >> 8));
    put_byte((BYTE)w);
}
////////////////////////////////////////////////////////////////////////////

la seconde :

///////////////////////////////////////////////////////////////////////////////////////
/* Get an incoming lword value, return 0 if end of message */
/*
BOOL get_lword(DWORD *lwp)
{

    BYTE n=4, b;

#ifdef HI_TECH_C
    while (n && get_byte(&b))
        lwp->b[--n] = b;
    return(n==0);
#else
  //  if (get_byte(&lwp->b[3]) && get_byte(&lwp->b[2]) && get_byte(&lwp->b[1]) && get_byte(&lwp->b[0]))   /////////////////
  //  if (get_byte(&lwp[3]) && get_byte(&lwp[2]) && get_byte(&lwp[1]) && get_byte(&lwp[0]))///////////////////////////////// c'est deux lignes retournais une erreur a la compilation je les es donc remplacer par la ligne suivante.

    if (get_byte(&lwp+3) && get_byte(&lwp+2) && get_byte(&lwp+1) && get_byte(&lwp+0))   ////// cela marche
        return(1);
    return(0);
#endif
}*/
------------------------------------------------------------------------------------------------

/* la fonction ci dessus a été refaite par qq1 qui maitrise le C pas comme moi ;-), j'aurais voulu savoir si on faisais la meme chose*/

BOOL get_lword(DWORD *lwp)
{
    BYTE LB,HB,UB,MB;
    DWORD w;
    if (get_byte(&MB) && get_byte(&UB) && get_byte(&HB) && get_byte(&LB))
        w = ((DWORD)MB<<24) | ((DWORD)UB<<16) | ((DWORD)HB<<8) | (WORD)LB;
        *lwp = w;
        return(1);
    return(0);
}