lire des bits

**sdec25** · 23/08/2010, 21h58

ok, c'est presque bon.
Tu as remplacé "ca = 0x0001" par "ca == 0x0001", pourquoi ne pas l'avoir fait avec MA_SORTIE ?
(En C, a=b signifie "a prend la valeur de b").

Sinon, maintenant que MA_SORTIE est un bit, cette ligne n'est plus correcte.

Code:

MA_SORTIE =(MA_SORTIE & 0xFE)|(ca & 0x0001);   //Lecture de la série des bits par le bit 0 du port B

De plus, "ca == 0x0001" est vrai si tous les bits sont à 0 sauf le premier bit. Je suppose que tu ne veux tester que le premier bit, donc "(ca&0x0001) == 1".

Sinon, je ne comprend pas bien ce que doit faire ton programme. Quel est le lien entre "ca", la durée du timer, la sortie courante (MA_SORTIE) et la sortie future ?

invitec8c13b53 · 23/08/2010, 23h12

J'ai modifié le programme comme tu m'as indiqué, mais je ne sais par quoi je dois remplacer MA_SORTIE qui est un bit, donc je l'ai laissé en LATB, merci

Code:

Sinon, je ne comprend pas bien ce que doit faire ton programme. Quel est le lien entre "ca", la durée du timer, la sortie courante (MA_SORTIE) et la sortie future ?

Alors grâce à ce programme, on doit pouvoir lire bit par bit d'une série puis lancer une durée selon la conditions envisagée en changeant d'état à chaque lecture.

Les conditions sont les suivantes :

Si le bit lu est différent au bit précédent + état précédent bas --> On lance un Grand Pallier Haut (GPH)
Si le bit lu est différent au bit précédent + état précédent haut --> On lance un Grand Pallier Bas (GPB)
Si le bit lu est identique au bit précédent + état précédent bas --> On lance un Petit Pallier Haut (PPH)
Si le bit lu est identique au bit précédent + état précédent Haut --> On lance un Petit Pallier Bas (PPB)

A chaque fois, on change d'état ( Haut ou Bas).

-- "ca" : c'est le bit à lire
-- La durée du timer "Timer0" : La durée du palier défnini en #define
-- La sortie courante(MA_SORTIE) : L'état précédent (Haut ou Bas)
-- La sortie future : La Trame qui réuni toutes les conditions précitées (image ci-joint)

Programme modifié :

Code:

#include <p18cxxx.h>

#ifndef	_XTAL_FREQ
#define	_XTAL_FREQ	4000000  /*4MHz*/

#define MA_SORTIE LATBbits.LATB0 // Le bit 0 du port B en sortie

#define	GPH 0x69 	// Grand Pallier Haut -- Durée = 1,2 ms
#define	GPB 0x11 	// Grand Pallier Bas -- Durée = 1,9 ms
#define	PPH 0x9B 	// Petit Pallier Haut -- Durée = 800 Us
#define	PPB 0xCD	// Petit Pallier Bas -- Durée = 400 Us

//#pragma config SOSCSEL = DIG      /*  Digital (SCLKI) mode*/
#pragma config FOSC = XT 
#pragma config PLLCFG = ON 
#pragma config PWRTEN = OFF  
#pragma config WDTEN = OFF 



unsigned long serie[2] = {0b01010101010100000001,0b10110101000101001110}; // Les deux séries de bit à lire (On teste la première - serie(0))

unsigned long ca;
/*******************************/
void Int_Hight(void);

#pragma code HighVector=0x08
void HighVector(void)
{
_asm goto Int_Hight _endasm
}
/*oooooooooooooooooooooooooooooooooooo*/
#pragma code LowVector=0x18
void LowVector(void)
{

}
#pragma code

#pragma interrupt Int_Hight
void Int_Hight(void){       // L'interrution
if(INTCONbits.TMR0IF){ /*==1*/
INTCONbits.TMR0IF=0; /*: Clr Overflow Interrupt Flag bit*/

LATB =(LATB & 0xFE)|(ca & 0x0001);   //Lecture de la série des bits par le bit 0 du port B
ca = ca >> 1;              // Registre à décalage --> Décalage des bit  
//MA_SORTIE = !MA_SORTIE;	   // Inversion d'état

				if 		(((ca&0x0001) == 1) && (MA_SORTIE == 1)) TMR0L = GPH; // Si le bit = "1" et l'état précédent est Haut --> Le Timer0 envoie GPH
				else if (((ca&0x0001) == 1) && (MA_SORTIE == 0)) TMR0L = GPB; // Si le bit = "1" et l'état précédent est Bas --> Le Timer0 envoie = GPH
				else if (((ca&0x0001) == 0) && (MA_SORTIE == 1)) TMR0L = PPH; // Si le bit = "0" et l'état précédent est Haut --> Le Timer0 envoie = GPH
				else if (((ca&0x0001) == 0) && (MA_SORTIE == 0)) TMR0L = PPB; // Si le bit = "0" et l'état précédent est Bas --> Le Timer0 envoie = GPH
			
				}
				}
