PIC18f452 + MCP2200

**paulfjujo** · 06/06/2014, 11h04

tu ne t'en sortira jamais , si tu ne separes pas les problemes..
test seul le PIC uart sur un terminal pour valider le fonctionnement de celui ci...
s'il est correct à 100% ,
tu devras te pencher coté MCP2200 et PC
verifier si il n' y a pas un protocole specifique à respecter .

Dans un systeme tri-partie , il faut trancher.

A toi de jouer, je ne peux plus rien pour toi.

nota: en principe on les colles ensemble les CR LF

Code:

printf("\n\r");

et quelque fois le

Code:

printf("\r\n");

est mieux interpreté

invite56c261eb · 06/06/2014, 14h27

Quand j'écris seulement ceci:

Code:

void Affiche_USART (void)
{
		if  ((seconde==1)&&(received==1))                    // Pour n secondes
	{	
		i=i++;						 //Affichage nb de secondes
		j=i*seconde;
		printf("Compteur = %d\r\n",compteur);
		printf("Seconde =");	
		seconde=0;
  		received=0;
  		Index1=0;
	}
}

J'ai l'affichage de mon compteur qui marche nikel, du feu de dieu!

Code:

Compteur = 00000
Compteur = 00000
Compteur = 00285
Compteur = 01290
Compteur = 02040
Compteur = 04215
Compteur = 04215
Compteur = 02955

Mais il suffit que je rajoute UN affichage simple:

Code:

printf("Compteur = %d\r\n",compteur);
		printf("Seconde =");

Que la le code s'emballe...

Code:

Comp~³º.ê‚j
           SeöË‹•ïžComðvV—= 0
S}¿¹‘ß¯þCompw«É= 0
SåÿË‹ÕßÏCom~»Y].ê‚j
                   SïïondÿNÏComð¾[].ê‚j
                                       Sýûondí¿=

**paulfjujo** · 06/06/2014, 15h28

Ces tests, sont-ils faits avec seulement le PIC <->terminal ou encore via le MCP2200 ?

comment est appelé void Affiche_USART() ?

Bizarre, tu demandes à ecrire (envoi sur USART) juste au moment ou
tu as les 2 interruptions Seconde (timer) et received (Rx Uart) armées en meme temps...
alors qu'il faudrait traiter la reception UART ...
donc en resumé, tu strap l'interruption RX UART.... (pas de traitement sur la trame Cycle..)
et cela ne fait pas du tout avancer le smilblick....

C'est quoi un affichage simple ?

Nota:
pour afficher les secondes il faudrait
ecrire printf("Seconde= %d\r\n",seconde);

Rappel: si ton envoi de trame Cycle ... etc .. est à 1Hz suffisament precis,
donc periode= 1 seconde
tu pourrais eviter le timer1 à 1seconde et te servir du flag received pour
te caler dessus .. pour le compteur
Un seul evenement à 1Hz à traiter ,vaut mieux que 2 ,qui plus est, sont asynchrones...

Désolé, mais cela devient trop changeant pour arriver à te suivre ....apres 62 posts !
tu modifies des parties de code , sans mettre l'environnement ...
et tout devient devinette ou supposition.
poste tout le code à chaque fois. ...

invite56c261eb · 06/06/2014, 15h38

Désolé, je suis tellement dans mon programme que j'explique pas bien les choses...

Voici le code en entier pour y voir plus clair!

Code:

/*********************************************************************************************************
*     Tachymètre (compte-tour) numérique à base de capteur à effet Hall                                  *
*     Quartz 20Mhz         PIC 18F1320                                                                   *
*                                                                                                        *
*     Formule de calcul du timer0 :                                                                      *
*     T = 1/(Fréquence horloge/4) * PRESCALER_registre_T0CON * (65535 - TMR0H&TMR0L)                     *
*     Ce qui donne:                                                                                      *
*     T = 1/(20000000/4)* 128 * (65535-26472) = 1.0000128s												 *
*																										 *
*     Le capteur Hall connecté sur RB0 déclenche une interruption à chaque passage de l'aimant           *
*********************************************************************************************************/

#include <p18f452.h>	 // d?claration SFR pour ICD2
#include <delays.h>	 // d?claration prototype fonctions delay
#include <usart.h>   // pour fonctions UART
#include <string.h>  // pour strmcp
#include <stdio.h>  // pour printf
#include <stdlib.h> // pour atoi
#define	FOREVER	 while(1)

// D?finir des nouveaux types donn?es

typedef unsigned char BYTE;
typedef unsigned int WORD;

// **** configuration du circuit *************

// configuration avec quartz
#pragma config OSC = HS, OSCS = OFF
#pragma config PWRT = OFF, BOR = OFF
#pragma config WDT = OFF
#pragma config CCP2MUX = OFF
#pragma config STVR = ON
#pragma config LVP = OFF
#pragma config DEBUG = ON
#pragma config CP0 = OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF, CPB = OFF, CPD = OFF
#pragma config WRT0 = OFF, WRT1 = OFF, WRT2 = OFF, WRT3 = OFF
#pragma config WRTB = OFF, WRTC = OFF, WRTD = OFF
#pragma config EBTR0 = OFF, EBTR1 = OFF, EBTR2 = OFF, EBTRB = OFF 

// d?finitions LCD


#define LCD_D4	LATBbits.LATB4 // data afficheur bit ? bits
#define LCD_D5	LATBbits.LATB1 // data afficheur bit ? bits
#define LCD_D6	LATBbits.LATB2 // data afficheur bit ? bits
#define LCD_D7	LATBbits.LATB3 // data afficheur bit ? bits

#define LCD_D4_DIR TRISBbits.TRISB4 // data direction afficheur bit ? bits
#define LCD_D5_DIR TRISBbits.TRISB1 // data direction afficheur bit ? bits
#define LCD_D6_DIR TRISBbits.TRISB2 // data direction afficheur bit ? bits
#define LCD_D7_DIR TRISBbits.TRISB3 // data direction afficheur bit ? bits

