Début de programmation PIC

[invite227f3bcd]

Bonjour,

J'écris ce message pour demander à des personnes qui connaissent bien la programmation en C de l'aide pour créer ne serait ce qu'une esquisse de programme.

Pour info, le microcontrôleur en question est un PIC18F2550.

Le but de ce programme principal serait:

- Dans un premier temps, de récupérer une information sur le port RC7/RX du PIC. Cette information binaire est codée sur 64 bits (qui correspondent à 8 trames successives de 8 bits chacune).

L'état logique au repos étant l'état "haut" (->1), dès que le PIC lit sur son entrée RX le passage à l'état bas (->0) du bit de start, il mémorise chaque bit jusqu'au dernier bit de stop de la huitième trame de 8 bits.

- Dans un seconde temps, mettre la sortie RA1 du PIC à l'état "haut" (->1) dès la lecture de ce dernier bit de stop.

- Dans un troisième temps, convertir l'information binaire de 64 bits en héxadécimale et la transférer dans une zone de mémoire (non volatile). Ce qui doit donner au final un code de 16 caractères.

Je remercie d'avance tout ceux qui pourront m'aider dans cette tâche...

Cordialement.
-----

[invite7a49d0d5]

Bonjour,

- Dans un premier temps, de récupérer une information sur le port RC7/RX du PIC. Cette information binaire est codée sur 64 bits (qui correspondent à 8 trames successives de 8 bits chacune).

L'état logique au repos étant l'état "haut" (->1), dès que le PIC lit sur son entrée RX le passage à l'état bas (->0) du bit de start, il mémorise chaque bit jusqu'au dernier bit de stop de la huitième trame de 8 bits.

Cordialement.

bonjour,

it's smell like rs232 ;O]

ça devrait être assez facile,
si tu connais le débit...

et si c'est du "vrai" rs232, tu
peux même trouver des
librairies pré-programmées
pour gérer l'UART de ton
pic plus aisément/rapidement...

voir aides de ton compilo...
C18, CSS, MikroC...

idem pour enregistrer en mémoire
(librairies "Eeprom"...Eeprom_Write... )
et idem pour la conversion ("fonctions" bin2hex...)

sinon tu configures n'importe
quelle entrée en numérique...
et t'a plus qu'a "écouter" ;O]

vede
;O]

ps : et pour mettre RA1 à 1,
ça donne ce genre de code:
PortA.1=1...;O]

[invite7a49d0d5]

bonjour

sinon tu configures n'importe
quelle entrée en numérique...
et t'a plus qu'a "écouter" ;O]

sinon, cad, si c'est pas du compatible rs232

[sdec25]

Bonjour,
Un début de programme en C pour PIC18F (avec C18) :

#include <p18cxxx.h>

void main(void) {
OSCCON = ...;
ADCON = ...;
TRIS = ...;
...
}

Et il ne faut pas oublier de choisir les bits de configuration (soit dans le code avec #pragma, soit dans l'IDE).
Après il faut savoir par quoi on veut commencer.
Sinon quel est l'intérêt de convertir une donnée 64 bits en hexa et de l'enregistrer dans l'eeprom en hexa ?

[A voir en vidéo sur Futura]

[invite7a49d0d5]

re

>Un début de programme en C pour PIC18F

et en plus compatible 16Fxx ;O]

vede
;O]

[invite227f3bcd]

Bonjour à vous deux...

Sinon quel est l'intérêt de convertir une donnée 64 bits en hexa et de l'enregistrer dans l'eeprom en hexa ?

En fait cette donnée à la base est un code de 16 caractères en hexa. Donc quand cette donnée et récupérée par le PIC, je voudrais ensuite lui redonner sa configuration initiale (code en héxa) pour après la transférer via un port USB (mais bon, cette partie n'est pas primordiale pour l'instant)
Je veux juste pour l'instant, tenter de récupérer cette info et de la mémoriser dans la mémoire eeprom qui est non volatile.

Sinon j'ai récupérer des fichier .c pour l'eusart dont un qui est intéressant: c'est la routine qui permet de récupérer sur le port les données une par une.

#include <p18f2550.h>
#include <usart.h>

