lire des bits

**electron22** · 17/08/2010, 23h32

Bonjour,

J'ai une série de bit "0100011010101010" par exemple que j'aimerais lire, merci de m'indiquer quelle fonction pourrait être efficace pour ce fait.

j'utilise le PIC 18F sous MPLAB.

Merci beaucoup

**Jack** · 18/08/2010, 00h06

J'ai une série de bit "0100011010101010"

Ah? Et d'où viennent-ils? Liaison série, mot mémoire, etc?

Dans quel langage programmes-tu?

Bref, ça manque de détail tout ça!

A+

**electron22** · 18/08/2010, 00h14

en fait, cette série est une donnée (inclut dans mon programme), le but est de lire bit par bit, pour ensuite commander le bit de sortie du pic qui change en fonction du bit 0 ou 1.

Je programme en langage C sous MPLAB c18 (pic 18f)

**electron22** · 18/08/2010, 00h38

La lecture doit s'effectuer en série. En effet mon programme en C et (pic 18 f), il doit générer en fonction de l'état (Haut ou Bas) et le bit (1 ou 0) une durée sur le bit0 du portB (LATB 0x01) en sortie.

Les règles :

Le passage du bit 1 à 0 ou de 0 à 1 --> Déclencher une Grande Durée:GP
Le passage du bit 1 à 1 ou de 0 à 0 --> Déclencher une Petite Durée:PP

En tous les cas, on change d'état ( Haut ou Bas).

Les 4 durées possibles :

Grand Palier Haut --> GPH
Grand Palier Bas --> GPB
Petit Palier Haut --> PPH
Petit Palier Bas--> PPB

Mon programme génère les durées avec succès en fonction de la variable i qui va de 0 à 3.

Maintenant je suis bloqué car ne sais pas comment faire pour pouvoir stocker la série de bits, pour ensuite les lire et générer en fonction du bit que j'ai, la durée correspondante.

Merci pour vos aides.

Le programme :

void Int_Hight(void);

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

}
#pragma code