#define LCD_E	LATAbits.LATA1 // cde afficheur E
//#define LCD_RW	PORTAbits.RA2 // cde afficheur RW
#define LCD_RS	LATAbits.LATA3 // cde afficheur RS


#define LCD_E_DIR TRISAbits.TRISA1 // cde direction afficheur E
//#define LCD_RW_DIR TRISAbits.TRISA2 // cde direction afficheur RW
#define LCD_RS_DIR TRISAbits.TRISA3 // cde direction afficheur RS

#define MAXLEN 40



//*****	variables globales ********************
unsigned char u=0; // caractere incremente pour defilement table de caracteres

//*****	prototypes de fonctions ********************
char k;
unsigned int temp,i,j;
unsigned char rotation_brute;
unsigned short int sequence;

void Init_LCD (void);
void Init_Interrupt (void);
void Init_UART (void);
void Affiche_Compteur (void);
void Affiche_USART (void);

void w_cde_nibble( unsigned char ); // ?crit le quartet fort du char x en mode cde
void w_cde_octet( unsigned char ) ;// ?crit le quartet fort du char x en mode cde puis le quartet faible
void w_data_octet( unsigned char ) ;// ?crit le quartet fort du char x en mode data puis le quartet faible


volatile unsigned int  tour;
volatile unsigned int compteur,seconde;
volatile char buffer[MAXLEN];
volatile int Index1;
volatile int received; // flag reception trame


//sous prog d'int
void Interrupt_B0(void);

// on déclare que lors d'une interruption
#pragma code highVector=0x08
void atInterrupthigh(void)
{
// on doit éxecuter le code de la fonction MyHighInterrupt
_asm GOTO Interrupt_B0 _endasm		
}
#pragma code // retour à la zone de code



// ************************
// ****  Interruptions ****
// ************************
#pragma interrupt Interrupt_B0

void Interrupt_B0(void)
{
  static char C ;
  static char i;

				 if ((INTCONbits.INT0IE==1) && (INTCONbits.INT0IF==1)) 
				{             // Si une interruption du port B0 est détectée
				             tour++;            // incrémenter la variable de tour
				 			 INTCONbits.INT0IF=0;
 				}

                 if ((INTCONbits.TMR0IE==1) && (INTCONbits.TMR0IF ==1))
				{
						    compteur = tour*15;         // Multiplier le nombre de tour/seconde par 60 (pour tour/min)
							TMR0H=0x67;
							TMR0L=0x68;
			                tour=0;
		                    INTCONbits.INT0IE = 1;     // Activer RB0/INT interruption
		                    seconde++;                                      // incrémente le nombre de secondes écoulées
							INTCONbits.TMR0IF = 0;		
 				}

				 //======== SERIAL======================
				if(PIR1bits.RCIF) // si un car arrive
				{
				   C =ReadUSART(); // le lire => RAZ  RCIF
				   if(RCSTAbits.FERR || RCSTAbits.OERR)
				   {
				      RCSTAbits.CREN = 0 ; RCSTAbits.CREN= 1 ;
				    }
				    // while(BusyUSART()); // par sécurité    <- inutilisé
				   // on arme le drapeau received sur reception du CR fin de trame Cycle
				   //  ou si on deborde la taille du buffer de reception
				   if ((C==13) || (i>=MAXLEN-1))
				      {
				         buffer[i]=0; // fin de chaîne si CR
				         Index1=i;
				         i=0;
				         received =1; // arme le flag reception Trame
				       }
				    else
				     {
				        buffer[i]=C ; // stockage
				        i++;
				         Index1++;
				       }
				  }
    }


//fin interruption
//*************	Programme principal *******************/
void main(void)
{

//*****	init variables ****************************
 TRISA=0;                          // PORTA configuré en sortie
 TRISB=0b00000001;                 // PORTB configuré en sortie sauf port0
 TRISC=0b10000000;

 compteur=0;
 temp=0;
 seconde=0;
 tour=0;
 i=0;
 j=0;
 received=0;
 buffer[0]=0;
 Index1=0;
 k=0;

//*****	init Ports ****************************
Init_LCD();
//*****	init Interrupt ****************************
Init_Interrupt();
//*****	init Ports ****************************
Init_UART();
//*****	boucle forever ****************************
FOREVER	 // boucle forever
{

	Affiche_Compteur();               // Fonction d'affichage sur LCD
	Affiche_USART();
}
}
 //***** ecriture des fonctions ****************************
void Init_LCD (void)
{
		// LCD
		ADCON1=0x0E;	 // RA1,2,3 en logique (port A analogique par d?faut)
		LATA=0xF1;	 // RA1,2,3 ? 0 force par le LATCH (pour pas de glitch sur E !)
		PORTA=0xF1;	 // RA1,2,3 ? 0 force par le port (pour pas de glitch sur E !) par securit? ! bof !
		LCD_E_DIR=0;	 // ports en sortie
		// LCD_RW_DIR=0;	 // ports en sortie
		LCD_RS_DIR=0;	 // ports en sortie
		LCD_D4_DIR=0;	 // ports en sortie
		LCD_D5_DIR=0;	 // ports en sortie
		LCD_D6_DIR=0;	 // ports en sortie
		LCD_D7_DIR=0;	 // ports en sortie
		
		//*****	init LCD      ****************************
		w_cde_nibble( 0x30 ); // 3 control
		Delay10KTCYx(150);	// delay = 15mS
		w_cde_nibble( 0x30 ); // 3 control
		Delay10KTCYx(50);	// delay = 5mS
		w_cde_nibble( 0x30 ); // 3 control
		Delay10TCYx(50);	// delay = 100?S
		w_cde_nibble( 0x20 ); // 2 mode 4 bits
		
		w_cde_octet( 0x28 ) ;// fonction set attention si 2F il ecrit en bas a droite ? l'envers avec  4 caracteres de masques (affiche a partir du 5eme car ecrit !)
		  w_cde_octet( 0x0F ) ;// display on
		w_cde_octet( 0x06 ) ;// mode d'entree
		w_cde_octet( 0x01 ) ;// clear display (facultatif)
		w_cde_octet( 0x80 ) ;// DDRAM 0000 (facultatif)
		w_cde_octet( 0x02 ) ;// home (facultatif)
		Delay1KTCYx(250);	// delay = 5mS INDISPENSABLE pour CDE HOME !
		
		w_cde_octet( 0x83 )  ;// 4eme case de la 1ère ligne
		w_data_octet( 0x54 ) ;// T
		w_data_octet( 0x41 ) ;// A
		w_data_octet( 0x43 ) ;// C
		w_data_octet( 0x48 ) ;// H
		w_data_octet( 0x59 ) ;// Y
		w_data_octet( 0x4D ) ;// M
		w_data_octet( 0x45 ) ;// E
		w_data_octet( 0x54 ) ;// T
		w_data_octet( 0x52 ) ;// R
		w_data_octet( 0x45 ) ;// E
		
		w_cde_octet( 0xC0 ) ;// passage seconde ligne
		w_cde_octet( 0xC8 ) ;// passage milieu seconde ligne
		
		w_data_octet( 0x54 ) ;// T
		w_data_octet( 0x52 ) ;// R
		w_data_octet( 0x2F ) ;// /
		w_data_octet( 0x4D ) ;// M
		w_data_octet( 0x4E ) ;// N
}