/********************************************************************
*    Function Name:  gets1USART                                      *
*    Return Value:   void                                           *
*    Parameters:     buffer: pointer to string                      *
*                    len: length of characters to receive           *
*    Description:    This routine receives a string of characters   *
*                    from the USART of length specified by len.     *
********************************************************************/
#if defined (AUSART_V2) || defined (EAUSART_V6)|| defined (EAUSART_V7) ||\
    defined (EAUSART_V8) || defined (EAUSART_V9) || defined (EAUSART_V10) ||\
	defined (EAUSART_V11)

void gets1USART(char *buffer, unsigned char len)
{
  char i;    // Length counter
  unsigned char data;

  for(i=0;i<len;i++)  // Only retrieve len characters
  {
    while(!DataRdy1USART());// Wait for data to be received

    data = getc1USART();    // Get a character from the USART
                           // and save in the string
    *buffer = data;
    buffer++;              // Increment the string pointer
  }
}

#endif

Par contre, je ne sais pas vraiment quelle valeur donné à la longueur "len" pour pouvoir récupérer l'info de 64 bits.
Est ce que je dois compter en plus des 64 bits de donnée total les bits de start et de stop ??

De plus, au niveau de l'eusart, j'ai trouvé cette info sur le net:

Le récepteur sait alors qu’il va recevoir une information, il démarre alors son horloge, vu que son horloge est à peu de chose près égale à celle de l’émetteur, à chaque coups d’horloge la ligne portera le nouveau bit. Et après 9 coups d’horloge sur le récepteur, celui-ci sait qu’il à reçu le mot et se mettra en attende d’un bit de « start ». Pour se faire correctement il sera préférable que l’horloge du récepteur se décale d’une demi-période par rapport à l’horloge de l’émetteur afin d’aller lire la valeur présente sur la ligne lorsque celle-ci est à la moitié de sa vie et donc assurer que premièrement le signal à eu le temps de s’initialiser correctement et secondement que si les deux fréquences d’horloge diffère légèrement que l’on ne risque pas de lire le mauvais bit.