#pragma interrupt Int_Hight
void Int_Hight(void){
static unsigned char i = 0;

if(INTCONbits.TMR0IF){ /*==1*/
INTCONbits.TMR0IF=0; /*: Clr Overflow Interrupt Flag bit*/

LATB=LATB^0x01;

TMR0L = var[i];

if (i <= 4) i++;
else i = 0;

}

}
void main (void){

TRISB=0b11111110; /* Bit 0 out*/

A voir en vidéo sur Futura · Aujourd'hui

**Jack** · 18/08/2010, 08h57

Pour présenter du code, utilise la balise "code" qui permet de garder l'indentation de ton source et ainsi faciliter sa lecture.

Maintenant je suis bloqué car ne sais pas comment faire pour pouvoir stocker la série de bits, pour ensuite les lire et générer en fonction du bit que j'ai, la durée correspondante.

Je ne connais pas trop les pics, mais je peux t'aider pour le reste.

Tu oublies de préciser combien de bits tu dois stocker au maximum. S'il n'y en a pas trop, tu peux les stocker dans un entier long non signé par exemple et utiliser l'opérateur de décalage pour les insérer ou les lire.

Si la série de bits est trop longue, tu pourras éventuellement les stocker dans un tableau, dynamiquement ou non. Le problème, c'est que ça va consommer beaucoup de ram pour pas grand chose.

Sinon, il reste le bit field qui est un type de structure particulier permettant de travailler au niveau du bit en C, ceci si la taille de la série de bits est connue.

A+

**alainav1** · 18/08/2010, 09h09

bonjour,
une suggestion
c'est du basic mais traduire en C ça doit pas etre trop difficile .
soit a extraire le bit 4 de reg1
reg1 et reg2 sont des bytes

reg2 = reg1 And %00010000
If reg2 >0 Then
porta.1 = 1
Else
porta.1 = 0
Endif
cordialement
Alai

***Baby*** · 18/08/2010, 10h04

Salut,

Je comprend rien à ton histoire.

D'où vient ta série de bit "0100011010101010". Elle est stocker où ??

Une fois que tu auras répondu à cela, tous deviendra plus simple.

@+

**electron22** · 18/08/2010, 10h18

Cette série est une donnée que je connais, et elle doit être déclarée dans le programme,

exemple :

unsigned long A1 = 0b1011000000100001000;
unsigned long A2 = 0b1011010100010011010;
unsigned long A3 = 0b1011011100110101010;

On doit choisir à chaque fois l'une de ces trois série, les lire bit par bit, puis lancer les durée en sortie.
Merci

**electron22** · 18/08/2010, 10h25

la taille de la série est de 16 ou 24 bits

**electron22** · 18/08/2010, 13h32

Pour pouvoir lire chaque bit de la série, j'ai pensé au registre à décalage et ça me donne des erreurs, merci de m'aider
erreur attaché en image

"#pragma code

#pragma interrupt Int_Hight
void Int_Hight(void){
static unsigned char i = 0;

/*-----------Tableau des 2 durées : GPH=0x69, GPB=0x11,--------*/

unsigned char var[2] = {0x69,0x11};

/*-----------------------Tableaux des séries-------------------*/

unsigned long serie[4] = {0b0111001011000000100,0b10110 101000101001110,0b101101010001 0011010,0b10101100110101001100 1010};

/*----------------------Registre à décalage--------------------*/

unsigned long a;

a = serie [0];
if(INTCONbits.TMR0IF){ /*==1*/
INTCONbits.TMR0IF=0; /*: Clr Overflow Interrupt Flag bit*/

LATB=LATB^0x01;

TMR0L = var[i];

if (i <= 2) i++;
else i = 0;

bit = a & 0x01;
a = a >> 1;

if (bit = 0) { j = 3;}
else j = 2;

}

}
void main (void){

TRISB=0b11111110; /* Bit 0 out*/"

**electron22** · 18/08/2010, 13h34

Code:

#pragma code

#pragma interrupt Int_Hight
void Int_Hight(void){
static unsigned char i = 0;

/*-----------Tableau des 2 durées : GPH=0x69, GPB=0x11,--------*/

unsigned char var[2] = {0x69,0x11}; 

/*-----------------------Tableaux des séries-------------------*/

unsigned long serie[4] = {0b0111001011000000100,0b10110101000101001110,0b1011010100010011010,0b101011001101010011001010};

/*----------------------Registre à décalage--------------------*/

unsigned long a; 

a = serie [0];
if(INTCONbits.TMR0IF){ /*==1*/
INTCONbits.TMR0IF=0; /*: Clr Overflow Interrupt Flag bit*/

LATB=LATB^0x01;

TMR0L = var[i];

if    (i <= 2) i++;
else  i = 0;

bit = a & 0x01;
a = a >> 1;

if (bit = 0) { j = 3;}
else j = 2;


}

}
void main (void){
	
	TRISB=0b11111110; /* Bit 0 out*/

**electron22** · 18/08/2010, 14h14

Avez vous une idée?

**Jack** · 18/08/2010, 16h04

Que d'erreurs !

Tu déclares un tableau de 2 char:

Code:

unsigned char var[2] = {0x69,0x11};

et tu fais monter ton index i jusqu'à 3 alors que la valeur maxi de i devrait être 1:

Code:

if    (i <= 2) i++;

Ensuite, la tarte à la crème du langage C: confusion entre les opérateurs = et == :

Code:

if (bit = 0)

ensuite au niveau des messages d'erreur, ça me semble limpide: la variable bit n'a pas été déclarée. Pareil pour j.

etc...

A+

**electron22** · 18/08/2010, 17h04

le programme est compilé correctement.
je n'ai pas pu relier les deux boucle i et j, i qui incrémente la durée à déclencher, et j qui pointe les bit dans la série.
voici le nouveau code, merci de m'indiquer où est l'erreur.
simulation ci joint
Merci

Code:

#pragma code

#pragma interrupt Int_Hight
void Int_Hight(void){
static unsigned char i = 0;
static unsigned char j = 0;
char bit;

/*-----------Tableau des 2 durées : GPH=0x69, GPB=0x11,--------*/

unsigned char var[2] = {0xFF,0x01}; 

/*-----------------------Tableaux des séries-------------------*/

unsigned long serie[2] = {0b0111001011000000100,0b10110101000101001110};

/*----------------------Registre à décalage--------------------*/

unsigned long a; 

a = serie [0];
if(INTCONbits.TMR0IF){ /*==1*/
INTCONbits.TMR0IF=0; /*: Clr Overflow Interrupt Flag bit*/

LATB=LATB^0x01;

TMR0L = var[i];

bit = a & 0x01;
a = a >> 1;
if (bit == 0) { j = 1;}
else j = 2;

if    (i <= 1) i++;
else  i = 0;






}

}
void main (void){
	
	TRISB=0b11111110; /* Bit 0 out*/

**electron22** · 18/08/2010, 17h07

la simulation ci joint n'est pas correcte car elle est périodique, alors qu'on doit observer la variation de la durée en fonction du bit lu.

**Jack** · 18/08/2010, 17h45

tu n'as pas bien compris ce que je t'ai dit précédemment:

Code:

if    (i <= 1) i++;
else  i = 0;

Que se passe-t-il si i vaut i avant le if? Eh bien i vaudra 2 après le if. Et à la prochaine interruption tu vas exécuter:

Code:

TMR0L = var[i];

Je ne sais pas ce qu'est TMROL, mais une chose est certaine, c'est que var[2] n'existe pas. Heureusement que tu es en lecture car autrement tu aurais un bel écrasement de données, assez difficile à débusquer.

A+

**o3k** · 18/08/2010, 18h27

C'est pas pour du codage type manchester par hasard?

Code:

#define high 1
#define low 0
unsinged int serie = 0b0110100100110101;
unsigned char i,j=0;
//j = valeur test bit à n-1

for(i=0;i<16;i++)
{
   if((serie>>i)&0x0001)
   {
        if(j) etatHaut_long();
        else etatHaut_court();
        j=1;
    }
    else
    {
         if(j) etatBas_court();
         else etatBas_long();
         j = 0;
    }
}

**Jack** · 18/08/2010, 22h15

le manchester ne module pas en largeur.

A+

**electron22** · 23/08/2010, 02h05

Par le programme ci dessous, je dois lire bit par bit d'une série et lancer une durée selon la conditions envisagée.Les conditions sont les suivantes :

Changement de bit + état précédent bas --> Grand Pallier Haut (GPH)
Changement de bit + état précédent haut --> Grand Pallier Bas (GPB)
Même bit + état précédent bas --> Petit Pallier Haut (PPH)
Même bit + état précédent Haut --> Petit Pallier Bas (PPB)

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

J'ai traduit le bit "0" par ca = 0x000 et le bit "1" par ca = 0x001.
Ensuite, l'état précédent niveau bas par le LATB = 0x01 et niveau haut par le LATB = 0x00.

Quand j'ai simuler la partie lecture des bits, qui en fonction du bit 0 ou 1 lance un palier état haut ou bas sans tenir compte les durées, ça fonctionne correctement et ça me donne la simulation ci joint.

Et quand, j'ai intégrer les durées et les conditions de l'état et bit pécédent ça n'a pas marché.

Merci de m'aider

Le programme :

Code:

#include <p18cxxx.h>

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

#define	GPH 0x69
#define	GPB 0x00
#define	PPH 0x9B
#define	PPB 0xCD

//#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] = {0b0101010101010001001101,0b10110101000101001110};

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

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

}
#pragma code

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

LATB =(LATB & 0xFE)|(ca & 0x0001); //& 0x0001);
ca = ca >> 1;

LATB = LATB^0x01;

				if      ((ca = 0x001) && (LATB = 0x01)) TMR0L = GPH;
				else if ((ca = 0x001) && (LATB = 0x00)) TMR0L = GPB;
				else if ((ca = 0x000) && (LATB = 0x01)) TMR0L = PPH;
				else if ((ca = 0x000) && (LATB = 0x00)) TMR0L = PPB;
					}
				}
void main (void){
	
	TRISB=0b11111110; /* Bit 0 out*/

	/**********************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];
	while(1){
	
	/**************************************/
	
	}
}