void Init_Interrupt (void)
{
		T0CON =0b00000110;    		    // Config T0CON pour avoir prescaler 128 et le timer sur 16bits.
		TMR0H=0x67;
		TMR0L=0x68;
		T0CONbits.TMR0ON = 1; 			// Timer 0 marche (debut du comptage)
		RCONbits.IPEN=0;

		INTCON2bits.INTEDG0=1;		    // front montant RB0
		INTCON2bits.TMR0IP=1; 		    // high level
		INTCON2bits.RBIP=0; 

		INTCONbits.PEIE = 1; 
		INTCONbits.INT0IF=0; 
		INTCONbits.INT0IE=1;  			// autorise RB0 interrupt
		INTCONbits.TMR0IE = 1; 			// Autorise TMR0 interrupt
		INTCONbits.PEIE = 1;   			// autorisation des IT des périphériques
		INTCONbits.GIE = 1;    			// active global interrupt
		PIE1bits.RCIE=1;


}

void Init_UART (void)
{
		OpenUSART( USART_TX_INT_OFF &
		USART_RX_INT_ON &
		USART_ASYNCH_MODE &
		USART_EIGHT_BIT &
		USART_CONT_RX &
		USART_BRGH_HIGH,
		129 );
}

void Affiche_Compteur (void) // fonction d'affichage de nombre sur plusieurs digits

	{           
		unsigned int temp;
		unsigned char rotation_brute;
		rotation_brute = (compteur/1000)+48;
		temp = compteur % 1000;
		w_cde_octet( 0xC0 ) ;						   // passage seconde ligne
		w_cde_octet( 0xC3 )	;						   // passage à la 4eme case de la seconde ligne
		w_data_octet( rotation_brute ) ;			   // Afficher les milliers
		rotation_brute = (temp/100)+48;
		temp = temp % 100;
		w_data_octet( rotation_brute ) ;//             // Afficher les centaines
		rotation_brute = (temp/10)+48;
		w_data_octet( rotation_brute ) ;//             // Afficher les dizaines
		rotation_brute = (temp % 10)+48;
		w_data_octet( rotation_brute ) ;//             // Afficher les unités
	
	}

void Affiche_USART (void)
{
		if  ((seconde==1)&&(received==1))                    // Pour n secondes
	{	
		i=i++;						 //Affichage nb de secondes
		j=i*seconde;
		k=fprintf(_H_USART,"Cycle : %s ;                compteur = %05d TR/MN\r\n\r\n",buffer,compteur); 
		seconde=0;
  		received=0;
  		Index1=0;
	}
}


void w_cde_nibble( unsigned char x) // écrit le quartet fort du char x en mode cde
    {
        LCD_RS=0;   // mode cde
        LCD_E=1;    // monte enable
        if (x&0x80)  LCD_D7=1; else LCD_D7=0;   // écriture des bits
        if (x&0x40)  LCD_D6=1; else LCD_D6=0;   // écriture des bits
        if (x&0x20)  LCD_D5=1; else LCD_D5=0;   // écriture des bits
        if (x&0x10)  LCD_D4=1; else LCD_D4=0;   // écriture des bits
        LCD_E=0;    // descends enable
        Delay10TCYx(50); // delay = 100µS
    }


void w_cde_octet( unsigned char x) // écrit le quartet fort du char x en mode cde puis le quartet faible
    {
        LCD_RS=0;   // mode cde
        LCD_E=1;    // monte enable
        if (x&0x80)  LCD_D7=1; else LCD_D7=0;   // écriture des bits
        if (x&0x40)  LCD_D6=1; else LCD_D6=0;   // écriture des bits
        if (x&0x20)  LCD_D5=1; else LCD_D5=0;   // écriture des bits
        if (x&0x10)  LCD_D4=1; else LCD_D4=0;   // écriture des bits
        LCD_E=0;    // descends enable
        Delay10TCYx(5); // delay = 10µS
        LCD_E=1;    // monte enable
        if (x&0x08)  LCD_D7=1; else LCD_D7=0;   // écriture des bits
        if (x&0x04)  LCD_D6=1; else LCD_D6=0;   // écriture des bits
        if (x&0x02)  LCD_D5=1; else LCD_D5=0;   // écriture des bits
        if (x&0x01)  LCD_D4=1; else LCD_D4=0;   // écriture des bits
        LCD_E=0;    // descends enable
        Delay10TCYx(50); // delay = 100µS
    }