void main (void){
    TRISBbits.TRISB0 = 0; 
	MA_SORTIE = 1;  // Sortir le bit 0 du port B

	/**********************TIMER 0 INIT*******************************************/
	T0CONbits.TMR0ON=1; /*: Timer0 On/Off Control bit
						1 = Enables Timer0*/
						
	T0CONbits.T08BIT=1; /*: Timer0 8-Bit/16-Bit Control bit
						1 = Timer0 is configured as an 8-bit timer/counter
						0 = Timer0 is configured as a 16-bit timer/counter*/
						
	T0CONbits.T0CS=0; 	/*Timer0 Clock Source Select bit
						1 = Transition on T0CKI pin input edge
						0 = Interna clock (FOSC/4)*/
					
	T0CONbits.PSA=0; 	/* Timer0 Prescaler Assignment bit
						1 = Timer0 prescaler is not assigned; Timer0 clock input bypasses the prescaler
						0 = Timer0 prescaler is assigned; Timer0 clock input comes from the prescaler output*/
					
	T0CONbits.T0PS=0x100;	/*<2:0>: Timer0 Prescaler Select bits
						111 = 1:256 Prescale value
						110 = 1:128 Prescale value
						101 = 1:64 Prescale value
						100 = 1:32 Prescale value
						011 = 1:16 Prescale value
						010 = 1:8 Prescale value
						001 = 1:4 Prescale value
						000 = 1:2 Prescale value*/
	/*******************************************************************************/
	
	INTCON2bits.TMR0IP=1; /*TMR0 Overflow Interrupt Priority bit
						1 = High priority
						0 = Low priority*/
						
	INTCONbits.TMR0IF=0; /*: TMR0 Overflow Interrupt Flag bit
						1 = TMR0 register has overflowed (must be cleared in software)
						0 = TMR0 register did not overflow*/
						
	INTCONbits.TMR0IE=1; /*: TMR0 Overflow Interrupt Enable bit
						1 = Enables the TMR0 overflow interrupt
						0 = Disables the TMR0 overflow interrupt*/
						
	RCONbits.IPEN = 1; /*When IPEN = 1:
						1 = Enables all high-priority interrupts
						0 = Disables all interrupts*/
						
	INTCONbits.GIE=1;	/*Global Interrupt Enable bit
						When IPEN = 0:
						1 = Enables all unmasked interrupts
						0 = Disables all interrupts*/
						
	TMR0L=0x00;			/*Timer0 Register Low Byte*/
	ca = serie[0]; // Lecture de la première série de bit indiquée dans le tableau serie 
	while(1){
	
	/**************************************/
	
	}
}

**sdec25** · 24/08/2010, 11h54

Envoyé par electron22

J'ai modifié le programme comme tu m'as indiqué, mais je ne sais par quoi je dois remplacer MA_SORTIE qui est un bit, donc je l'ai laissé en LATB, merci

L'avantage de travailler au niveau du bit est la simplicité :
Pour modifier l'état d'un bit : bit = 1; ou bit = 0;

Tu trouves vraiment que "LATB =(LATB & 0xFE)|(ca & 0x0001);" c'est plus simple ?

-- "ca" : c'est le bit à lire

attention, "ca" est l'ensemble des bits à lire. (ca&0x0001) est le bit à lire.

A chaque fois, on change d'état ( Haut ou Bas).