Je voulais savoir comment on décale d'une demi période l'horloge du recepteur (cad l'horloge du PIC) dans le cas ou par exemple, Fosc=20MHz et la vitesse de transmission est de 9600 bauds???

Cordialement.

[RISC]

Guillaume,

Ta citation n'a de sens que pour un UART faite par logiciel ou il faut acquérir au milieu du bit (et encore un suréchantillonnage est souvent souhaitable)... Les UARTs matérielles échantillonnent au moins 4 fois (voire 16 fois) chaque bit pour les valider donc il ne faut SURTOUT pas décaler quoique ce soit...

a+

[invite227f3bcd]

Ok RISC, on ne décale rien du tout.

Sinon je rencontre un autre problème dans mon début de programmation. C'est au niveau des Directive "#pragma config".

J'ai trouvé un programme pour l'emploi du "reset":

#include <p18f2550.h>
#include "reset.h"

/*Configuration settings:
	* Oscillator is configured as INTRC
	* watch dog timer is disabled or enabled (comment out respective line)
	* Extended instruction mode is disabled
	* Low voltage programming is disabled
*/
#pragma config OSC = HS
#pragma config XINST = OFF
#pragma config LVP = OFF
#pragma WDT = OFF
//#pragma WDT = ON, WDTPS = 1024

#define RESET	1

//Function Prototypes
void user_main(void);
void Blink_LED(unsigned int number_of_blink);
void Delay(void);

//Reset flags
unsigned char R_POR, R_MCLR, R_BOR, R_WDT;

//main function
void main(void){
	// Clear Reset flags
	R_POR = 0;
	R_MCLR = 0;
	R_BOR = 0;
	R_WDT = 0;
	
	// Configure PORTB as input
	LATB = 0xFF;
	TRISB = 0xFF;
	
//	if(isPOR() == RESET){			//Reset source is POR
//		Blink_LED(1);
//		R_POR = 1;
//	}
	if(isMCLR() == RESET){			//Reset source is MCLR
		Blink_LED(2);
		R_MCLR = 1;
	}

//#if defined(BOR_ENABLED)
//	if(isBOR() == RESET){			//Reset source is BOR
//		Blink_LED(3);
//		R_BOR = 1;
//	}
//#endif

#if defined(WDT_ENABLED)
	if(isWDTTO() == RESET){			//Reset source is WatchDeog timer time out
		Blink_LED(4);
		R_WDT = 1;
	}			
#endif

	StatusReset();					//Clear the Reset status
	user_main();					//call the "user_main" -- The User application program
}

void user_main(void)
{
	while(1);		//Any user application to be executed and wait untill reset happens
}


void Blink_LED(unsigned int number_of_blink)
{
	unsigned int n=0;
	
// ************ BLINK LED *******************************	
//	for(n = 0; n < number_of_blink; n++){		
//		Delay();		// Turn on
//		LATB = 1;
//		Delay();		// Turn off
//		LATB = 0;
//	}
}

void Delay(void){
	unsigned int delay = 12000;		// If faster oscillator is used, make this larger (avant:6000)
	while(delay--);
}

Mais quand je le compile j'ai les 2 erreurs suivantes:

MPLAB C18 v3.32 (evaluation)
Copyright 2000-2009 Microchip Technology Inc.
Days remaining until evaluation becomes feature limited: 55
D:\Documents and Settings\stephane.rochetau\Mes documents\Stage\Proxiway\Progr ammation\SOURCE\reset_source.c :73:Error [1224] configuration setting 'OSC' not recognized
D:\Documents and Settings\stephane.rochetau\Mes documents\Stage\Proxiway\Progr ammation\SOURCE\reset_source.c :76:Warning [2002] unknown pragma 'WDT'

Pourtant, préalablement, j'avais bien rempli la fenêtre de configuration des bits dans MPLAB donc je ne vois pas vraiment ce qui cloche....

Cordialement.

[invite227f3bcd]

Note: Pour la deuxième erreur, j'avais oublié le mot "config"....

[sdec25]

Error [1224] configuration setting 'OSC' not recognized

-> OSC n'est pas une directive de config. Il faut trouver la bonne.
Sous MPLAB : Help > Topics > PIC18 Config Settings > ton PIC. Tu as toutes les directives de config de ton PIC.

Pourtant, préalablement, j'avais bien rempli la fenêtre de configuration des bits dans MPLAB donc je ne vois pas vraiment ce qui cloche....

Il faut faire soit l'un soit l'autre, pas les 2.

[invite227f3bcd]

Merci sdec25 pour la remarque, j'ai corrigé le tir.

Cependant je voudrais te demander autre chose.
Je sais maintenant comment positionner à 1 le premier bit du port A grâce à "vede".

Mais, ce que je n'arrive pas à traduire en code, c'est la condition qui apparaiît avant de cette action.

Cette condition veut que l'on mette à "1" RA1 lorsque sur le port RC7, on a fini de lire la dernière trame de 8 bits (sachant que le PIC reçoit 8 trames de 8 bits), ce qui signifit que toute l'information a bien été reçue.

Je suppose qu'il y aurait un lien avec le programme qui s'occupe de lire les bits sur RC7 (à travers la fonction "gets1USART").

Si quelqu'un pouvait me renseigner là dessus...

Cordialement

[sdec25]

Mais, ce que je n'arrive pas à traduire en code, c'est la condition qui apparaiît avant de cette action.

Cette condition veut que l'on mette à "1" RA1 lorsque sur le port RC7, on a fini de lire la dernière trame de 8 bits (sachant que le PIC reçoit 8 trames de 8 bits), ce qui signifit que toute l'information a bien été reçue.

Je suppose qu'il y aurait un lien avec le programme qui s'occupe de lire les bits sur RC7 (à travers la fonction "gets1USART").

gets1USART est bloquante, il suffit donc de mettre RA1 à 1 après avoir appelé gets1USART1.

[invite227f3bcd]

gets1USART est bloquante, il suffit donc de mettre RA1 à 1 après avoir appelé gets1USART1.

Ok donc au niveau de la boucle qui est dans la fonction "gets1USART1" je dois alors lui spécifier la longueur de l'information qu'il doit récupérer.

void gets1USART(char *buffer, unsigned char len)
{
  char i;    // Length counter
  unsigned char data;

  for(i=0;i<len;i++)  // Only retrieve len characters
  {
    while(!DataRdy1USART());// Wait for data to be received

    data = getc1USART();    // Get a character from the USART
                           // and save in the string
    *buffer = data;
    buffer++;              // Increment the string pointer
  }
}

#endif

Dans ce cas, si je remplace "len" par le chiffre 64, alors on récupérera bien l'état des 64 bits qui passe après le premier bit de start ??

De cette façon dans mon programme principal, il suffit que, dans le "main", j'appelle la fonction "gets1USART1" et qu'ensuite je mette à "1" le bit1 du PORTA.

Est ce que j'ai raison ???

Cordialement.

[sdec25]

Dans ce cas, si je remplace "len" par le chiffre 64, alors on récupérera bien l'état des 64 bits qui passe après le premier bit de start ??

Il ne faut pas remplacer len par 64 car len est un paramètre. La longueur est spécifiée à l'appel de la fonction, pas dans la déclaration (le code avec le for).
De plus, len est en octets (on lit des caractères de 8 bits). Donc 64 bits = 8 octets.

De cette façon dans mon programme principal, il suffit que, dans le "main", j'appelle la fonction "gets1USART1" et qu'ensuite je mette à "1" le bit1 du PORTA.

Oui c'est bon.

[invite227f3bcd]

Il ne faut pas remplacer len par 64 car len est un paramètre. La longueur est spécifiée à l'appel de la fonction, pas dans la déclaration (le code avec le for).
De plus, len est en octets (on lit des caractères de 8 bits). Donc 64 bits = 8 octets.

Aaah Ok donc c'est dans cette ligne alors:

void gets1USART(char *buffer, unsigned char len)

que je remplace ici "len" par 8, n'est ce pas !!

Est ce que, du même coup il faudra également remplacer le paramètre *buffer ??

Je te remercie pour ton aide, ça commence à venir....

Cordialement.

[sdec25]

Aaah Ok donc c'est dans cette ligne alors:

Non ça c'est aussi la déclaration. Il ne faut pas y toucher.
L'appel est ailleurs (dans la fonction main par ex).
Les fonctions en C

On doit arriver à un code comme ça :

char caracteres[8];
gets1USART(caracteres, 8);

[invite227f3bcd]

D'accord, je vois.
En tout cas merci pour le lien. Ça me sera bien utile....

Cordialement.

[invite227f3bcd]

Re-bonjour,

Voilà j'ai réalisé les modifications sur le programme.
J'ai intégré cette partie de programme dans le"user_main" du programme du reset parce qu'apparemment, il dise qu'on doit trouver dans ce "user_main" :

/*Any user application to be executed and wait untill reset happens*/

Voici le code du fichier source du reset avec l'intégration dans le "user_main" du petit bout de programme:

#include <p18f2550.h>
#include "reset.h"
#include "EEP.h"
#include "u1gets.c"	/*RAJOUT*/
#include "u1drdy.c"	/*RAJOUT*/

/*Configuration settings:
	* Oscillator is configured as INTRC
	* watch dog timer is disabled or enabled (comment out respective line)
	* Extended instruction mode is disabled
	* Low voltage programming is disabled
*/

#define RESET	1

/*Function Prototypes*/
void user_main(void);
void Blink_LED(unsigned int number_of_blink);
void Delay(void);
void gets1USART(char *buffer, unsigned char len);	/*RAJOUT*/
char DataRdy1USART(void);			/*RAJOUT*/

void Busy_eep ( void );
void Write_b_eep(PARAM_SCLASS unsigned int badd,PARAM_SCLASS unsigned char bdata );

/*Reset flags*/
unsigned char R_POR, R_MCLR, R_BOR, R_WDT;

/*main function*/
void main(void){
	/*Clear Reset flags*/
	R_POR = 0;
	R_MCLR = 0;
	R_BOR = 0;
	R_WDT = 0;
	
	/*Configure PORTB as input*/
	LATB = 0xFF;
	TRISB = 0xFF;

	/*Configure PORTA as output*/	/*RAJOUT*/
	LATB = 0;			/*RAJOUT*/
	TRISA = 0;			/*RAJOUT*/
	
//	if(isPOR() == RESET){		/*Reset source is POR*/
//		Blink_LED(1);
//		R_POR = 1;
//	}

	if(isMCLR() == RESET){		/*Reset source is MCLR*/
		Blink_LED(2);
		R_MCLR = 1;
	}

//#if defined(BOR_ENABLED)
//	if(isBOR() == RESET){		/*Reset source is BOR*/
//		Blink_LED(3);
//		R_BOR = 1;
//	}
//#endif

//#if defined(WDT_ENABLED)
//	if(isWDTTO() == RESET){	/*Reset source is WatchDeog timer time out*/
//		Blink_LED(4);
//		R_WDT = 1;
//	}			
//#endif
;

	StatusReset();			/*Clear the Reset status*/
	user_main();			/*call the "user_main" -- The User application program*/
}

void user_main(void)
{
	unsigned int address;
	while(1)				/*Any user application to be executed and wait untill reset happens*/
	{
		DataRdy1USART();	/*RAJOUT*/
		if(PIR1bits.RC1IF=1)	/*RAJOUT*/
		{								
		char caracteres[8];	             /*RAJOUT*/
		gets1USART(caracteres, 8);	/*RAJOUT*/
		PORTAbits.RA1=1;		/*RAJOUT*/

		}
	}		
}

void Blink_LED(unsigned int number_of_blink)
{
	unsigned int n=0;
	
// ************ BLINK LED *******************************	
//	for(n = 0; n < number_of_blink; n++){		
//		Delay();		// Turn on
//		LATB = 1;
//		Delay();		// Turn off
//		LATB = 0;
//	}
}

void Delay(void){
	unsigned int delay = 12000;		//If faster oscillator is used, make this larger (avant:6000) /*RAJOUT*/	while(delay--);
}

J'ai pu ensuite compiler sans problème ce programme donc à mon avis, il ne doit pas y avoir d'autres fautes...

Maintenant je voudrais me servir de la mémoire de donnée eeprom du PIC (256 octets) pour y mettre le tableau "caracteres" à chaque fois qu'on récupèrera cette trame d'information sur RX.
J'ajoute alors, dans le "user_main" du reset la boucle for suivante:

void user_main(void)
{
	unsigned int address;
	while(1)		                                        /*Any user application to be executed and wait untill reset happens*/
	{
		DataRdy1USART();						/*RAJOUT*/
		if(PIR1bits.RC1IF=1)					/*RAJOUT*/
		{								
		char caracteres[8];						/*RAJOUT*/
		gets1USART(caracteres, 8);				/*RAJOUT*/
		PORTAbits.RA1=1;						/*RAJOUT*/

		/*Write to EEPROM*/
		for(address = 0; address < 256; address++)
			{
			Write_b_eep (address, caracteres);				/*Write at each location its address*/
			Busy_eep ();							/*Wait until write is complete*/
			}

		}
	}		
}

J'ai bien déclaré les fonctions que j'appel dans les "foncTions prototypes" située plus haut dans le programme.
La fonction "Write_b_eep (address, caracteres);" est issue du fichier source "write_B.c":

#include <p18f2550.h>
#include <EEP.h>

/********************************************************************
*     Function Name:    Write_b_eep                                 *
*     Return Value:     None										*
*     Parameters:       unsigned int add, unsigned char data        *
*     Description:      Write single byte to Internal EEP           *
********************************************************************/
#if defined (EEP_V1)		//	128 byte EEP
void Write_b_eep( unsigned int badd,unsigned char bdata )
{
	EEADR = (badd & 0x07f);
	EEDATA = bdata;
  	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.WREN = 1;
	INTCONbits.GIE = 0;
	EECON2 = 0x55;
	EECON2 = 0xAA;
	EECON1bits.WR = 1;
	INTCONbits.GIE = 1;
	EECON1bits.WREN = 0;
}

#elif defined (EEP_V2)	//	256 byte EEP
void Write_b_eep( unsigned int badd,unsigned char bdata )
{
	EEADR = (badd & 0x0ff);
  	EEDATA = bdata;
  	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.WREN = 1;
	INTCONbits.GIE = 0;
	EECON2 = 0x55;
	EECON2 = 0xAA;
	EECON1bits.WR = 1;
	INTCONbits.GIE = 1;
	EECON1bits.WREN = 0;
}

#elif defined (EEP_V3)				// 1024 byte EEP	
void Write_b_eep( unsigned int badd,unsigned char bdata )
{
	EEADRH = (badd >> 8) & 0x03;
	EEADR = (badd & 0x0ff);
	EEDATA = bdata;
  	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.WREN = 1;
	INTCONbits.GIE = 0;
	EECON2 = 0x55;
	EECON2 = 0xAA;
	EECON1bits.WR = 1;
	INTCONbits.GIE = 1;
	EECON1bits.WREN = 0;
}
#endif

J'ai donc voulu remplacer dans la fonction d'appel "bdata" par "caractère" pour que les données soient écritent dans le registre EEDATA mais j'ai un souci car "caracteres" est un "char" alors que "bdata" et un "unsigned char".
donc quand je compile, j'ai les 2 messages d'erreurs suivants:

MPLAB C18 v3.32 (evaluation)
Copyright 2000-2009 Microchip Technology Inc.
Days remaining until evaluation becomes feature limited: 54
D:\Documents and Settings\stephane.rochetau\Mes documents\Stage\Proxiway\Progr ammation\SOURCE\reset_source.c :150:Warning [2106] comparison of a signed integer to an unsigned integer detected
D:\Documents and Settings\stephane.rochetau\Mes documents\Stage\Proxiway\Progr ammation\SOURCE\reset_source.c :152:Warning [2054] suspicious pointer conversion

Je voulais donc savoir comment on passe le tableau de 8octets "caracteres" vers la variable "bdata" ???

Cordialement.

[sdec25]

Re,
Tout d'abord, un include en C est remplacé par le contenu du fichier. On n'inclut jamais les .c, toujours les .h. Dans ton cas ça ne pose pas de problème mais tu sauras que ça peut être problématique.

J'ai donc voulu remplacer dans la fonction d'appel "bdata" par "caractère" pour que les données soient écritent dans le registre EEDATA mais j'ai un souci car "caracteres" est un "char" alors que "bdata" et un "unsigned char".

Ce n'est pas le soucis, char et unsigned char sont compatibles sauf si on fait des opérations arithmétiques.
Voir Les tableaux en C

La fonction Write_b_eep demande un char (8 bits), or tu veux écrire 8 octets d'un coup, c'est impossible.
Et la variable "caracteres" est un tableau, c'est-à-dire une adresse ou pointeur (dans un int). D'où l'erreur :

Warning [2054] suspicious pointer conversion

[invite227f3bcd]

La fonction Write_b_eep demande un char (8 bits), or tu veux écrire 8 octets d'un coup, c'est impossible.
Et la variable "caracteres" est un tableau, c'est-à-dire une adresse ou pointeur (dans un int). D'où l'erreur :

Je comprends maintenant la signification du message d'erreur. J'ai regardé le passage qui explique les tableaux en C.
Vu que La fonction Write_b_eep demande un char (8 bits), je me suis dit que je pourrais accéder à chacun des 8 octets dans le tableaux "caracteres" et leur appliqué la fonction "Write_b_eep" 1 octet par 1 octet.
J'ai donc rajoutté une boucle for avec la variable "Indice" qui désigne chacun des 8 octets qui constituent "caracteres".
Je voulais savoir si le bout de code était correcte.

void user_main(void)
{
	unsigned int address;
	while(1)						/*Any user application to be executed and wait untill reset happens*/
	{
		DataRdy1USART();						/*RAJOUT*/
		if(PIR1bits.RC1IF=1)					/*RAJOUT*/
		{		
		char Indice;						
		char caracteres[8];						/*RAJOUT*/
		gets1USART(caracteres, 8);				/*RAJOUT*/
		PORTAbits.RA1=1;						/*RAJOUT*/

		/*Write to EEPROM*/
		for(address = 0; address < 256; address++)
			{
			for(Indice = 0; Indice <= 7; Indice++)
				{
				Write_b_eep (address, caracteres[Indice]);					/*Write at each location its address*/
				Busy_eep ();									/*Wait until write is complete*/
				}
			}
		}
	}		
}

Quand je compile, j'ai l'erreur suivante:

D:\Documents and Settings\stephane.rochetau\Mes documents\Stage\Proxiway\Progr ammation\SOURCE\reset_source.c :151:Warning [2106] comparison of a signed integer to an unsigned integer detected

qui concerne la ligne de code :

for(address = 0; address < 256; address++)

Etant donnée que "adress" est déclaré comme un "unsigned int" et que 256 est un simple entier, ça explique ce message d'erreur.
Mais est ce que ce serait grave si je déclarais "adress" comme étant un "int" normal ???
Si c'est pas le cas, comment on peut régler ce problème de type de variable ??

Cordialement.

[sdec25]

je me suis dit que je pourrais accéder à chacun des 8 octets dans le tableaux "caracteres" et leur appliqué la fonction "Write_b_eep" 1 octet par 1 octet.
J'ai donc rajoutté une boucle for avec la variable "Indice" qui désigne chacun des 8 octets qui constituent "caracteres".
Je voulais savoir si le bout de code était correcte.

Oui c'est exactement ça

Par contre pour le warning je ne comprends pas, peut-être que 256 est considéré comme signed, mais ce n'est pas grave.
Ce que je ne comprend pas, c'est pourquoi tu écrits 256 fois la même chose ? Ton programme écrit 8 fois les données au même emplacement (les 7 premières sont écrasées et on aura la même valeur à 256 adresses).
Ce que je ferais :

adress_debut = ...;
for(i=0; i<8; ++i) {
write(adress_debut+i, donnee_a_ecrire);
}

Tu as remarqué que je n'ai pas mis <=7 mais <8, non seulement c'est plus rapide à exécuter mais c'est compréhensible + facilement car 8 est la taille du tableau (de manière générale, on fait for(i=0; i<taille; ++i)).
A+

[invite227f3bcd]

Ce que je ne comprend pas, c'est pourquoi tu écrits 256 fois la même chose ? Ton programme écrit 8 fois les données au même emplacement (les 7 premières sont écrasées et on aura la même valeur à 256 adresses).
Ce que je ferais :

Oui en effet ce n'est pas le résultat espéré, mon programme n'est pas encore au point....

Chaque fois que ces 8 informations sont "écrites" en zone mémoire, il faudrait alors sortir de la boucle "for" car sinon, comme tu l'as dit, on écrit la même chose jusqu'à ce qu'on est remplie la mémoire.

En fait ce que je souhaiterai , c'est stocker ces 8 informations à la suite, cad à des adresses qui se suivent.
Ce qui doit correspondre parfaitement avec le bout de code qui tu as écrit.

Dans le même temps, il faut quand même vérifier à chaque écriture dans la mémoire que l'on a pas dépassé les 256 octets de capacité.

Après, l'ennui, c'est comment signifier au programme qu'à la prochaine réception des 8 informations, il devra les écrires en mémoire à la suite et non "écrasé" les données déjà présentes en mémoire.
Donc en fait il faudrait à chaque fois qu'on sort de la boucle:

adress_debut = ...;
for(i=0; i<8; ++i) {
write(adress_debut+i, donnee_a_ecrire);
}

Incrémenter la variable "adress_debut" de 8 adresses.
De cette manière, à la prochaine écriture en mémoire, les données se retrouveront à la suite des anciennes......

J'ai ré-écris le programme pour essayer de résoudre ce problème:

void user_main(void)
{
	int address_debut;
	address_debut = 0;
	while(1)						/*Any user application to be executed and wait untill reset happens*/
	{
		DataRdy1USART();						/*RAJOUT*/
		if(PIR1bits.RC1IF=1)					/*RAJOUT*/
		{										/*RAJOUT*/
		char Indice;							/*RAJOUT*/			
		char caracteres[8];						/*RAJOUT*/
		gets1USART(caracteres, 8);				/*RAJOUT*/
		PORTAbits.RA1=1;
												/*RAJOUT*/
		/*Write to EEPROM*/
		if(address_debut < 256)
		{																	/*RAJOUT*/
			for(Indice = 0; Indice <= 8; Indice++)							/*RAJOUT*/
			{																/*RAJOUT*/
			Write_b_eep (address_debut+Indice, caracteres[Indice]);		/*RAJOUT*/		/*Write at each location its address*/
			Busy_eep ();												/*RAJOUT*/		/*Wait until write is complete*/
			}
		}
		}
		address_debut = address_debut + 8;
	}		
}

Cordialement.

[sdec25]

Oui ce programme devrait marcher.
Il y a juste une petite erreur :

for(Indice = 0; Indice <= 8; Indice++)

Mettre < au lieu de <= .

Et que doit-il se passer quand la mémoire est remplie ?
Et au début tu ne voulais pas écrire les valeurs directement en hexadécimal dans la mémoire (16 caractères) ?

[invite227f3bcd]

Mettre < au lieu de <= .

Ok merci pour la remarque.

Et que doit-il se passer quand la mémoire est remplie ?

Hé bien en fait, je dispose d'une mémoire externe eeprom (une 24LC512) que j'ai relier au PIC avec les entrée SDA et SCL.
Je pensais que lorsque la mémoire eeprom du PIC serait saturé, je pourrais rediriger les informations vers la mémoire externe. Mais bon je pense que pour communiquer avec cette mémoire, ça ne doit pas être de la tarte !!!

Si tu avais quelques infos la dessus, ce ne serait pas de refut...

Et au début tu ne voulais pas écrire les valeurs directement en hexadécimal dans la mémoire (16 caractères) ?

Ben au début si, mais je n'ai pas réussi à trouver la fonction dont on m'avait parlé au début de la discussion qui était "bintohex" (ou bien alors "bin2hex").
J'ai bien cherché dans les librairies maths et autres du PIC mais pas moyen de trouver une fonction de ce genre et je ne pense pas que j'aurais les connaissances pour la crée moi-même, donc je l'ai mis de côté pour l'instant....

Cordialement

[invite7a49d0d5]

bonjour,

il n'y a pas de librairie i2c dans ton compilo?
sinon tape "soft i2c" par exemple dans google...
c'est un sujet re-rabattu...
mais il faudra aussi jeter un oeil au datasheet du 24LC512 ;O]

