Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur le langage C !

Modérateur : Jérémy

Structure et Champs de bits
AchileT
Membre
Membre
Messages : 17
Enregistré en : septembre 2015

#1 Message par AchileT » dim. 27 sept. 2015 10:16

Bonjour la compagnie,

J'ai vu sur abcelectronique la création de ce forum, alors je me suis inscrit, étant moi même débutant.

J'ai une question sur la structure d'un champ de bit.

Je souhaite faire passer des informations en tout ou rien par voie radio. Pour ce faire et gagner en octets j'avais penser les réunir en un seul octet. Ainsi je pourrais envoyer 8 bits en une seule information.

Pensez vous que cela est possible ? il faudrait que je puisse travailler sur chaque bit indépendamment les unes des autres en les renommant par exemple .

Structure et Champs de bits
Guest
Confirmé
Confirmé
Messages : 800
Enregistré en : mars 2017

#2 Message par Guest » dim. 27 sept. 2015 11:12

Bonjour
voila une declarations d'une structure 8bits par exemple

Code : Tout sélectionner

/***********************structure de 8 bits *************************/

struct {                                // Holds status bits
    unsigned            trm01:1;   // flag TRM01
    unsigned            trm02:1;        // Flag TRM02
    unsigned       bit2:1;
    unsigned       bit3:1;
    unsigned            bit4:1;
    unsigned            bit5:1;
    unsigned            bit6:1;
    unsigned            bit7:1;
} stat ;

et ici un test et la manipulation du bit ici stat.trm01

Code : Tout sélectionner

void
inter_haute(void)
{
  char compte = 0;
 
  if (INTCONbits.TMR0IF == 1)        // debordement timer0?
    {
    INTCONbits.TMR0IF = 0;       // oui remise a zeo flag

        if (stat.trm01 == 0)       // test flag si arriver en FIN de tempo
            {
        if (compte < 31)       // test Si notre compteur arriver en FIN de tempo
                {
                ++compte;      // Non  compte+1
                }
        else
                {
            stat.trm01= 1;      // flag a 1
            compte = 0;         // et compteur a zero modifie dans int
                }
            }
// ici suite eventuellement d'autres tempos
    }
}


c'est pour XC8 a voir avec ton compilateur

A+

Structure et Champs de bits
Guest
Confirmé
Confirmé
Messages : 800
Enregistré en : mars 2017

#3 Message par Guest » dim. 27 sept. 2015 12:10

re bonjour

les structures peuvent s’écrire aussi comme cela

Code : Tout sélectionner

struct {                                // Holds status bits
    unsigned               trm01:1;   // flag TRM01
    unsigned            trm02:1;        // Flag TRM02
    unsigned       bit2:1;
    unsigned       bit3:1;
    unsigned          quatre:4;
} stat ;

la variable ici quatre est positionné sur 4 bits

Code : Tout sélectionner

    stat.quatre = 3;


a voir avec ton compilateur, structure c'est vaste

A+

Structure et Champs de bits
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#4 Message par Jérémy » dim. 27 sept. 2015 14:40

Hello AchileT,

Il serait bien de préciser ton compilateur ? quelques légères différences peuvent subsister entre MikroC et XC8 .
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Structure et Champs de bits
AchileT
Membre
Membre
Messages : 17
Enregistré en : septembre 2015

#5 Message par AchileT » dim. 27 sept. 2015 18:09

Merci maï et Jérémy pour vos réponses ultra rapides .

je vais essayer tout ça . J'ai oublié de vous dire que je programme avec MikroC pro . Je vais essayer de convertir tout ca dés que j'ai un peu de temps.

Par contre est ce que je peux donner un nombre à ma structure, pour l’appeler comme une variable ?

Structure et Champs de bits
Guest
Confirmé
Confirmé
Messages : 800
Enregistré en : mars 2017

#6 Message par Guest » lun. 28 sept. 2015 09:17

Bonjour
AchileT a écrit :Par contre est ce que je peux donner un nombre à ma structure, pour l’appeler comme une variable ?


je pense qu'il faut chercher un peu , car perso comme déjà dit le C, n'est pas ma tasse de the .je vous donne quand même toujours pour XC8 une solution. structure et union. Je pense qu'il doit y en avoir d'autres.Par exemple la manip sur les bits de la variable avec opérateur logique, un peu plus long, si vous ne trouvait pas.Celle que je vous propose amha est la plus rapide.

Code : Tout sélectionner

union myunion {
unsigned char byte;
struct {
    unsigned b0:1;
    unsigned b1:1;
    unsigned b2:1;
    unsigned b3:1;
    unsigned b4:1;
    unsigned b5:1;
    unsigned b6:1;
    unsigned b7:1;
    } bitv;
} var;


et la manipulation

Code : Tout sélectionner

    var.bitv.b0 = 1; //manip sur bit de la variable
    var.byte = 12;      //manip sur variable
    donnée =var.byte;


A+
Modifié en dernier par Anonymous le lun. 28 sept. 2015 18:34, modifié 1 fois.