donc MA_SORTIE = !MA_SORTIE (mais à faire à la fin puisque dans les tests, MA_SORTIE est l'état précédent).

L'instruction "LATB =(LATB & 0xFE)|(ca & 0x0001);" est à supprimer car elle ne correspond à rien.

Sinon il y a une condition que je ne vois pas dans tes tests : "Si le bit lu est différent au bit précédent". Qu'est-ce que ça signifie ?

invitec8c13b53 · 24/08/2010, 15h01

Le programme maintenant génère les Palliers avec les durée correctement, mais au lieu de prendre comme condition "la comparaison avec le bit précédent" il le fait par rapport à la condition " si le bit est 1 ou 0".

Je ne parviens pas à savoir comment avoir la valeur du bit précédent pour le mettre à la place de la condition "bit à 1 ou 0".

En ce qui concerne l'état, vu le nouvel emplacement de "MA_SORTIE = !MA_SORTIE" dans le programme, ça me donne l'état actuel et je crois que c'est correcte aussi de raisonner sur l'état actuel sans tenir compte l'état précédent, donc quand c'est : 1-> Haut, 0-> Bas.

Simulation ci joint.

Nouveau programme :

Code:

unsigned long serie[2] = {0b11111111111000000000000111111111,0b10110101000101001110}; // Les deux séries de bit à lire (On teste la première - serie(0))

unsigned long ca;
/*******************************/
void Int_Hight(void);

#pragma code HighVector=0x08
void HighVector(void)
{
_asm goto Int_Hight _endasm
}
/*oooooooooooooooooooooooooooooooooooo*/
#pragma code LowVector=0x18
void LowVector(void)
{

}
#pragma code

#pragma interrupt Int_Hight
void Int_Hight(void){       // L'interrution
if(INTCONbits.TMR0IF){ /*==1*/
INTCONbits.TMR0IF=0; /*: Clr Overflow Interrupt Flag bit*/

//LATB =(LATB & 0xFE)|(ca & 0x0001);   //Lecture de la série des bits par le bit 0 du port B
ca = ca >> 1;              // Registre à décalage --> Décalage des bit  
MA_SORTIE = !MA_SORTIE;	   // Inversion d'état

				if 		(((ca&0x0001) == 1) && (MA_SORTIE == 1)) TMR0L = GPB; // Si le bit = "1" et l'état précédent est Haut --> Le Timer0 envoie GPH
				else if (((ca&0x0001) == 1) && (MA_SORTIE == 0)) TMR0L = GPH; // Si le bit = "1" et l'état précédent est Bas --> Le Timer0 envoie = GPH
				else if (((ca&0x0001) == 0) && (MA_SORTIE == 1)) TMR0L = PPB; // Si le bit = "0" et l'état précédent est Haut --> Le Timer0 envoie = GPH
				else if (((ca&0x0001) == 0) && (MA_SORTIE == 0)) TMR0L = PPH; // Si le bit = "0" et l'état précédent est Bas --> Le Timer0 envoie = GPH
			
				}
				}
void main (void){
    TRISBbits.TRISB0 = 0; 
	MA_SORTIE = 1;  // Sortir le bit 0 du port B

**Jack** · 24/08/2010, 15h32

Je ne parviens pas à savoir comment avoir la valeur du bit précédent pour le mettre à la place de la condition "bit à 1 ou 0".

Il suffit de le mémoriser ...

A+

invitec8c13b53 · 24/08/2010, 16h04

donc il faut utiliser un registre pour le mémoriser, peux tu m'éclaircir un peu la procédure.
merci

invite7a49d0d5 · 24/08/2010, 17h07

Salut,

au plus simple:

tu crée une variable "ancienbit"...

qui sauvegarde l'état du précédent bit...

vede
;O]
______________
...

**Jack** · 24/08/2010, 17h47

Un registre

je te rappelle qu'une variable est faite pour mémoriser des valeurs.

A+

invitec8c13b53 · 25/08/2010, 06h53

Salut,

J'ai défini comme vous m'avez demandé la variable "e" qui mémorise l'ancien l'état (ne marche pas comme voulu)

La variable "a" qui mémorise le bit précédent, mais la simulation ne correspond pas au raisonnement :

Code:

else if ((ca&0x0001 == a ) && (c == 0)) TMR0L = GPH; // Si : bit = "1" et l'état est Bas --> Le Timer0 envoie = GPH
				else if ((ca&0x0001 != a ) && (c == 1)) TMR0L = PPB;

simulation+programme ci joint

Le programme modifié :

Code:

unsigned long serie[2] = {0b101010101010101010111,0b10110101000101001110}; // Les deux séries de bit à lire (On teste la première - serie(0))

unsigned long ca;
unsigned long a;
unsigned long e;
/*******************************/
void Int_Hight(void);

#pragma code HighVector=0x08
void HighVector(void)
{
_asm goto Int_Hight _endasm
}
/*oooooooooooooooooooooooooooooooooooo*/
#pragma code LowVector=0x18
void LowVector(void)
{

}
#pragma code

#pragma interrupt Int_Hight
void Int_Hight(void){       // L'interrution
if(INTCONbits.TMR0IF){ /*==1*/
INTCONbits.TMR0IF=0; /*: Clr Overflow Interrupt Flag bit*/

//LATB =(LATB & 0xFE)|(ca & 0x0001);   //Lecture de la série des bits par le bit 0 du port B

ca = ca >> 1;       // Registre à décalage --> Décalage des bit 1 par 1
MA_SORTIE = !MA_SORTIE;   // Inversion d'état

				if 		((ca&0x0001 == a ) && (e == 1)) TMR0L = GPB; // Si : bit = "1" et l'état est Haut --> Le Timer0 envoie GPH
				else if ((ca&0x0001 == a ) && (e == 0)) TMR0L = GPH; // Si : bit = "1" et l'état est Bas --> Le Timer0 envoie = GPH
				else if ((ca&0x0001 != a ) && (e == 1)) TMR0L = PPB; // Si : bit = "0" et l'état est Haut --> Le Timer0 envoie = GPH
				else if ((ca&0x0001 != a ) && (e == 0)) TMR0L = PPH; // Si : bit = "0" et l'état est Bas --> Le Timer0 envoie = GPH
			
				a = ca&0x0001;
				e = MA_SORTIE;
				}
				}
void main (void){
    TRISBbits.TRISB0 = 0;

**sdec25** · 25/08/2010, 12h17

2 remarques :
Tu utilises un processeur 8 bits, qui ne sait faire des calculs que sur 8 bits (1 octet), alors pourquoi utiliser des unsigned long (4 octets) pour stocker 1 seul bit ? Comme il n'y a pas de variable bit, tu peux utiliser le type char, ça suffit.

pourquoi mémoriser l'ancien état (e = MA_SORTIE) alors que MA_SORTIE change à chaque fois ? Si on est à l'état haut c'est qu'on était à l'état bas la fois précédente.

Je ne vois plus d'erreur de syntaxe dans ton programme, si ça ne fonctionne pas c'est que ton algo n'est pas bon.
Exécute le programme pas à pas (soit sur papier, soit avec le debugger) et vérifie que les valeurs des différentes variables sont cohérentes avec l'état (global) courant de ton programme.

Et fais attention aux variables non initialisées. Comme tu prends en compte l'état précédent dans ton calcul, que doit-on faire la première fois ?

invitec8c13b53 · 25/08/2010, 13h27

J'ai enlevé l'état précédent "e" et j'ai gardé l'état actuel de "MA_SORTIE == 1".

Quand je change cela, je remarque que cette instruction n'est pas lu par le simulateur :

Code:

else if ((ca&0x0001 != a )  && (MA_SORTIE == 1)) TMR0L = PPH;

La sortie doit être à 0 au début, c'est la lecture du premier bit et le changement d'état qui vont lancer un état Haut, mais ça ne sera pas comparable avec le bit précédent puisqu'il n y est pas. le cahier de charge impose un Grand Pallier Haut au début si comme si on a commencé par l'envoie d'un bit "1" de START, je dois faire une condition pour cela.

Code:

unsigned long serie[2] = {0b101010101010101010111,0b10110101000101001110}; // Les deux séries de bit à lire (On teste la première - serie(0))

unsigned long ca;
unsigned char a;

/*******************************/
void Int_Hight(void);

#pragma code HighVector=0x08
void HighVector(void)
{
_asm goto Int_Hight _endasm
}
/*oooooooooooooooooooooooooooooooooooo*/
#pragma code LowVector=0x18
void LowVector(void)
{

}
#pragma code

#pragma interrupt Int_Hight
void Int_Hight(void){       // L'interrution
if(INTCONbits.TMR0IF){ /*==1*/
INTCONbits.TMR0IF=0; /*: Clr Overflow Interrupt Flag bit*/

//LATB =(LATB & 0xFE)|(ca & 0x0001);   //Lecture de la série des bits par le bit 0 du port B

ca = ca >> 1;       // Registre à décalage --> Décalage des bit 1 par 1
MA_SORTIE = !MA_SORTIE;   // Inversion d'état

				if 		((ca&0x0001 == a ) && (MA_SORTIE == 1)) TMR0L = GPH; // Si : bit = "1" et l'état est Haut --> Le Timer0 envoie GPH
				else if ((ca&0x0001 == a ) && (MA_SORTIE == 0)) TMR0L = GPB; // Si : bit = "1" et l'état est Bas --> Le Timer0 envoie = GPH
				else if ((ca&0x0001 != a ) && (MA_SORTIE == 1)) TMR0L = PPH; // Si : bit = "0" et l'état est Haut --> Le Timer0 envoie = GPH
				else if ((ca&0x0001 != a ) && (MA_SORTIE == 0)) TMR0L = PPB; // Si : bit = "0" et l'état est Bas --> Le Timer0 envoie = GPH
			
				a = ca&0x0001;
								}
				}
void main (void){
    TRISBbits.TRISB0 = 0;

**sdec25** · 25/08/2010, 17h34

Quand je change cela, je remarque que cette instruction n'est pas lu par le simulateur :

Elle n'est probablement pas lue parce que "else" n'est exécuté que si la condition if précédente n'est pas vraie.
Si ton programme ne fonctionne toujours pas, quel est le problème ?

lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Discussions similaires

[C] - Passage de mots de n bits en mode de 8 bits

[C] - Manipulation des bits

récupération du mot de 8 bits sur 4 bits

Lire un mot 8 bits

Convertir 12 bits série en 7 bits paralléle avec un HC11 ?