void w_data_octet( unsigned char x ) // écrit le quartet fort du char x en mode data puis le quartet faible

    {
        LCD_RS=1;   // mode data
        LCD_E=1;    // monte enable
        if (x&0x80)  LCD_D7=1; else LCD_D7=0;   // écriture des bits
        if (x&0x40)  LCD_D6=1; else LCD_D6=0;   // écriture des bits
        if (x&0x20)  LCD_D5=1; else LCD_D5=0;   // écriture des bits
        if (x&0x10)  LCD_D4=1; else LCD_D4=0;   // écriture des bits
        LCD_E=0;    // descends enable
        Delay10TCYx(5); // delay = 10µS
        LCD_E=1;    // monte enable
        if (x&0x08)  LCD_D7=1; else LCD_D7=0;   // écriture des bits
        if (x&0x04)  LCD_D6=1; else LCD_D6=0;   // écriture des bits
        if (x&0x02)  LCD_D5=1; else LCD_D5=0;   // écriture des bits
        if (x&0x01)  LCD_D4=1; else LCD_D4=0;   // écriture des bits
        LCD_E=0;    // descends enable
        Delay10TCYx(50); // delay = 100µS
    }

En ce moment même, je pense que je ne suis pas loin avec cet affichage:

Code:

k=fprintf(_H_USART,"Cycle : %s ;                compteur = %05d TR/MN\r\n\r\n",buffer,compteur);

Mais si je le mets comme ceci, j'ai le Cycle Analyst mais pas le compteur où l'affichage est mauvais.
En revanche, si je change le %05d par %d, j'ai le compteur qui est bon, mais plus le Cycle. Je n'y comprends plus rien je crois qu'à force je m'embrouille et je me perds tout seul :/

**paulfjujo** · 06/06/2014, 15h58

dans l'IT timer tu incrementes déja seconde

essaie de traiter uniquement l'IT UART , les secondes sont deja traitées dans l'IT timer
et le compteur dans l'IT RB0

Code:

void Affiche_USART (void)
{
      if  (received==1))                    // Pour n secondes
	{	
	// attention au / dans le fprintf	
	k=fprintf(_H_USART,"Cycle : %s ;    compteur = %05d TR_MN      seconde=%5d \r\n\r\n",buffer,compteur,seconde); 
	received=0;
  	Index1=0;
	}
}

invite56c261eb · 06/06/2014, 16h08

En faisant cela, ça m'écrit entre 5 et 6 fois par seconde sur le terminal, ça devrait écrire toutes les secondes non?

**paulfjujo** · 06/06/2014, 16h20

Envoyé par gautyy5

En faisant cela, ça m'écrit entre 5 et 6 fois par seconde sur le terminal, ça devrait écrire toutes les secondes non?

Oui, si ta trame Cycle est bien emise à 1Hz .. 1 fois par seconde!
As-tu verifié qu'il y a bien un carcatere 0x0D ou 13 ou CR dans la trame Cycle ?
c'est la detection de ce caractere qui fait armer la fin de reception avec le flag receveid=1.
sinon c'est le debordement de taille MAXLEN .. qui lui est completement aperiodique.

essaie de rajouter la valeur de Index1 dans l'Affichage_UART

Code:

k=fprintf(_H_USART,"Cycle : %s ;    compteur = %05d TR_MN      seconde=%5d  Index=%5d \r\n\r\n",buffer,compteur,seconde,Index1);

invite56c261eb · 06/06/2014, 17h41

Oui effectivement je n'y avais pas pensé, il n'y a pas de CR dans la trame reçue, voilà pourquoi c'est apériodique. Ca doit m'afficher le tableau dès qu'il a fini de se remplir!

**paulfjujo** · 06/06/2014, 18h07

est-ce que ta trame est de longueur constante ?
dans ce cas affiner MAXLEN ...

Y a-t-il un autre caractere particulierement reconnaissable ?
ou alors capter une sequence particuliere de caracteres.

invite56c261eb · 10/06/2014, 08h20

Oui la trame est de longueur constante (voir pièce jointe).
Mais il n'y a pas de caractère particulier apparemment..

**paulfjujo** · 10/06/2014, 09h41

Envoyé par gautyy5

Oui la trame est de longueur constante (voir pièce jointe).
Mais il n'y a pas de caractère particulier apparemment..

Bizarre, si c'est la capture exacte de ta trame.. on y voit bien au moins 2 carriage return <CR>
un apres Cycle et l'autre en fin de trame ....
ou alors un LF interpreté comme un CR
à confirmer ou pas

Peut-tu faire afficher la trame en hexadecimal..
comme c'est possible avec le terminal VBRAY ou aure terminal evolué..
comme cela on serait vraiment fixé sur ce contenu de trame

si c'est le cas , il suffit de valider le flag (received) que si buffer[0] est different de 'C'
remarque ,il me semble que la longueur de trame est > 40 cars
augmenter MAXLEN à 48 ou 50 .. à verfier

ce qui modifierai l'IT reception ainsi...

Code:

 #define MAXLEN 50


 //  ou si on deborde la taille du buffer de reception
if ((C==13) || (i>=MAXLEN-1)) 
{
   buffer[i]=0; // fin de chaîne si CR
   if(buffer[0]=='C')  // detection Cycle   ,on passe par dessus
    {
       buffer[0]=0;
       Index1=0;
       i=0;
       received=0;
     }
      else  
     {
         buffer[i]=0;
         Index1=i;
         received=1;
     }        
}
   else
    {
    buffer[i]=C ; // stockage
    i++;
    Index1++;
     }
  }

invite56c261eb · 10/06/2014, 10h54

Je crois avoir résolu le problème pour l'affichage des caractères du Cycle Analyst!
J'ai modifié ceci:

Code:

