Pin mapping via MPLAB sur PIC24FJ128GB206

[PtiBruno]

Bonjour à tous,
je suis débutant en programmation sous Mplab en langage C.
Je cherche à utiliser un PIC24FJ128GB206 afin de lire des données provenant d'un port série et de la recopier vers un autre port, en y apportant quelques modifications.

pour l'instant je ne cherche qu'a écrire en boucle sur le port série UART1, sur les pic 24 on les pins sont configurable et je ne sais pas trop comment le faire. Sur le net je trouve des infos mais ça ne fonctionne pas.

voici le code que j'utilise :

#include <p24FJ128GB206.h>
//#include "HardwareProfile.h"
#define USE_AND_OR /* To enable AND_OR mask setting */
#include <uart.h>
#include <stdio.h>
#include "PPS.h" //Re-map Pin library Peripheral Pin 
#include "Compiler.h"
#include "p24fxxxx.h"
#include "uart.h"



	//watchdog OFF //use PGx1 //jtag off
	_CONFIG1(FWDTEN_OFF & ICS_PGx1 & JTAGEN_OFF);

	//quartz <10 MHz //Primary Oscillator without PLL module // no clk switching
	_CONFIG2(POSCMOD_XT & OSCIOFNC_OFF & FCKSM_CSDCMD &	FNOSC_PRI);



//FCY=Fosc / 2
#define FCY 3685000UL  // Define CPU frequency for correct __delay_ms() operation before including the libpic30.h file

#include <libpic30.h>
#define UART1_BAUDRATE		11 //9600

int main(void)
{		

	//////////////////////////////
	//configure I/O
	//unlock Pin re-map
	__builtin_write_OSCCONL(OSCCON & 0xbf);
	//desactivate analog
	ANSB=0x0000;

	TRISEbits.TRISE4=0; //RE4 en sortie pour la Led verte
	TRISEbits.TRISE3=0; //RE3 en sortie pour la Led rouge

	TRISDbits.TRISD3=1; //RD3 en entrée pour Rx
	TRISDbits.TRISD4=0; //RE3 en sortie pour le Tx

	
	// Assign U1Rx To Pin R22
	iPPSInput(IN_FN_PPS_U1RX,IN_PIN_PPS_RP22); 
	// Assign U1Tx To Pin Rp25
	iPPSOutput(OUT_PIN_PPS_RP25,OUT_FN_PPS_U1TX);


	//lock Pin re-map
	__builtin_write_OSCCONL(OSCCON | 0x40);

	/////////////////////////////
	//configure peripheral 
	CloseUART1();
	OpenUART1(UART_EN & UART_NO_PAR_8BIT & UART_IrDA_DISABLE & UART_BRGH_SIXTEEN,UART_TX_ENABLE , UART1_BAUDRATE);

	/////////////////////////////
	//LOOP
	while(1)
    {
		PORTEbits.RE3=1;
		__delay_ms(200);
		WriteUART1(153);
		__delay_ms(200);
		PORTEbits.RE3=0;
	}
	
}

Je pense qu'il doit y avoir des problèmes dans la rédaction du code mais je ne vois pas lesquels.

Si quelqu'un à une idée?

Par avance
Merci
Bruno
-----

[JPL]

Je pense que c'est plutôt pour les électroniciens. Je déplace donc le sujet.

[herrmattoon]

Salut,
A la ligne :
OpenUART1(UART_EN & UART_NO_PAR_8BIT & UART_IrDA_DISABLE & UART_BRGH_SIXTEEN,UART_TX_ENAB LE , UART1_BAUDRATE);

Tu ne devrais pas utiliser le | (ou) plutôt que le &?
Sinon regarde dans le manuel du compilateur qui devrait être accessible depuis MPLAB pour voir si tu accèdes correctement aux pins des ports, je me souviens que le compilateur que j'avais utilisé une fois il fallait écrire : RB6 p.ex. plutôt que PORTB.BITblablabla...
Je rentre d'une longue journée de raquettes, je n'avais pas le courage de lire tout le code..
Peut-être que mon intervention t'aidera un peu.
A plus, courage!

[amoniaque]

Hello,

Tout d'abord, pourquoi mettre deux include pour ton uart.h ?!
Un seul devrait suffire normalement.

De mémoire la manière de définir les masques est quelque chose du genre "#define USE_OR_MASKS" (ou "#define USE_AND_MASKS").