sinon le protocole est assez facilement émulable...
je l'ai fait dernierement en Basic, et c'est fonctionnel ;O]
(pour accés DS1307 et 24LC256 avec un pic...)

ton PIC intégre un MSSP? (hard i2c)

vede
;O]

[invite227f3bcd]

Bonjour vede !!

il n'y a pas de librairie i2c dans ton compilo?

Si si je l'ai trouvé le dossier i2c par contre il contient une cinquentaine de fichiers avec autant de fonctions décrites à chaque fois.
Comment savoir quels fichiers ".c" seront utile pour ce que je veux faire ??

ton PIC intégre un MSSP? (hard i2c)

Oui il intègre un MSSP (hard i2c et SPI).

Sinon en ce qui concerne la conversion des 8 octets en héxadécimals, tu ne connaitrais pas par hasard une petite routine qui permettrait de faire cette opération ???

Cordialement.

[sdec25]

Pour la fonction bin2hex (que j'appelerais plutôt bytetohex), essaie cette fonction :

void bytetohex(char* chaine, char nb) {
  unsigned char x;
  x = nb;
  x = x >> 4; // poids fort
  if (x < 10) chaine[0] = x + '0';
  else chaine[0] = x - 10 + 'A';

  x = nb;
  x = x & 0x0F; // poids faible
  if (x < 10) chaine[1] = x + '0';
  else chaine[1] = x - 10 + 'A';
}

Elle met la représentation hexa de "nb" dans la chaine "chaine".
Cependant, si tu stockes la représentation hexa dans l'eeprom, ça prendra 2 fois plus de place.

[invite7a49d0d5]

bonjour,

je comprend pas bien l'idée du stockage
en hexa dans l'eeprom...l'interet...

l'important, ça sera plutot aprés lecture,
de faire une conversion (bin2hex ou byte2hex...)
pour un affichage en hex...

d'ailleurs, oui, sedc25 a raison, un stockage en hexa
prend 2 fois plus de place en mémoire...on pourrait
dire "stockage ascii"??

vede
;O]

