PIC18f452 + MCP2200

[gautyy5]

Bonjour à tous!

J'ai récemment réalisé un compte tour pour une moto électrique avec un PIC18f452 branché à un afficheur LCD.
J'aimerais maintenant pouvoir enregistrer les informations du pic, donc le nombre de tour/minutes via un MCP2200 qui sera branché à un mini PC.
J'ai réalisé sur une carte électronique le montage du MCP2200.
Ma question est la suivante: est-ce qu'il suffit de relier le TX et le RX du PIC au MCP? Ou sinon faut-il modifier une partie du programme pour pouvoir le faire? Et si ce n'est pas tout que faut-il faire d'autre?

Je vous remercie d'avance pour vos réponses
-----

[gautyy5]

D'après ce que j'ai pu voir depuis ce matin, c'est qu'il faudrait configurer les registres TXSTA et RCSTA du PIC, ainsi que de calculer le SPBRG voulu en utilisant le formule:
SPBRG = ( (FOSC / Desired Baud Rate) / 64 ) – 1

Le but de mon programme serait de transmettre environ une fois par seconde le nombre de tours/minute de mon moteur qui est une valeur sur 16bits.

Voici mon programme qui gère mon compte tour:

/*********************************************************************************************************
*     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

#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






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

//*****	prototypes de fonctions ********************
unsigned int temp,i;
unsigned char rotation_brute;
unsigned short int sequence;
void Affiche_Compteur (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;

//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)
{

				 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/4)*60;         // 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++;
							INTCONbits.TMR0IF = 0;
											
 				}
}


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

//*****	init variables ****************************
 TRISA=0;                          // PORTA configuré en sortie
 TRISB=0b00000001;                 // PORTB configuré en sortie sauf port0
 compteur=0;
 temp=0;
 seconde=0;
 tour=0;
//*****	init Ports ****************************


// 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

//*****	init Interrupt ****************************
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

//*****	boucle forever ****************************
FOREVER	 // boucle forever
{

	Affiche_Compteur();               // Fonction d'affichage sur LCD

}
}

 //***** ecriture des fonctions ****************************

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 w_cde_nibble( unsigned char x) // écrit le quartet fort du char x en mode cde
    {
        ...
    }


void w_cde_octet( unsigned char x) // écrit le quartet fort du char x en mode cde puis le quartet faible
    {
        ...
    }

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

    {
       ...
    }

Ce programme incrémente une valeur à chaque interruption sur RB0, et affiche cette valeur qui sera converti en nombre de tour/minute toutes les secondes (lorsque le Timer0 déborde).
J'aimerai donc transmettre cette valeur affichée par liaison USB, en utilisant le MCP2200 (il est monté avec un quartz de 12Mhz)

[paulfjujo]

bonjour,


Exact ! ....

D'apres ce que j'en comprends le MCP2200 rends transparent la transformation UART/USB
donc coté PIC on le considere comme un client RS232

Comment representes- tu ta valeur à envoyer ?
en binaire (soit 2 bytes ) qui peuvent etres interprété soit en binaire Hexa soit en entier
soit codé en BCD ex: 0000 à 9999 sur 4 carcateres ascii
il faut peut etre prevoir une sequence de synchro ou reconnaissance
pour que coté PC tu puisse t'y retouver
ex: envoi de #0000&<CR> c'est un peu plus long mais facile de reperer lé # de debut le & de fin et le CR terminateur

Liaison unidirectionnelle PIC -> PC ?

sinon il faut prevoir la reception UART via interruption....
et un protocole d'echange.


un petit exemple d'init UART pour un 18F252 ..mais qui doit etre OKpour un 452

#include <usart.h>   // pour fonctions UART
#include <string.h>  // pour strmcp
#include <stdio.h>  // pour printf
#include <stdlib.h> // pour atoi

// init 19200Bd a 10Mhz avec IT en rx
// voir para 18.5 spec sheet DS41159B page 186
OpenUSART( USART_TX_INT_OFF &
USART_RX_INT_ON &
USART_ASYNCH_MODE &
USART_EIGHT_BIT &
USART_CONT_RX &
USART_BRGH_HIGH,
32 );
INTCONbits.PEIE = 1 ; // autorisation des IT des périphériques
INTCONbits.GIE = 1 ; // autorisation globale des IT

WriteUSART(CLS);
Tempo(150000L);
printf("Demo fonction USART Hardware PIC18F252\r\n");

[gautyy5]

Comment representes- tu ta valeur à envoyer ?
en binaire (soit 2 bytes ) qui peuvent etres interprété soit en binaire Hexa soit en entier
soit codé en BCD ex: 0000 à 9999 sur 4 carcateres ascii

Bonjour, ma valeur à envoyer est représentée par une variable de mon programme, nommée "compteur" sur 16bits, qui s'actualise toutes les secondes lorsqu'il y a une interruption sur le Timer0.

D'apres ce que j'en comprends le MCP2200 rends transparent la transformation UART/USB
donc coté PIC on le considere comme un client RS232


il faut peut etre prevoir une sequence de synchro ou reconnaissance
pour que coté PC tu puisse t'y retouver
ex: envoi de #0000&<CR> c'est un peu plus long mais facile de reperer lé # de debut le & de fin et le CR terminateur

Liaison unidirectionnelle PIC -> PC ?

sinon il faut prevoir la reception UART via interruption....
et un protocole d'echange.

Je débute totalement dans ce domaine que je ne connaissais pas du tout avant ce matin, alors je suis désolé mais je n'ai pas tout compris.
En gros, je comptais me servir de mon PIC, brancher les broches Tx et Rx (RC6 et RC7) sur le montage du MCP2200 et relier ce montage au PC.
Mais je ne sais absolument pas comment programmer cela, et surtout où le glisser dans le programme que j'ai réalisé pour qu'il envoie bien la valeur souhaitée toutes les secondes (pour commencer) avec un Quartz de 12MHz.

[A voir en vidéo sur Futura]

[paulfjujo]

Bonjour, ma valeur à envoyer est représentée par une variable de mon programme, nommée "compteur" sur 16bits, qui s'actualise toutes les secondes lorsqu'il y a une interruption sur le Timer0.

J'ai bien compris... mais coté PC, il s'attend à recevoir quoi ?
ex: compteur =10 ---> "10" en ascii ou 0x000A direct
si cela est envoyé à un terminal , ce sera un saut de ligne ...
si c'est en ascii tu visualisera 10
ex: compteur =9999 -> soit "9999" soit 0x270F en direct..
il faut savoir sous quel format tu veux l'envoyer...


Coté Hard, UART <-> MCP2200 je penses que tu as compris

Par contre la vitesse en Bauds du PIC doit etre calculéee à partir de son QUARTZ 20Mhz
et non pas de 12Mhz

Pour qu'il envoie cette valeur toutes les secondes, tu peux utiliser l'interruption timer0 existante
avec un flag ...

exemple en mikroC:

// dans l'init , rajouter 
volatile unsigned Flag_Seconde;
char  CRam[16];


// dans l'interrupt tmr0

if ((INTCONbits.TMR0IE==1) && (INTCONbits.TMR0IF ==1))
  	{

		    compteur = (tour/4)*60;         // 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++;
			INTCONbits.TMR0IF = 0;
		Flag_Seconde=1;
											
 				}


...........
// dans le main 
   // Initialize UART module at 9600 bps
  UART1_Init(19200);
..........

FOREVER	 // boucle forever
{

Affiche_Compteur();               // Fonction d'affichage sur LCD

if(Flag_seconde==1)
{
 WordToStr(Compteur,CRam);
   UART1_Write_Text(CRam);    // envoyé en ascii   "9999"
 UART1_Write(13); // et saut de ligne
  Flag_seconde=0;
}

}

Quel est ton compilateur ?

[gautyy5]

Je ne sais pas ce que l'ordi s'attend à recevoir, justement. Je pensais utiliser un hyperterminal ou autre mais je ne m'y connais pas des masses. Donc je sais pas comment il va recevoir les informations!
Quel est le mieux pour recevoir ces informations? En logiciel?

J'utilise MPLAB, en C18!

[RISC]

Salut Gauty,
Il va falloir installer le driver USB port COM virtuel qui est fourni sur la page du MCP2200 : http://www.microchip.com/MCP2200 (MCP2200 windows installer)
Un utilitaire est fourni pour le MCP2200 pour programmer le baud rate de l'UART du MCP2200 avec les même paramètres que ceux de ton PIC (baudrate, stop bit, parité,...)
Ensuite, pour tester si cela fonctionne, écrit un petit programme qui fait l'echo distant. Le PIC recoit un caractère et le renvoie.
Utilises un logiciel terminal tel que Teraterm pour taper des caractères qui devrait revenir (renvoyés par le PIC).
Pour le MCP2200 tu le cable comme sur le MCP2200 breakout board (pages 13 à 16) :http://ww1.microchip.com/downloads/e...Doc/52064A.pdf
a+

[gautyy5]

Salut Gauty,
Il va falloir installer le driver USB port COM virtuel qui est fourni sur la page du MCP2200 : http://www.microchip.com/MCP2200 (MCP2200 windows installer)

Apparemment c'est pour 64 et 86 bits, or j'ai un ordinateur 32 bits à mon stage :/.

[gautyy5]

Je n'ai rien dit j'ai réussi à l'installer, mais lorsque je branche mon montage rien ne se passe. Est-ce que le simple fait de le brancher en USB devrait suffire ou non?

Et aussi grâce à paulfjujo j'ai compris comment marche la programmation, mais je n'arrive pas à le faire en C18 sur MPLAB :/

[gautyy5]

Lorsque je branche l'interface à l'ordi par l'USB, rien ne se passe. C'est une interface que j'ai faite moi-même, pas achetée. L'USB est-il censé alimenter la carte? Parce qu'il n'y a aucune tension.
Vous voulez peut-être que je vous envoie le schéma et éventuellement une photo ou deux?

[paulfjujo]

c'est bien un MCP2200 ?
As-tu installé le driver ?

qui doit etre compatible 32 bits d'apres les infos
du fchier "readme.txt"

System Requirements
-----------------------------------------------------------------------------------------------------------
Operating System: Windows XP SP3, Vista, 7, and 8 (64 and 32 bit) - (ADMIN PRIVILEGES ARE REQUIRED FOR DRIVER INSTALLATION)

et
dans le dossier "legacy driver"
le fichier MCP2200_v1.0(SEE_README).inf indicque bien les versions

;------------------------------------------------------------------------------
; Windows 2000/XP/Vista-32bit Sections
;------------------------------------------------------------------------------

sinon, dispose tu d'un port COM traditionnel sur ton PC ?

Autre alternative : le cordon miracle "USB-DB9 COM" Trendnet ou autre marque !
qui est livre avec un mini-cd pour le driver et la doc ..pour moins de 20€

[gautyy5]

Non mais c'est bon c'est bien installé, mais je le branche et ma carte n'a pas l'air de réagir.
Il y a bien une tension au niveau du Tx, mais au niveau des Leds et du Rx il n'y a rien

[paulfjujo]

Il n'y a probablement que toi qui comprend tes reponses ...

Non mais c'est bon (Quoi ? )
c'est bien installé, (Le driver ?)

mais je le branche ( Quoi )
et ma carte ( le PIC ?) n'a pas l'air de réagir.
Il y a bien une tension au niveau du Tx, (sur quel pin de quel equipement ?)
mais au niveau des Leds (?)
et du Rx il n'y a rien

un petit schema representant les interconnections vaut mieux qu'un grand discours
et au besoin une photo en plus ..

[gautyy5]

Je vous ai proposé de vous mettre un schéma et une photo dans les messages précédents. Je vous le mets dans la soirée!

[gautyy5]

Ci-joint, la photo du circuit imprimé, du typon, et de la carte électronique. Ce circuit ayant pour but de gérer le MCP2200

[gautyy5]

Que je connecte ce circuit avant ou après avoir ouvert la "configuration utility", ça ne change rien, la config ne détecte pas mon montage.
"Write te device failed. Is it still connected?"

[paulfjujo]

bonjour


Tu as bien une alim presente sur Vcc (+USB) du MCP2200 lorsqu'il est connecté au PC ?
Nota:
Pour les tests seulement 2 fils TX et RX ? ... et le 0V GND ,où il est connecté ?
Je ne vais pas etudier le MCP2200 à ta place, mais il me semble qu'il faut aussi gerer les signneaux
CTS et RTS , puisqu'à priori, coté uART PIC, aucun moyen de gerer ..

Ton PC reagit-il lorsque tu connectes le montage MCP sur le port USB du PC?
Il (le PC) devrait au moins detecter un device .. meme non reconnu..
voir dans Systeme , s'il n'est pas désactivé !

[RISC]

Salut Gautyy,

Peux-tu reposter ton schéma électronique. Celui que tu as posté n'est pas lisible. Il y a apparemment des composants et des lignes qui ont disparues...

a+

[gautyy5]

Ah bon? Il manquerait quoi? Parce qu'il s'est bien posté le schéma :/

[RISC]

Salut,

Sous firefox je ne vois pas les connections Vdd du PIC, ni le quartz, ni d'autres lignes. Regarde bien ton le schéma de ton post #15
J'ai l'impression que le scan ou la resolution de ton schéma électronqiue est trop faible ce qui fait disparaitre certaines lignes et rend ton schéma incomplet...

a+

[gautyy5]

Je vais essayer de voir avec mon prof cet après midi, je vous tien au courant.
Du coup en attendant j'essaie de modifier mon programme sous MPLAB IDE avec le compilateur C18 pour écrire la valeur de mon compteur toutes les secondes.

Voilà ce que j'ai fait pour le moment:

L'interruption qui a lieu toutes les secondes:

void Interrupt_B0(void)
{
                 if ((INTCONbits.TMR0IE==1) && (INTCONbits.TMR0IF ==1))
				{

						    compteur = (tour/4)*60;         // 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++;
							INTCONbits.TMR0IF = 0;
							Flag_Seconde++;				
 				}
}

Initialisation de l'UART:

void Init_UART (void)
{
		TRISCbits.TRISC6 = 0;    		// set TX (RC6) as output 
  		TRISCbits.TRISC7 = 1;     		// and RX (RC7) as input

		OpenUSART( USART_TX_INT_OFF |
	    USART_RX_INT_OFF |
	    USART_ASYNCH_MODE |
	    USART_EIGHT_BIT |
	    USART_CONT_RX |
	    USART_BRGH_HIGH, 25 );			// configure la vitesse (BAUD) 9600 N 8 1

}

Ecriture de l'UART dans la boucle infinie:

{

	Affiche_Compteur();               // Fonction d'affichage sur LCD
	
	if (Flag_Seconde==1)			  // Nombre de secondes 
	{
		i=0;
		printf("tour/mn= ");
		while(CRam[i]!=0)
		{
			a=CRam[i];
			WriteUSART(a);    	
		}
		printf("\r\n"); 
		Flag_Seconde=0;
	}

}

J'ai deux questions: premièrement, est-ce que le programme se rédige bien comme ça? Et comment faire pour convertir ma valeur "compteur" pour l'envoyer dans le tableau pour l'écriture de l'UART?

[paulfjujo]

printf("tour/mn= ");
	while(CRam[i]!=0)
	{
		a=CRam[i];
		WriteUSART(a);    	
	}
printf("\r\n");

on suppose que la table CRam est bien dimensionné
tu as oublié de remplir "CRam" avec la transformation decimal -> ascii du compteur
et d'incrementer la variable "i" pour parcourir le contenu de la table

je t'avais deja proposé

if(Flag_seconde==1)
{
 WordToStr(Compteur,CRam);
   UART1_Write_Text(CRam);
  Flag_seconde=0;
}

je ne sais pas si avec ce pic tu peux utiliser simplement !

int k;
....
if(Flag_seconde==1)
{
  k=fprintf(_H_USART,"Compteur =  %05d ",compteur); 
 Flag_seconde=0;
}

[gautyy5]

je ne sais pas si avec ce pic tu peux utiliser simplement !

int k;
....
if(Flag_seconde==1)
{
  k=fprintf(_H_USART,"Compteur =  %05d ",compteur); 
 Flag_seconde=0;
}

Déjà, ce code se compile sans problèmes.
Je vais voir si je règle le problème de mon MCP2200 cet après-midi pour pouvoir tester ceci!

[gautyy5]

Y a-t-il possibilité d'utiliser un 2ème UART avec mon PIC?
Je dois récupérer les informations de mon Cycle Analyst 2.23 (doc -> http://www.ebikes.ca/documents/Cycle...al_Vers223.pdf ).
Je comptais utiliser le Tx et G de la carte pour avoir les données sur l'ordinateur. (Comme dans le 2.1 -> http://www.ebikes.ca/documents/Analogger_Manual_Web.pdf ).

Seulement je ne sais pas comment faire pour rassembler ces données avec celles de mon compte tour, le but étant d'avoir les informations du Cycle Analyst ET de mon compte tour, étant donné qu'il n'y a pas cette valeur dans l'Analyst.

[paulfjujo]

Il serait preferable de conserver l'UART hardware pour la reception de ta trame
qui contient

Ah V A S D3
3.296 47.62 10.04 15.32 8.9132

qui apparament a une longueur constante
est emise à 1Hz (à chaque seconde)
et se termine par un <CR> donc facilement reconnaissable..

Veux-tu recuperer toutes les donnees ou seulement quelques unes parmi celle ci ?

il n'ya qu"un seul UART Hard sur ce PIC (il me semble)
et donc utiliser un UART soft pour envoyer le global
compteur + trame à ton PC (via un MAX232)
pas d'interruption à gerer...
- Creer un UART soft (bibliotheque C18 ) pour l'envoi au PC

- modifier l'init de l'UART pour accepter les interruptions
- Prevoir un buffer de maxi 32 cars pour la reception de la trame + 5 cars pour le compteur
donc de taille maxi buffer[40]
Rajouter le traitement IT interruption RX UART
et un flag (Received) pour signaler la fin de recepetion de trame dans l'IT , avec la reconnaissance du <CR>


exemple de traitement IT UART

#define MAXLEN 40
initialiser le buffer
volatile char buffer[MAXLEN];
volatile Index1;
volatile int received; // flag reception trame

// rajouter dans le traitement des IT

  static char C ;
  static char i;
 //======== 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é
     if(C != CR && i<MAX_LEN)
      {
        buffer[i]=C ; // stockage
        i++;
         Index1++;
        }
      else
        {
         buffer[i]='\0'; // fin de chaîne si CR
         Index1=i;
         i=0;
         received =1; // arme le flag reception Trame
       }
      }
    }



//  dans le main
received=0;
buffer[0]=0;
Index1=0;
// armer les IT pour la recption de l'UART
RCIE
PEIE
GIE

le buffer contient alors la trame terminée par un zero (au lieu du CR.)..
il suffit de rajouter la valeur (en ascii) du compteur à la fin du buffer

Dans la boucle FOREVER

si usage de 2 uart UART hardware en reception du module et UART soft en emission vers PC

if  ((Flag_seconde==1)&&(received==1))
{
   k=strlen(buffer);
   buffer[k]=32; // rajout un espace
   WordToStr(Compteur,buffer+k+1);  // compteur mis au bout du buffer
   buffer[31]=13; // rakout CR
   buffer [32]=0;  // terminateur de string
   UART_soft_write_text(buffer); // on envoi au PC via l'UART soft !!
    Flag_seconde=0;
  received=0;
  Index1=0;
}
}

si le PC ne doit rien envoyer au PIC
on utile 1 seul UART Hardw

if  ((Flag_seconde==1)&&(received==1))
{
   k=fprintf(_H_USART,"%s %03d",buffer,compteur); 
    Flag_seconde=0;
  received=0;
  Index1=0;
}
}

Nota:
Il risque d'y avoir un probleme de desynchro entre le 1Hz de l'equipement et la second
generee par le Timer!
Si le 1Hz de l'equipement est fiable; plus besoin de generer l'IT 1 seconde
Utiliser simplement le flag received qui sera l'evenement 1seconde atteinte..

voiia de quoi cogiter.. à toi de jouer.

[gautyy5]

Il serait preferable de conserver l'UART hardware pour la reception de ta trame
qui contient
qui apparament a une longueur constante
est emise à 1Hz (à chaque seconde)
et se termine par un <CR> donc facilement reconnaissable..

Veux-tu recuperer toutes les donnees ou seulement quelques unes parmi celle ci ?

il n'ya qu"un seul UART Hard sur ce PIC (il me semble)
et donc utiliser un UART soft pour envoyer le global
compteur + trame à ton PC (via un MAX232)
pas d'interruption à gerer...
- Creer un UART soft (bibliotheque C18 ) pour l'envoi au PC

- modifier l'init de l'UART pour accepter les interruptions
- Prevoir un buffer de maxi 32 cars pour la reception de la trame + 5 cars pour le compteur
donc de taille maxi buffer[40]
Rajouter le traitement IT interruption RX UART
et un flag (Received) pour signaler la fin de recepetion de trame dans l'IT , avec la reconnaissance du <CR>

D'accord je crois que j'ai plus ou moins compris!
Je compte récupérer toutes les données citées. Mais ce que je ne comprends pas, c'est l'endroit où je dois connecter le Tx et le G du Cycle Analyst sur mon PIC pour stocker ces informations.

[paulfjujo]

où je dois connecter le Tx et le G du Cycle Analyst sur mon PIC

c'est bien clair sur le schema page 18

le G au 0V de l'alim du PIC
le TX sur le RX UART du PIC ... recoit la trame
Le TX UART renvoi Trame + compteur au PC

[gautyy5]

J'ai résolu le problème pour la connexion! Le circuit avait apparemment grillé sous le MCP (les soudures avaient effectuées à la machine).
Donc j'ai refait une carte, avec cette fois les soudures faites à la main et la carte est bien reconnue par le PC!

Maintenant je l'ai paramétrée pour qu'elle soit connectée sur le port COM1 du PC, mais quand j'ouvre tera term et que je lui demande de se connecter au port, il me marque "CANNOT OPEN COM1".

[gautyy5]

Fausse alerte. J'ai bidouillé 2-3 trucs et ça a marché d'un coup..
Maintenant je me lance dans la prog, pour essayer de bien récupérer ce que je veux!

[gautyy5]

Lorsque je programme:

k=fprintf(_H_USART,"Compteur =  %05d ",compteur);

Le terminal m'écrit:

Õ`Õ`Õ`Õ`ÿäÿÿÿÕàþÕ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ``Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`
Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ
`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`ÿÿÿÿÿÿÿÿÕàþÕ`Õ`dÿþúÿÿÿäþÕ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`Õ`

Les "Õ`" quand il ne se passe rien, et les "ÿ" quand le moteur tourne.
Ce qui est bon, c'est que ça écrit bien toutes les secondes comme voulu!