**Jack** · 23/08/2010, 09h20

Tu viens d'ouvrir une nouvelle discussion qui fait suite à tes précédentes. Quel est l'intérêt de s'éparpiller ainsi?
C'est d'autant plus frustrant que je t'avais fait des propositions de modifications dans le précédent fil et que tu n'y as pas répondu directement.

J'ai donc fusionné tes 2 derniers sujets.

**sdec25** · 23/08/2010, 12h11

Bonjour,

Et quand, j'ai intégrer les durées et les conditions de l'état et bit pécédent ça n'a pas marché.

En général quand on demande de l'aide sur un programme un minimum compliqué on fait quelques efforts d'analyse pour cibler le + précisément le problème. Personnellement je ne vais pas compiler ton programmer pour t'aider.

Dans ton cas, il y a de grossières erreurs qui t'ont déjà été signalées, à toi de relire les posts et de faire les corrections en conséquence.

Concernant le forme : ton programme est difficilement lisible : aucun commentaire, nom des variables pas explicites.
Peux-tu expliquer dans ton programme ce que font les différentes instructions ?
Et pourquoi tester le port LATB en entier alors que tu travailles sur un seul bit de ce port ?
Pour travailler au niveau du bit :

Code:

LATBbits.LATBx = 1;

ou mieux :