Dans ton cas tu as mis du "#define USE_AND_OR" : ça me parait étrange que les masques puissent être autant du AND que du OR.

A+

[A voir en vidéo sur Futura]

[RISC]

Salut,

Tu trouveras des exemples de code pour les UARTs des PIC24F sur ce lien.

a+

[PtiBruno]

Merci pour vos conseils !

Herrmattoon, en ce qui concerne les & dans la ligne de configuration, j'ai vérifié dans le compilateur il faut utiliser cette synthaxe, qui je te l'accorde peut sembler étrange.

Amoniaque, bien vu, en faite je vais expliquer ça par le désespoirs comme ça ne fonctionnai pas, j'ai changer la syntaxe de l'include

Risc, alors en regardant de plus pret les exemples de code, je me suis aperçu que rien de va, ni dans mon pin mapping, trop d'include, mauvais define....

Je vais corriger le code et je le posterai, si il fonctionne !

Encore merci

Bruno

[PtiBruno]

pour ceux que ça interesse j'ai revu mon code, et voici le pin mapping qui fonctionne ( merci les exemples de microchip )

#include <p24FJ128GB206.h>
#define USE_AND_OR /* To enable AND_OR mask setting */
#include <uart.h>
#define USE_OR_MASKS
#define USE_AND_MASKS
#define FCY 3685000UL  

#include <libpic30.h>
#define UART1_BAUDRATE		9600

#define round(x) 		(int)(((float)(x))>0?(float)(x)+0.5:(float)(x)-0.5)
#define Fosc            8000000
                  
#define BRGVAL          round((FCY/UART1_BAUDRATE/(float)16)-1)



//*********************************************************************************************************************************************************************************
// define des variables sur les ports
//*********************************************************************************************************************************************************************************
#define LED_VERT PORTEbits.RE3
#define LED_ROUGE PORTEbits.RE4
//*********************************************************************************************************************************************************************************




	//watchdog OFF //use PGx1 //jtag off
	_CONFIG1(FWDTEN_OFF & ICS_PGx1 & JTAGEN_OFF);

	//quartz <10 MHz //Primary Oscillator without PLL module // no clk switching
	_CONFIG2(POSCMOD_XT & OSCIOFNC_OFF & FCKSM_CSDCMD &	FNOSC_PRI);



void ioMap(void);			// Assign RPn pin(s) to input/output functions for this lab
void unlockIO(void);		// Unlock sequence for RPn configuration
void lockIO(void);			// Lock sequence for RPn configuration
void UARTInit(void);		// Initiallize UART for 9600/N/8/1/HW Flow Control
void IOInit(void);			// Initialize switch and LED I/O/

//*********************************************************************************************************************************************************************************
// ZE MAIN
//*********************************************************************************************************************************************************************************
int main(void)
{		
 	ioMap();
	UARTInit();


	//desactivate analog
	ANSB=0x0000;

	//PINout_TRIS=0;
	//PINin_TRIS=1;
 
	TRISEbits.TRISE4=0; //RE4 en sortie pour la Led rouge
	TRISEbits.TRISE3=0; //RE3 en sortie pour la Led verte

	char Rx1;
	/////////////////////////////
	//configure peripheral 
	
	//CloseUART1();
	//OpenUART1(UART_EN & UART_NO_PAR_8BIT & UART_IrDA_DISABLE & UART_BRGH_SIXTEEN,UART_TX_ENABLE , UART1_BAUDRATE);

	/////////////////////////////
	//LOOP
	while(1)
    {

		LED_VERT=1;
		__delay_ms(1000);
		WriteUART1("0x55");
		WriteUART2("0x55");
WriteUART3("0x55");
		LED_VERT=0;
		__delay_ms(1000);
	}
}