//======== SERIAL======================
				if(PIR1bits.RCIF) // si un car arrive
				{
				   C =ReadUSART(); // le lire => RAZ  RCIF
				   if(RCSTAbits.FERR || RCSTAbits.OERR)
				   {
				      RCSTAbits.CREN = 0 ; RCSTAbits.CREN= 1 ;
				   }
				    // while(BusyUSART()); // par sécurité    <- inutilisé
				   // on arme le drapeau received sur reception du CR fin de trame Cycle
				   //  ou si on deborde la taille du buffer de reception
				   if ((C==13) || (i>=MAXLEN-1))
				      {
				         buffer[i]=0; // fin de chaîne si CR
				         Index1=i;
				         i=0;
				         received =1; // arme le flag reception Trame
				       }
				    else
				     {
				        buffer[i]=C ; // stockage
				        i++;
				         Index1++;
						received=0;
				       }
				  }

Sinon "received" restait constamment à 1, et ne voulait donc rien dire. Maintenant j'ai toutes les valeurs à chaque coup.

Le dernier problème à résoudre vient de l'affichage. Les premiers et derniers caractères déconnent.

Code:

void Affiche_USART (void)
{
		unsigned int compte_tour;
		if  ((seconde==1)&&(received==1))                    // Pour n secondes
	{	
		i=i++;						 //Affichage nb de secondes
		j=i*seconde;
		compte_tour=compteur;
		printf("\r\n\r\n");
		printf("Cycle Analyst =     ");
		printf("%s",buffer);
		printf("				COMPTE_TOUR =    ",compte_tour);
		printf("%04d\r\n",compte_tour);
		seconde=0;
  		received=0;
  		Index1=0;
	}
}

Ca donne ceci:

Code:

Ã±•Analyst =
               -159.79  51.22   0.2     0.00    0.0000                          COMPTE_TOUR =    0000ß

c,«Analyst =
              -159.79   51.22   0.2     0.00    0.0000                          COMPTE_TOUR =    0000MZ

Cy,«Analyst =
Z              -159.79  51.22   0.2     0.00    0.0000                          COMPTE_TOUR =    0000

Cý,«Analyst =
ž              -159.79  51.22   0.2     0.00    0.0000                          COMPTE_TOUR =    0000

Cÿ,«Analyst =
ž              -159.79  51.22   0.2     0.00    0.0000                          COMPTE_TOUR =    0000

ccle Analyst =
               -159.79  51.20   1.1     0.00    0.0000                          COMPTE_TOUR =    0390*¯

C¯,«Analyst =
í              -159.79  51.19   1.3     0.00    0.0000                          COMPTE_TOUR =    0540

ó±•Analyst =
               -159.79  51.16   1.9     0.00    0.0000                          COMPTE_TOUR =    0660*¯

ccle Analyst =
               -159.79  51.17   1.8     0.00    0.0000                          COMPTE_TOUR =    0915MZ

ó×±•Analyst =
               -159.79  51.10   3.7     0.00    0.0000                          COMPTE_TOUR =    1395Oß

C,«Analyst =
              -159.79   51.12   3.1     0.00    0.0000                          COMPTE_TOUR =    1635ß

ccle Analyst =
               -159.79  51.15   2.1     0.00    0.0000                          COMPTE_TOUR =    1515-ë

C^,«Analyst =
               -159.79  51.17   1.5     0.00    0.0000                          COMPTE_TOUR =    1155MZ

ccle Analyst =
               -159.79  51.18   1.1     0.00    0.0000                          COMPTE_TOUR =    0645MZ

Cý,«Analyst =
ž              -159.79  51.22   0.2     0.00    0.0000                          COMPTE_TOUR =    0135

L'écriture de "Cycle Analyst" n'est pas bonne, et les derniers caractères de l'affichage du compteur non plus.

**paulfjujo** · 10/06/2014, 11h13

Tu n'as pas repondu à mon dernier post ...

çà marchotte .. car ce n'est pas LA SOLUTION .
received etait bien remis à 0 dans la routine d'affichage..
il ne doit etre mis à 1 QUE SUR la reception de CR
et on ne sait toujours pas si il y
zero CR
un CR
ou
Deux CR dans ta trame..
c'est un point essentiel à verifer.

Mais il n'y a pas de caractère particulier apparemment..

ces caracteres ne sont pas imprimables MAIS
mais apparament si, puisqu'on voit un changement de ligne..

idem pour
longueur de trame ? <40 ?

peux-tu capter la trame en mode text comme à l'ecran , dans un fichie rlog
et poster ce fichier.

invite56c261eb · 10/06/2014, 11h22

Envoyé par paulfjujo

peux-tu capter la trame en mode text comme à l'ecran , dans un fichie rlog
et poster ce fichier.

Qu'est-ce que c'est qu'un fichier rlog? :/

**paulfjujo** · 10/06/2014, 11h32

certain programme terminal sur PC
tel que le logiciel Terminal Vbray ( ou Realterm)
offre la possibilité de stocker tout ce qui arrive sur l'ecran dans un fichier .log
donner un nom au fichier ex: toto.log et activer la capture

apres avoir vu defilier les donnees , on stop et sauve ledit fichier

Le terminal permet aussi de dater chaque ligne à 50mS pres..
Terminal vbray a aussiune option pour afficher en hexadecimal chaque caractere
au lieu de l'ascii.. ou les 2 à la fois.
ce qui permet de bien verifier si un CR code 0x0D est present dans la trame..

invite56c261eb · 10/06/2014, 12h05

J'ai enregistré le fichier log comme tu me l'as demandé (en pièce jointe).

J'ai écrit ceci dans le programme pour afficher:

Code:

void Affiche_USART (void)
{
		unsigned int compte_tour;
		if  ((seconde==1)&&(received==1))                    // Pour n secondes
	{	
		printf("Cycle Analyst = ");
		printf("%s\r\n",buffer);
		seconde=0;
  		received=0;
  		Index1=0;
	}
}

J'ai également recopié la trame en hexadécimal:

Code:

43 79 63 6C E5 3D 41 6E 61 6C 39 09 
35 31 30 30 30 30 0D 0A 0D 0A 34 09 30 2E 32 09 
30 2E 30 30 09 30 2E 0A 34 09 30 2E 32 09 30 2E 
30 30 09 30

**paulfjujo** · 10/06/2014, 13h10