[invite227f3bcd]

Bonjour,

je comprend pas bien l'idée du stockage
en hexa dans l'eeprom...l'interet...

Hé bien, en fait, chaque information en hexa est un code correspondant à un badge RFID. Je voudrais stocker ces codes en eeprom puis les extrairent vers un PC portable via un port USB.

d'ailleurs, oui, sedc25 a raison, un stockage en hexa
prend 2 fois plus de place en mémoire...on pourrait
dire "stockage ascii"??

Alors peut être serait-il préférable de ne faire la conversion que lorsque les données devront être transférer sur l'USB. De cette manière les informations restent en binaire dans l'eeprom.

De toute manière cette partie de programmation reste très illusoire vu mon niveau de programmation assez faible (cependant je compte bien utiliser le code fournie par sdec25 pour essayer d'arriver à mes fins).
Le but premier étant de réceptionner cette information -> mettre à 1 la sortie adéquate -> stocker l'info en eeprom.

Cordialement.

[invite227f3bcd]

Autre question:

Quand la mémoire de l'eeprom sera saturée , je voudrais bien alors stocker les infos sur ma mémoire externe (voir Message #24 ).
Par quel moyens ou fonctions en C je pourrais envoyer (donc "écrire" ou même "lire") ces infos sur la mémoire externe ?????

Cordialement.