Structure et Champs de bits
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#7 Message par Jérémy » lun. 28 sept. 2015 16:29

Coucou,

@AchileT, je suis fortement intéresser par ta question , pour un futur projet . Dans quel contexte pense tu utilisé ceci ?

Pour ma part, se sera pour envoyer des informations d'interrupteur ( donc en Tout ou Rien) aussi par voie radio, sur un Véhicule à distance !
Je vais essayer de vous suivre, mais j'ai lus quelques trucs dessus et ça m'a l'air plutôt pêchus .

Je crois que je viens de trouver mon prochain tuto ! . Si ça te dérange pas je vais aussi squatter un peu ce post.
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Structure et Champs de bits
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#8 Message par Jérémy » ven. 2 oct. 2015 17:46

AchileT tu es mort ?

Si tu as trouvé ta réponse il serait intéressant de la partager avec la communauté . c'est le principe d'un forum, car cela pourra aidé d'autres personnes .

Merci !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Structure et Champs de bits
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 2589
Âge : 73
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#9 Message par paulfjujo » sam. 3 oct. 2015 11:36

bonjour,


concernant les structures, tu en utilises déja à foison, definies en interne compilateur MikroC
LATA0_bit
PORTA.B0
en fait toutes les variable en *_bit sont des elements d'une structure
les unions aussi, car :
LATA0_bit est equivalent à LATA.B0
PORTA0_bit ..... PORTA.B0


exemple de champs de bit regroupes dans un octet => 8 infos dans un octet
cela evite de declarer chaque drapeau individuellement , soit au minimum 8 octets
Ces drapeaux peuvent etre utilisés n'importe ou dans le programme principal , si declaré en Global
donc en dehors du main programme.
l'avantage est d'avoir un nom significatif
par exemple Stable ... Drapeaux.Stable pour indiquer que l'oscillateur interne est Stable
Accumule pour indiquer qu'on a accumulé un certain nombre de mesure et qu'on peut en faire la moyenne.
..etc..

Code : Tout sélectionner

//unsigned char Drapeaux ;     // 8 flags
struct chbits {
                 unsigned Stable:1;
                 unsigned SDcard:1;
                 unsigned elligible:1;
                 unsigned Accumule:1;
                 unsigned Blc:1;
                 unsigned Over:1;
                 unsigned Fill:1;
                 unsigned Lcd:1;
               } Drapeaux;
//    

exemple d'usage du drapeaux.Lcd pour decider si on envoi
la chaine de caratere sur un LCD Nokia 3310 ou sur l' UART RS232

Code : Tout sélectionner