ta demarche est OK,
mais ce qui est interressant c'est la trame qui vient de ton boitier,
celle qui rentre dans le PIC en RX

invite56c261eb · 10/06/2014, 13h19

D'accord, il s'agit de ceci:

Code:

0D 0A 2D 31 35 39 2E 38 36 09 35 31 2E 31 
33 09 30 2E 32 09 30 2E 30 30 09 30 2E 30 30 30 
30

Avec le fichier en PJ. Il s'agit uniquement de ce qui arrive sur Rx

**paulfjujo** · 10/06/2014, 14h17

au vu du dump, il y a bien un CR LF (0x0D et 0x0A) en fin de trame

-159.85 51.03 0.2 0.00 0.0000<CR><LF>
je suppose que chaque trame est espacee d'une seconde ..(envoi à 1Hz)
à confirmer ..
sur terminal VBRAY on peut activer la coche time..qui affiche le temps à chaque ligne

Nom : dump.jpg
Affichages : 69
Taille : 192,2 Ko

Nom : dump.jpg
Affichages : 69
Taille : 192,2 Ko

une trame est en surligné dans le dump.
Elle fait moins de 40 cars donc MAXLEN peut rester à 40

Je ne vois donc aucun probleme pour recevoir cette trame avec le terminateur <LF>=0x0A
au lieu de <CR> =0x0D de façon à ce quelle soit entiere
et qu'on ne chope pas une nouvelle interrupt si on utilise CR.. car LF suit juste derriere

Code:

if ((C==10) || (i>=MAXLEN-1)) 
{
   buffer[i]=0; // fin de chaîne si LF recu
   if (buffer[i-1]==13)    
    {
        received=1;    // si caractere precedent=13=CR
        buffer[i-1]=0;  // optionnel si on veut eliminer le CR resideul dans le buffer
        Index1=i;
         i=0;
     }
      else   // on annule tout
     {
       received=0;    // caractere precedent different de 13=CR
        Index1=0i;
         i=0;
        buffer[0]=0;
      }  
    }   
     else
    {
    buffer[i]=C ; // stockage
    i++;
    Index1++;
    received=0;
     }
  }

invite56c261eb · 10/06/2014, 14h46

Nikel merci beaucoup!
Mais malheureusement ça ne règle pas le problème d'affichage de "CYCLE_ANALYST". (Voir PJ)

Code:

void Affiche_USART (void)
{
		unsigned int compte_tour;
		if  ((seconde==1)&&(received==1))                    // Pour n secondes
	{	
		i=i++;						 //Affichage nb de secondes
		j=i*seconde;
		compte_tour=compteur;
		printf("\r\n");
		printf("CYCLE_ANALYST:");
		printf("	%s",buffer);
		printf("				");
		printf("COMPTE_TOUR:");
		printf("	%04d",compte_tour);
		printf("\r\n");
		printf("%d",j);
		printf("\r\n");
		seconde=0;
  		received=0;
  		Index1=0;
	}
}

L'affichage du compteur est aussi défectueuse si la poignée d'accélérateur varie très rapidement

invite56c261eb · 10/06/2014, 15h26

Et c'est peut-être lié, mais lorsque la valeur du compteur est légèrement perturbée quand la poignée d'accélérateur varie rapidement, le mot "CYCLE_ANALYST" s'écrit correctement uniquement à ce moment précis!

Code:

 CYCLE_ANALYST:
                -159.59 50.92   -0.7    0.00    0.0000                          COMPTE_TOUR:    0975]Þ764

CYC¿Q91eMQé
                -159.59 50.79   3.3     0.00    0.0000                          COMPTE_TOUR:    1140
165

CYCÞQ91eMQé
                -159.59 50.85   1.8     0.00    0.0000                          COMPTE_TOUR:    1065
166

CYCLE_ANALYST:
                -159.59 50.93   -1.3    0.00    0.0000                          COMPTE_TOUR:    123pç167

CYCÞQ91eMQé
                -159.59 50.89   0.0     0.00    0.0000                          COMPTE_TOUR:    0030
168

CYCïE_ANALYST:
                -159.59 50.89   0.0     0.00    0.0000                          COMPTE_TOUR:    0000
169

**paulfjujo** · 10/06/2014, 16h19

je te propose de changer de strategie en partant sur le fait que:
la seconde elaboree via timer0 n'est pas synchrone avec l'arrivée de la trame qui est elle aussi à 1Hz (une seonde)
on separe donc les 2 traitements qui sont aperiodiques .
dans l'IT Rx UART on interdit tout autre IT TANT QUE LE BUFFER n'est pas imprimé

dans la boucle FOREVER:
simpliication en suppriamnt l'appel à la fonction..Affiche_USART qui est alors integree dans le main
L'affichage LCD prend beaucoup de temps (avec toutes les tempos inherentes à cet affichage)
et on raffraichit le LCD hors impression buffer
Sachant qu'apres reception UART..il faut environ 1 seconde pour avoir la prochaine IT ( à 1Hz)
Simplification du printf general.
simplification comptage secondes : variable secs.

Code:

/*********************************************************************************************************
*     Tachymètre (compte-tour) numérique à base de capteur à effet Hall                                  *
*     Quartz 20Mhz         PIC 18F1320                                                                   *
*                                                                                                        *
*     Formule de calcul du timer0 :                                                                      *
*     T = 1/(Fréquence horloge/4) * PRESCALER_registre_T0CON * (65535 - TMR0H&TMR0L)                     *
*     Ce qui donne:                                                                                      *
*     T = 1/(20000000/4)* 128 * (65535-26472) = 1.0000128s												 *
*																										 *
*     Le capteur Hall connecté sur RB0 déclenche une interruption à chaque passage de l'aimant           *
*********************************************************************************************************/

#include <p18f452.h>	 // d?claration SFR pour ICD2
#include <delays.h>	 // d?claration prototype fonctions delay
#include <usart.h>   // pour fonctions UART
#include <string.h>  // pour strmcp
#include <stdio.h>  // pour printf
#include <stdlib.h> // pour atoi
#define	FOREVER	 while(1)

