- 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 ---
Modérateur : Jérémy
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 .
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+
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+
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 ?
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+
-
Jérémy
Administrateur du site- Messages : 2723
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
@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.
- paulfjujo
Expert- Messages : 2597
- Âge : 73
- Enregistré en : juillet 2015
- Localisation : 01800
- Contact :
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
-
Jérémy
Administrateur du site- Messages : 2723
- Âge : 45
- Enregistré en : juillet 2015
- Localisation : Dans le sud
- Contact :
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
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
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 monOCTET, monCHAMPS;
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.monOCTET, text); // 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 + 1 ; // incrémentation de notre variable entiere
PORTC = variable.monOCTET;
ShortToStr(variable.monOCTET, text); // 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.monOCTET, text); // COnversion de la variable en string pour affichage
Lcd_Out(2,1,text) ; // On affiche la valeur de notre variable
}
}
}
Qui est en ligne
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 81 invités