Code:

#define MA_SORTIE LATBbits.LATBx
//...
MA_SORTIE = 1;

**electron22** · 23/08/2010, 13h46

Jack :
Merci, j'aurai du rester dans le premier sujet, j'avais pris tes conseils au sérieux et cela est figuré dans le programme car j'ai enlevé les durée qui étaient déclaré en tableau var[i] et les boucles i et j et je les ai déclaré en #define.

sdec25 :
J'ai commenté les lignes importantes du code.
Ce programme est compilé correctement.
Le problème c'est que la simulation qui ne correspond à mon raisonnement, je ne sais pas si j'ai traduit mon raisonnement expliqué dans mon dernier commentaire en langage C correctement, c'est que la sortie ne bouge pas et ça donne un "0" sans changer d'état.

J'ai modifier la ligne qui déclare la sortie bit 0 du PORTB que tu m'as indiqué, merci

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 
#define	GPB 0x00 	// Grand Pallier Bas
#define	PPH 0x9B 	// Petit Pallier Haut 
#define	PPB 0xCD	// Petit Pallier Bas

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

//TRISB.RB0 = 0; // La sortie est le bit 0 du port B 

unsigned long serie[2] = {0b0101010101010001001101,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  

LATB = LATB^0x01;   // Changement d'état à chaque lecture de bit

				if      ((ca = 0x001) && (LATB = 0x01)) TMR0L = GPH; // Si le bit = "1" et l'état précédent est Haut --> Le Timer0 envoie GPH
				else if ((ca = 0x001) && (LATB = 0x00)) TMR0L = GPB; // Si le bit = "1" et l'état précédent est Bas --> Le Timer0 envoie = GPH
				else if ((ca = 0x000) && (LATB = 0x01)) TMR0L = PPH; // Si le bit = "0" et l'état précédent est Haut --> Le Timer0 envoie = GPH
				else if ((ca = 0x000) && (LATB = 0x00)) TMR0L = PPB; // Si le bit = "0" et l'état précédent est Bas --> Le Timer0 envoie = GPH
					}
				}