// D?finir des nouveaux types donn?es

typedef unsigned char BYTE;
typedef unsigned int WORD;

// **** configuration du circuit *************

// configuration avec quartz
#pragma config OSC = HS, OSCS = OFF
#pragma config PWRT = OFF, BOR = OFF
#pragma config WDT = OFF
#pragma config CCP2MUX = OFF
#pragma config STVR = ON
#pragma config LVP = OFF
#pragma config DEBUG = ON
#pragma config CP0 = OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF, CPB = OFF, CPD = OFF
#pragma config WRT0 = OFF, WRT1 = OFF, WRT2 = OFF, WRT3 = OFF
#pragma config WRTB = OFF, WRTC = OFF, WRTD = OFF
#pragma config EBTR0 = OFF, EBTR1 = OFF, EBTR2 = OFF, EBTRB = OFF 

// d?finitions LCD


#define LCD_D4	LATBbits.LATB4 // data afficheur bit ? bits
#define LCD_D5	LATBbits.LATB1 // data afficheur bit ? bits
#define LCD_D6	LATBbits.LATB2 // data afficheur bit ? bits
#define LCD_D7	LATBbits.LATB3 // data afficheur bit ? bits

#define LCD_D4_DIR TRISBbits.TRISB4 // data direction afficheur bit ? bits
#define LCD_D5_DIR TRISBbits.TRISB1 // data direction afficheur bit ? bits
#define LCD_D6_DIR TRISBbits.TRISB2 // data direction afficheur bit ? bits
#define LCD_D7_DIR TRISBbits.TRISB3 // data direction afficheur bit ? bits

#define LCD_E	LATAbits.LATA1 // cde afficheur E
//#define LCD_RW	PORTAbits.RA2 // cde afficheur RW
#define LCD_RS	LATAbits.LATA3 // cde afficheur RS


#define LCD_E_DIR TRISAbits.TRISA1 // cde direction afficheur E
//#define LCD_RW_DIR TRISAbits.TRISA2 // cde direction afficheur RW
#define LCD_RS_DIR TRISAbits.TRISA3 // cde direction afficheur RS

#define MAXLEN 40



//*****	variables globales ********************
unsigned char u=0; // caractere incremente pour defilement table de caracteres

//*****	prototypes de fonctions ********************
char k;
unsigned int temp,i,j;
unsigned char rotation_brute;
unsigned short int sequence;
unsigned int secs;			// comptage Nb de secondes

void Init_LCD (void);
void Init_Interrupt (void);
void Init_UART (void);

//void Affiche_Compteur (void);   // <-- integree dans la main boucle FOREVER
//void Affiche_USART (void);

void w_cde_nibble( unsigned char ); // ?crit le quartet fort du char x en mode cde
void w_cde_octet( unsigned char ) ;// ?crit le quartet fort du char x en mode cde puis le quartet faible
void w_data_octet( unsigned char ) ;// ?crit le quartet fort du char x en mode data puis le quartet faible


volatile unsigned int  tour;
volatile unsigned int compteur,seconde;
volatile char buffer[MAXLEN];
volatile int Index1;
volatile int received; // flag reception trame


//sous prog d'int
void Interrupt_B0(void);

// on déclare que lors d'une interruption
#pragma code highVector=0x08
void atInterrupthigh(void)
{
// on doit éxecuter le code de la fonction MyHighInterrupt
_asm GOTO Interrupt_B0 _endasm		
}
#pragma code // retour à la zone de code


/ ************************
//  Interruptions 
// ************************
#pragma interrupt Interrupt_B0

void Interrupt_B0(void)
{
  static char C ;
  static char i;
 if ((INTCONbits.INT0IE==1) && (INTCONbits.INT0IF==1)) 
{             // Si une interruption du port B0 est détectée
            tour++;            // incrémenter la variable de tour
	 INTCONbits.INT0IF=0;
}

//========= IT Timer0 ==============
  if ((INTCONbits.TMR0IE==1) && (INTCONbits.TMR0IF ==1))
  {
     compteur = tour*15;         // Multiplier le nombre de tour/seconde par 60 (pour tour/min)
    TMR0H=0x67;
    TMR0L=0x68;
     tour=0;
     seconde=1;  // drapeau seconde ecoulee
     INTCONbits.TMR0IF = 0;		
 }				

//=== IT Serial UART RX =================
if (PIE1bits.RCIE==1) && (PIR1bits.RCIF)) // si un car arrive
{
   C =RCREG ; // le lire => RAZ  RCIF
  if(RCSTAbits.FERR || RCSTAbits.OERR)
   {
      RCSTAbits.CREN = 0 ; RCSTAbits.CREN= 1 ;
   }
  if ((C==10) || (i>=MAXLEN-1)) 
  {
   buffer[i]=0; // fin de chaîne si LF recu
   if (buffer[i-1]==13)    
    {
        received=1;    // si caractere precedent=13=CR
        buffer[i-1]=0;  // optionnel si on veut eliminer le CR resideul dans le buffer
        Index1=i;
         i=0;
         PIE1bits.RCIE=0;  // on stoppe les IT reception jusqu'à ce qu'on lise le buffer
     }
      else   // on annule tout
     {
       received=0;    // caractere precedent different de 13=CR
        Index1=0i;
         i=0;
        buffer[0]=0;
      }  
    }   
     else
    {
    buffer[i]=C ; // stockage
    i++;
    Index1++;
    received=0;
     }
  }
}



// dans la boucle principale  traiter de suite les evenements lié à la seconde
// et afficher sur le LCD .. pendant le remplissage du buffer UART et le comptage Tour