void Write_String
(char * txt)
{
 short int i1,j1,k;
   i1=0;
   while(*(txt))   // tant qu'on ne rencontre pas la fin de chaine  =0
   {
     if (Drapeaux.Lcd==0)
      Put_RS(k);  // envoi car sur UART
    else
     
{
      // tronque le message si superieur à largeur LCD
       if (i1<16) sendchar(k);  // envoi car sur LCD
      }
   if (Drapeaux.Lcd==0)
   {
    PutR_RS(10); // line feed LF
    PutR_RS(13); // Carriage Return CR
   }
  i1++;
}


**********************

Autre exemple , pour assembler ou eclater un mot de 32 bits

Code : Tout sélectionner

#define Byte unsigned char

// pV pointe sur l'ensemble des 4 octets
struct ForByte
{
     Byte pv0;
     Byte pv1;
     Byte pv2;
     Byte pv3;
    } pV;

// MD pointe sur le mot de 32 bit  Freq   [b] ET[/b]    aussi sur l'ensemble de 4 bytes pV
union
{
  near unsigned long Freq;
  near struct ForByte pV;
}
MD

// si on initialise le terme Freq

Code : Tout sélectionner

MD.Freq= 0xFF804020


resultat dans la structure ForByte:

Code : Tout sélectionner

=> pV.pv3=0xFF
=> pV.pv2=0x80
=> pV.pv1=0x40
=> pV.pv0=0x20



********************************

les instructions
utilisées pour le LCD et autres ..
sbit .. at .... servent à definir DIRECTEMENT une structure de bit

sbit BP0 as PORTB.B0
sbit BP0_direction as TRISB.B0

dans le main
BP0_direction=1 ; // en entree
....
if (BP0==1) ... test BP0
Aide toi, le ciel ou FantasPic t'aidera

Structure et Champs de bits
Jérémy
Administrateur du site
Administrateur du site
Messages : 2722
Âge : 44
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#10 Message par Jérémy » sam. 3 oct. 2015 19:10

Bonsoir,

Alors j'ai lu, et essayer de comprendre ces maudits champs de bits . pas évident pour un novice .

@Paulfjujo : Au début j'ai compris ton explication, mais les exemples qui suivent sont bien trop complexe . Tu fais rentrer plein de nouveaux truc d'un seul coup, difficile à comprendre pour une bille comme moi . ( put , send char ; write string etc ....) . Trop gros niveaux la humour!!

Sinon j'ai quand même avancé cet après-midi . en mixant le Maï et Paul . J'en suis rendu a ce petit programme , qui a le mérite de bien commencé mais de mal finir oops

En fait le but ( pour le moment), :
Appui sur un BP on incrémente notre variable global
Appui sur un autre BP un change seulement 1 bit de notre variable .

rien de bien compliqué me direz vous. Mais ca m'aide a comprendre en tout cas . Le seul hic c'est que je part de la valeur 0 que j'affiche sur le LCD . quand j’incrémente ma variable avec les boutons ca fonctionne impeccable . quand je change mon bit seulement ca ajoute 1 ou ca le retranche nickel ! Seulement voila une fois arrivé a la valeur 8 tout se bloque ?
Avez vous une idée du problème ?

Code : Tout sélectionner

/*##################################################################################
##############################     Variable / Constante    #########################
##################################################################################*/

char  monOCTETmonCHAMPS;

char text[17];     // création d'un tableau pour aceuillir une chaine de 16 caracteres + terminaison ( 1 ligne)
char *ptr ;        // Création d'un pointeur

void affichage (); // Déclaration de la fonction ( mise à la fin)

// Connexions du module LCD
sbit LCD_RS at LATB4_bit;
sbit LCD_EN at LATB5_bit;
sbit LCD_D4 at LATB0_bit;
sbit LCD_D5 at LATB1_bit;
sbit LCD_D6 at LATB2_bit;
sbit LCD_D7 at LATB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// FIN Connexions du module LCD

// Création de l'UNION
 
union myunion {                 // Nom de l'union qui réunis deux structures ( 1 Champs de bits et 1 variable)
                                 // Les deux structures auront la même adresse mémoire

       
unsigned char monOCTET;   // Ici la premiere structure qui est une variable appellée monOCTET

        
struct {                 // ici la deuxiéme structure qui est un champ de bits
            
unsigned inter0:1;
            
unsigned inter1:1;
            
unsigned inter2:1;
            
unsigned inter3:1;
            
unsigned inter4:1;
            
unsigned inter5:1;
            
unsigned inter6:1;
            
unsigned inter7:1;
           } 
monCHAMPS;        // Nom du champs de bits
  
variable;                  // Nom de l'UNION
// Fin de l'UNION

/*##################################################################################
############################   PROGRAMME PRINCIPAL    ##############################
##################################################################################*/
void main(){
  
ANSELB 0;                        // Configure le PORTB en digital
  
TRISB 0b00000000;                // Configure le PORTB en Sortie
  
LATB 0;                          // Initialise à 0

  
ANSELC 0;                        // Configure le PORTC en digital
  
TRISC 0b00000000;                // Configure le PORTC en Sortie
  
LATC 0;                          // Initialise à 0

  
ANSELD 0;                        // Configure le PORTD en digital
  
TRISD 0b11111111;                // Configure le PORTD en Entrée
  
LATD 0;                          // Initialise à 0

  
Lcd_Init();                        // Initialisation du LCD

  
Lcd_Cmd(_LCD_CLEAR);               // On efface l'écran
  
Lcd_Cmd(_LCD_CURSOR_OFF);          // On arrete le curseur
  
delay_ms(500);                     // pause de 500ms

  
Lcd_Out(1,1,"Valeur variable=");  // On affiche du texte

  
variable.monOCTET 0;            // On met notre variable à 0

  
ShortToStr(variable.monOCTETtext); // On convertis notre variable en string pour l'afficher
  
Lcd_Out(2,1,text);                   // On affiche la valeur de notre variable : "0" au départ

 //##########################    BOUCLE INFINIE    ##################################
  
while(1) {                   // boucle sans fin

    
if (PORTD.B0 == 1) {       // Détection d'appui sur le BP0 qui incremente notre variable directement
       
delay_ms(30);
       if (
PORTD.B0 == 1)
          while (
PORTD.B0 == 1); // Anti- rebond

          
variable.monOCTET variable.monOCTET // incrémentation de notre variable entiere

          
PORTC variable.monOCTET;
          
ShortToStr(variable.monOCTETtext);       // COnversion de la variable en string pour affichage
          
Lcd_Out(2,1,text);                         // On affiche la valeur de notre variable
      
}

    if (
PORTD.B1 == 1) {     // Detection de l'appui sur le BP1 qui inverse le bit0 de notre variable
       
delay_ms(30);
       if (
PORTD.B1 == 1)
          while (
PORTD.B1 == 1); // Anti-rebond

        
variable.monCHAMPS.inter0 = ~variable.monCHAMPS.inter0 // Inversion du Bit0 de notre variable

          
PORTC variable.monOCTET;
          
ShortToStr(variable.monOCTETtext);                  // COnversion de la variable en string pour affichage
          
Lcd_Out(2,1,text) ;                                   // On affiche la valeur de notre variable
     
}
  }
}

 
C'est en faisant des erreurs, que l'on apprend le mieux !!!


Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 38 invités