//*********************************************************************************************************************************************************************************
// foncrion qui effectue le mapping des uarts
//*********************************************************************************************************************************************************************************
void ioMap()
{

	//*************************************************
	//	STEP 1:     Unlock the Reprogrammable Pin Mechanism
	//*************************************************/
	unlockIO();                         	// ###

	//*************************************************
	//	STEP 2:    configuration UART 1 = DEBUG				
	//*************************************************
	RPOR10bits.RP21R=3; 	//attribue RP21 à U1Tx
	RPINR18bits.U1RXR=26; 	//attribue RP26 à U1Rx
	
	//*************************************************
	//	STEP 3:     configuration uart 2 = CAPTEUR
	//*************************************************
	RPOR8bits.RP16R=5;		//attribue RP16 à U2Tx
	RPINR19bits.U2RXR=17;	//attribue RP17 à U2Rx
	RPINR19bits.U2CTSR=4; 	//Attribue RP4 à U2CTS
	RPOR1bits.RP2R=6;		//Attribue RP2 à U2RTS

	//*************************************************
	//	STEP 4:     configuration uart 3 = GSM
	//*************************************************
	RPOR11bits.RP22R=28;	//attribue RP22 à U3Tx
	RPINR17bits.U3RXR=25;	//Attribue RP25 à U3Rx
	RPINR21bits.U3CTSR=24;	//attribue RP24 à U3CTS
	RPOR11bits.RP23R=29;	//attribue RP23 à U3RTS	

	//*************************************************
	//	STEP 6:     Lock the Reprogrammable Pin Mechanism
	//*************************************************/
	lockIO();                       	// ###

}

//*********************************************************************************************************************************************************************************
//fonctions de Lock unlock du mapping
//*********************************************************************************************************************************************************************************
void lockIO(){

asm volatile ("mov #OSCCON,w1 \n"
				"mov #0x46, w2 \n"
				"mov #0x57, w3 \n"
				"mov.b w2,[w1] \n"
				"mov.b w3,[w1] \n"
				"bset OSCCON, #6":::"w1","w2","w3");
}


void unlockIO()
{
asm volatile ("mov #OSCCON,w1 \n"
				"mov #0x46, w2 \n"
				"mov #0x57, w3 \n"
				"mov.b w2,[w1] \n"
				"mov.b w3,[w1] \n"
				"bclr OSCCON, #6":::"w1","w2","w3");
}

//*********************************************************************************************************************************************************************************
//fonctions d'initalisation des UART
//*********************************************************************************************************************************************************************************

void UARTInit()
{

	TRISGbits.TRISG6 = 0;	// configure pin RG6 en sortie UART1TX en sortie
	TRISGbits.TRISG7 = 1;	// configure pin RG6 en sortie UART1RX en entree

	TRISFbits.TRISF3 = 0;	// configure pin RF3 en sortie UART2TX en sortie
	TRISFbits.TRISF5 = 1;	// configure pin RG6 en sortie UART2RX en entree
	//TRISDbits.TRISD8 = 0;	// configure pin RD8 en sortie U3RTS
	//TRISDbits.TRISD9 = 1;	// configure pin RD8 en sortie U3CTS	

	
	TRISDbits.TRISD3 = 0;	// configure pin RD3 en sortie UART3TX en sortie
	TRISDbits.TRISD4 = 1;	// configure pin RG6 en sortie UART3RX en entree
	//TRISDbits.TRISD2 = 0;	// configure pin RD8 en sortie U3RTS
	//TRISDbits.TRISD1 = 1;	// configure pin RD8 en sortie U3CTS



	//********************************************************************************
	//  Load the count to get 9600 baudrate
	//	BRG = Fcy/(16*BaudRate)-1  where Fcy = Fosc/2 = 4MHz
	//********************************************************************************/
	U1BRG = BRGVAL;
	U2BRG = BRGVAL; // automatic macro computation = 0x19; 
	U3BRG = BRGVAL;
	//********************************************************************************
	//  Hardware Flow Control OFF(sur U1 et ON sur U2 et U3), No Loop-Back
	// 	No Auto-Baud, No Rx-Inversion
	//	Low BaudRate, 1 Stop-bit
	//	8-bit, no parity 
	//********************************************************************************/
	U1MODE = 0x8000;	
	U2MODE = 0x8200; 
	U3MODE = 0x8200;
	//********************************************************************************
	//  Tx Interrupt to interrupt when at least one location is free in Tx buffer
	//	No Tx Inversion, Disable Sync Break
	//	Enable Transmit, Disable Address Detect
	//	Interrupt on every receive. 
	//********************************************************************************/
	U1STA = 0x0400;
	U2STA = 0x0400; // 0b0000 0100 0000 0000
	U3STA = 0x0400;

	IFS0bits.U1RXIF = 0;		// Clear U1RX_Int flag
	IFS1bits.U2RXIF = 0;		// Clear U2RX_Int flag
	IFS5bits.U3RXIF = 0;		// Clear U3RX_Int flag
}