FOREVER
{
    if  (seconde==1)
        { 
         secs++;
          seconde=0;
      }
    if  (received==1)                    // Pour n secondes
	{	
		secs++; // compteur de secondes 
		printf("CYCLE_ANALYST: %s  COMPTE_TOUR: %04d    Secs=%d \r\n  ",buffer,compteur,secs );
		seconde=0;  // raz drapeau secondes ecoulees
  		received=0;  // raz drapeau rx uart
  		Index1=0;
		RCREG=0;
		PIE1bits.RCIE=1; // re-enable interrupt USART
	}
	else
	{
	 Affiche_Compteur ();
            } 

}

**paulfjujo** · 10/06/2014, 16h36

Code:

if  (received==1)                    // Pour n secondes
	{	
		secs++; // compteur de secondes

attention j'ai oublié de supprimer cette ligne..
secs deja incrementé dans le teste seconde=1

invite56c261eb · 10/06/2014, 17h59

Je vais tester cela demain quand j'aurai de nouveau tout le matériel!
J'avais une autre question en attendant:
Lorsque je coupe la batterie de la moto, et que je la rallume, le programme pour l'afficheur LCD fonctionne correctement lorsque la batterie est rallumée, en revanche pour la communication UART, il faut que je reprogramme le PIC pour que ça fonctionne, sinon ça ne communique plus. Ce qui est gênant si on fait un tour de moto, qu'on s'arrête en chemin, on ne peut plus avoir les données après l'arrêt de la batterie.

**paulfjujo** · 11/06/2014, 09h32

mettre init interrupt APRES init UART
et un bon delai au tout debut du programme
sinon, circuit RC sur le Reset ... attend que l'alim soit stabiliséee avant de liberer le MCU..

Code:

delay_ms(200);

//*****	init Ports ****************************
Init_LCD();
//*****	init Ports ****************************
Init_UART();
//*****	init Interrupt ****************************
Init_Interrupt();

Nom : reset_schem.jpg
Affichages : 59
Taille : 27,8 Ko

invite56c261eb · 11/06/2014, 14h34

J'ai mis le bouton Reset, ça marche très bien.
Par contre avec ce nouveau programme, j'ai l'impression que la trame n'est pas de 1hz comme annoncé, parce que les informations s'écrivent très rapidement, 5 fois par seconde (donc sur 5Hz et non 1Hz), et la valeur de "secs" s'affiche mal (voir en PJ).

invite56c261eb · 11/06/2014, 14h43

Ce que j'aimerais, c'est de pouvoir afficher les valeurs toutes les n secondes (n que l'on pourra modifier dans le programme)

**paulfjujo** · 11/06/2014, 15h30

tu ne precises pas si c'est l'affichage LCD qui va trop vite ou l'envoi UART vers PC
vu qu'il n'y a as de valeur de temps en debut de fichier log..
as-tu l'option "time" sur tertaterm ? permettant cet horodatage..

c'est normal que COMPTE_TOUR: 0000 ?

Dans tous les cas, il faut traiter chaque nterrupt UART

Code:

// declaration
#define NBsecondes 4

int n1;


n1=0;

FOREVER
 {
    if  (seconde==1)
        { 
         secs++;
          seconde=0;
      }
    if  (received==1)                 
	{	
	     n1++;
              if (n1>NBsecondes)
                {
		printf("CYCLE_ANALYST: %s  COMPTE_TOUR: %05d    Secs=%05d \r\n  ",buffer,compteur,secs );
                n1=0;
               }
		seconde=0;  // raz drapeau secondes ecoulees
  		received=0;  // raz drapeau rx uart
  		Index1=0;
		RCREG=0;
		PIE1bits.RCIE=1; // re-enable interrupt USART
	}
	else
	{
	 Affiche_Compteur ();
            }

invite56c261eb · 11/06/2014, 15h33

Envoyé par paulfjujo

tu ne precises pas si c'est l'affichage LCD qui va trop vite ou l'envoi UART vers PC
vu qu'il n'y a as de valeur de temps en debut de fichier log..
as-tu l'option "time" sur tertaterm ? permettant cet horodatage..

c'est normal que COMPTE_TOUR: 0000 ?

Pardon, c'est l'envoi UART qui est trop rapide!
Non je n'ai pas l'option time, mais j'ai réussi à afficher les valeurs de "secs", et il est incrémenté toutes les 5 lignes, donc il y a 5 envois par seconde (et donc 5Hz).

Pour le compte tour, c'est normal puisque je n'ai pas touché à la poignée d'accélérateur durant le test.

**paulfjujo** · 11/06/2014, 16h29

J'ai testé le programme avec le compteur n1 rajouté..
en fait le NbSecondes sera à multiplier par 5 , puisque la trame UART est à 200mS (5Hz)
Avec Vbray et un script j'envoi la trame toutes les 200mS environ sur le RX de mon PIC
et je simule la vitesse sur RBO avec mon gene DDS carré 20Hz et 50 Hz
et j'obtiens des mesures et affichage stables... (encore heureux, il est stable mon PIC DDS!)
avec affichage correct aussi sur un LCD4x20 I2C.

avec NbSecondes=4

à 20Hz
7:20:35.593> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00510
17:20:36.593> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00511
17:20:37.656> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00512
17:20:38.718> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00513
17:20:39.718> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00514
17:20:40.781> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00515
17:20:41.781> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00516
17:20:42.843> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00517
17:20:43.906> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00518
17:20:44.968> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00519
17:20:45.968> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00520
17:20:47.031> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00521
17:20:48.093> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00522
17:20:49.093> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00300 Secs=00523

à 50Hz
17:21:17.281> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00750 Secs=00552
17:21:18.281> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00750 Secs=00553
17:21:19.343> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00750 Secs=00554
17:21:20.343> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00750 Secs=00555
17:21:21.406> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00750 Secs=00556
17:21:22.468> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00750 Secs=00557
17:21:23.531> CYCLE_ANALYST: 159.59 50.79 0.1 0.00 0.0000; COMPTE_TOUR: 00750 Secs=00558

PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Re : PIC18f452 + MCP2200

Discussions similaires

Probléme avec le convertisseur UART/USB MCP2200

PWM sur Pic18f452 en C

pic18F452

Pic18f452

Can Pic18f452