void main (void){
	
	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){
	
	/**************************************/
	
	}
}

invite7a49d0d5 · 23/08/2010, 13h53

Salut,

est ce que c'est normal que cette ligne :

//TRISB.RB0 = 0; // La sortie est le bit 0 du port B

soit en commentaire?

et "en dehors" du "main()"...

vede
;O]
_____________
...

**electron22** · 23/08/2010, 14h03

justement, je l'ai commenté par ce que ça me donnait des erreurs et même si je la met dans le main ça marche pas, le fait de déclarer LATB ca veut dire la sortie, je crois ce n'est pas la peine d'écrire TRISB.RB0 = 0;
merci

invite7a49d0d5 · 23/08/2010, 14h09

re ;O]

je ne "crois" pas que LATB suffise à "mettre" PORTB en sorties...

essayes avec: TRISB=0; au début du "main"...

**electron22** · 23/08/2010, 14h27

OK c'est modifié, en effet, je voulais faire ce que m'a dit "sdec25"; est de ne pas activer tout le port pour s'en intéresser d'une partie, je veux pas mettre tout le port B en sortie juste par ce que je suis intéressé par mettre le bit 0 du port B . c'est pour ca j'ai mit "TRISB.RB0 = 0;"
Sinon ça marche comme ça et ça me gêne pas.

Je commence au moins de voir la sortie, mais périodique ce qui veut dire que la procédure des changement des durée n'a pas été pris en compte
image ci joint

**electron22** · 23/08/2010, 14h43

Schéma de la lecture des bits de la série (4 types de palliers) prévu en sortie RB0

**electron22** · 23/08/2010, 15h38

J'aimerais savoir si la ligne ci-dessous traduit ce raisonnement :

Si le bit = "1" et l'état précédent est Haut -- > Le Timer0 déclenche la durée GPH.

if ((ca = 0x001) && (LATB = 0x01)) TMR0L = GPH;

**sdec25** · 23/08/2010, 17h20

Tu as mal compris ce que j'ai dit à propos du LAT :
MA_SORTIE est le bit du LAT qui correspond à la sortie, donc :

Code:

MA_SORTIE = 1;

équivaut à

Code:

LATBbits.LATB0 = 1;

ce qui met la sortie à l'état 1. Faire comme ça ne dispense en rien d'initialiser le port avec le registre TRISA (ou les ports 1 par 1 avec TRISAbits.TRISAx).

Sinon tu manipules encore le registre LATA en entier, pourquoi ne pas utiliser MA_SORTIE partout ?

Code:

MA_SORTIE = 1; // Etat haut
MA_SORTIE = 0; // Etat bas
MA_SORTIE = !MA_SORTIE; // Inversion

Idem pour faire les tests sur l'état actuel de MA_SORTIE.

Sinon, relis le post 13 de Jack, ton erreur y est expliquée.

**electron22** · 23/08/2010, 19h27

J'ai modifié le programme, en fait, la ligne MA_SORTIE = !MA_SORTIE; permet d'inverser tous les états de la série alors que que le but est d'inverser l'état à chaque lecture de bit (l'état ne doit en aucun cas être maintenue).
Sinon j'ai modifié en utilisant que le bit0 du port B.
Le problème est que la durée n'est pas activé ainsi que l'inversion de l'état
simulation ci joint

Le 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] = {0b0101010101010000010,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*/

MA_SORTIE =(MA_SORTIE & 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) && (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) && (MA_SORTIE = 0)) TMR0L = GPB; // Si le bit = "1" et l'état précédent est Bas --> Le Timer0 envoie = GPH
				else if ((ca == 0x0000) && (MA_SORTIE = 1)) TMR0L = PPH; // Si le bit = "0" et l'état précédent est Haut --> Le Timer0 envoie = GPH
				else if ((ca == 0x0000) && (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){
	
	/**************************************/
	
	}
}

lire des bits

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

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

Re : lire des bits

aide langage c + pic

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 ?