Liaison UART par PIC24F

[invite5b91726d]

Bonjours, j'ai un problème avec la liaison UART d'un PIC24F avec le PC

voici mon programme

#include <p24FJ32GA002.h>

#define XTFREQ 20000000//j'utilise un quartz externe de 20MHz
#define PLLMODE 2
#define FCY XTFREQ*PLLMODE
#define BAUDRATE 9600
#define BRGVAL ((FCY/BAUDRATE)/16)-1
#define null 0

int main (void)
{
//dévalidation watch dog
RCONbits.SWDTEN=0;

//cablage des pins pour l'uart

//unlock des registres
OSCCON = 0x46;
OSCCON = 0x57;
OSCCONbits.IOLOCK = 0;

//assigne U1RX > RP4
RPINR18bits.U1RXR = 4;
//U1CTSR > RP5
RPINR18bits.U1CTSR = 5;
//U1TX > RP2
RPOR1bits.RP2R = 3;
//U1RTS > RP3
RPOR1bits.RP3R = 4;

//lock des registres
OSCCON = 0x46;
OSCCON = 0x57;
OSCCONbits.IOLOCK = 1;

//config uart
U1STAbits.UTXEN = 0; //reset du buffer
U1BRG = BRGVAL;
U1MODE = 0x8000; //U1MODE affiche 0xC000 (pin15 à 1 mais elle sert à rien)
U1STA = 0x0400; //U1STA affiche 0x0510 (TRMT à 1 et RIDLE à 1(mode recevoir en idle))
IFS0bits.U1RXIF = 0; //effaçage du falg d'interruption RX de l'uart

//routine
while(1)
{
if(IFS0bits.U1RXIF==1) //si un caractère est en attente
{
while(!U1STAbits.TRMT); //attendre que la transmission soit complète
U1TXREG = U1RXREG;
IFS0bits.U1RXIF = 0;
}
}

return 0;
}

Voilà, mon U1MODE et mon U1STA me donne des valeurs bizarres à l'initialisation.

Je reçois mes données de Labview (où j'utilise VISA WRITE pour écrire) sur le COM1 avec un câble RS232

Voilà aussi la datasheet du PIC, la fonction UART est à la page 153
http://ww1.microchip.com/downloads/e...Doc/39881b.pdf

merci de votre aide si vous pouviez m'éclaicir un peu
-----

[invited5b3bb8b]

Bonjour,
J'aurais voulu savoir si vous aviez réussi à utiliser L'UART de votre PIC24f.

[invite5b91726d]

oui, j'avais réussi

[invite6ea6d79a]

En fait le bit 15 de U1MODE est le bit UARTEN qui est UART ENABLE. Avec ce bit à 0 tu peux être certain que ton UART ne fonctionnera pas.

Il est normal que TRMT soit à 1 si tu ne transmet rien:

TRMT: Transmit Shift Register Empty bit (Read-Only)
1 = Transmit Shift Register is empty and transmit buffer is empty (the last transmission has completed)
0 = Transmit Shift Register is not empty, a transmission is in progress or queued

même chose pour RIDLE. Il sera à 1 si le UART n'est pas entrain de recevoir.
RIDLE: Receiver Idle bit (Read-Only)
1 = Receiver is Idle
0 = Receiver is active

Tu dois porter attention à ce que la datasheet te dis. La mention Read-Only spécifie que ces bit servent à passer des messages et que tu peux donc les tester mais qu'il n'est pas conseiller d'essayer d'écrire une valeur une fois l'initialisation faite.

[A voir en vidéo sur Futura]

[RISC]

Salut,


Il existe plusieurs cartes avec des PIC24F chez Microchip. Perso, j'utilise souvent comme base le code en téléchargement gratuit de ces cartes. Ca fait gagner du temps ;=)

Ces cartes sont visibles ici avec leurs manuels, les schemas électroniques etc :
http://www.microchip.com/stellent/id...wwPIC24MCUDemo

Il y a aussi des exemples de code pour t'aider ici : www.microchip.com/codeexamples

Et le forum dédié aux utilisateurs de PIC24F : http://forum.microchip.com/tt.aspx?forumid=179

a+

[RISC]

Salut,

Ci-joint un morceau de code qui initialise l'UART et qui fonctionne sur la carte EXPLORER16 (je l'ai testé et utilisé) avec le PIM 44 broches utilisant le PIC24FJ64GA004 que j'avais récupéré sur le site de Microchip.

Les problèmes courants avec le PPS sont :
* oubli de "unlocker" et "locker" le PPS (voir le programme)
* oubli de programmer les broches TRIS correspondantes

a+

/*****************************************************************************
 *
 * PPS (Peripheral Pin Select) Lab - Echoes typed keys back to HyperTerminal
 *
 *****************************************************************************
 * FileName:        PPS_solution.c
 * Dependencies:    p24FJ64GA004.h
 * Processor:		PIC24FJ64GA004
 * IDE :       	    MPLAB v7.61 or higher
 * Compiler :       MPLAB C30 v3.01b or higher
 * HW platform :    EXPLORER16 (DM240001)
 * Plug-In Module : PIC24FJ64GA004 PIM Plug-In Module (MA240013)
 * Company:         Microchip Technology Incorporated
  *****************************************************************************/

#include <p24FJ64GA004.h>


//****************************************************************************************
//	STEP 1:
//	Set up the Configuration Bits in the file using the _CONFIGx macros
//  Macros and bit configuration labels are defined in the p24FJ64GA004.h file
//  Details about bit configuration registers in PIC24FJ64GA004 datasheet, section 23
//	(JTAG=Disabled, WATCHDOG=Disabled, EMUC/EMUD share PGC1/PGD1, PriOSC=HS, IOLOCK=1 Way)
//***************************************************************************************/

_CONFIG1(JTAGEN_OFF & ICS_PGx1 & FWDTEN_OFF)	// ###  configure _CONFIG1
_CONFIG2(FNOSC_PRI & POSCMOD_HS & IOL1WAY_ON)	// ###  configure _CONFIG2


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


/*** main() Function********************************************************************/
int main(void)
{
	ioMap();				// Configure the remappable I/O pins
	UARTInit();      		// Initialize UART2
	IOInit();				// Initialize Switch and LED I/O
	
	IEC1bits.U2RXIE = 1;	// Enable Uart2 RX Interrupts
	
	while(1);
}

/*********************************************************************************** 
 * Function: ioMap()
 *
 * Preconditions: None.
 *
 * Overview: This executes the necessary process to map the RPn pins to UART 2 for the
 *				PIC24FJ64GA004-PIM installed on Explorer16
 *
 * Input: None.
 *
 * Output: None.
 *
 *****************************************************************************/
void ioMap()
{
	//*************************************************
	//	STEP 2:     Unlock the Reprogrammable Pin Mechanism
	//*************************************************/
	unlockIO();                         	// ###

	//*************************************************
	//	STEP 3:     Map RP19 pin to input function U2RX
	//*************************************************/
	RPINR19bits.U2RXR = 19;             	// ###
	
	//*************************************************
	//	STEP 4:     Map RP20 pin to input function U2CTS
	//*************************************************/
	RPINR19bits.U2CTSR = 20;            	// ###

	//*************************************************
	//	STEP 5:     Map Output Function U2TX to RP25
	//*************************************************/
	RPOR12bits.RP25R = 5;                 	// ###

	//*************************************************
	//	STEP 6:     Map Output Function U2RTS to RP21
	//*************************************************/
	RPOR10bits.RP21R = 6;                   // ###
	
	//*************************************************
	//	STEP 7:     Lock the Reprogrammable Pin Mechanism
	//*************************************************/
		lockIO();                       	// ###
}
 
/*********************************************************************************** 
 * Function: lockIO
 *
 * Preconditions: None.
 *
 * Overview: This executes the necessary process to set the IOLOCK bit to lock
 * I/O mapping from being modified.
 *
 * Input: None.
 *
 * Output: None.
 *
 *****************************************************************************/
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");
}

/*****************************************************************************
 * Function: unlockIO
 *
 * Preconditions: None.
 *
 * Overview: This executes the necessary process to clear the IOLOCK bit to 
 * allow I/O mapping to be modified.
 *
 * Input: None.
 *
 * Output: None.
 *
 *****************************************************************************/
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");
}

/*********************************************************************************
*
*	UARTinit() - Initialize UART2 for 9600/8/N/1/HW Flow control
*
**********************************************************************************/
void UARTInit()
{
	TRISCbits.TRISC9 = 0;	// RC9 on 24FJ64GA004 connected to UART TX = output function
	TRISCbits.TRISC5 = 0;	// RC5 on 24FJ64GA004 connected to UART RTS = output function

	//********************************************************************************
	//  Load the count to get 9600 baudrate
	//	BRG = Fcy/(16*BaudRate)-1  where Fcy = Fosc/2 = 4MHz
	//********************************************************************************/
	U2BRG = 0x19; 

	//********************************************************************************
	//  Flow Control Mode, No Loop-Back
	// 	No Auto-Baud, No Rx-Inversion
	//	Low BaudRate, 1 Stop-bit
	//	8-bit, no parity 
	//********************************************************************************/
	U2MODE = 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. 
	//********************************************************************************/
	U2STA = 0x0400;

	IFS1bits.U2RXIF = 0;		// Clear U2RX_Int flag
}

/*********************************************************************************
*
*	IOInit() - Initialize Switch and LED I/O for the project
*
**********************************************************************************/
void IOInit()
{
	LATAbits.LATA10 = 0;	
	TRISAbits.TRISA10 = 0;	// RA10 as output for LED D3 on EXPLORER16
}

/*********************************************************************************
*
*	_U2RXInterrupt - Echo character back to Hyperterminal or another terminal SW
*
**********************************************************************************/
// shadow attribute is used here to reduce interrupt save and restore overhead
volatile char C;
void __attribute__((interrupt, shadow, no_auto_psv)) _U2RXInterrupt()
{
	IFS1bits.U2RXIF = 0;

	while(!U2STAbits.TRMT);

	C = U2RXREG;
		U2TXREG = C;
	__builtin_btg((unsigned int*)&LATA,10); // switch ON and OFF LED D3
}

Bonjour RISC et tout le groupe

Le fichier zip, inadapté à ce cas, ne doit pas être utilisé, en raison des contraintes liées aux virus, et du travail inutile des modérateurs.

Merci de consulter le lien épinglé suivant:

http://forums.futura-sciences.com/thread163927.html

Là, le texte est tout simplement inclus dans le corps du message, avec la balise [code]. L'alternative, c'est de placer un fichier texte, parfaitement admis par le serveur.

[invited5b3bb8b]

Bonjour RISC,
Voila en fait j'ai quelque soucis avec le programme que tu a fourni.
En effet, je ne comprends pas trop l'assembleur et vu que je créé un programme en C, j'aimerai bien que tout soit dans la même forme.

La partie que je comprends pas concerne le vérrouillage et le déverrouillage :
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");
}


Si par exemple je veux mettre en C. Est-ce que cela fonctionnerai comme le propose EZAY ?

void lockIO(){

OSCCON = 0x46;
OSCCON = 0x57;
OSCCONbits.IOLOCK = 1;
}
Car quand je compile il me met une erreur.

Merci de l'aide !

[RISC]

Salut,

Microchip recommande dans sa documentation, de ne SURTOUT pas faire ces fonctions en C....

voir PIC24F Family Reference Manual Section 12 sur le PPS (paragraphe 12.4.4.1) :
"The unlock/lock sequence must be executed as an assembly language routine in the same manner as changes to the oscillator configuration because the unlock sequence is timing critical. If the bulk of the application is written in C, or another high-level language, the unlock sequence should be performed by writing inline assembly or using built-in functions provided by the MPLAB® C30 C Complier."

Il y a d'ailleurs, si tu es allergique à l'assembleur, il existe des fonctions _builtin fournies par le compilateur C30 qui font la même chose que ce que j'ai montré : __builtin_write_OSCCONL(value) et __builtin_write_OSCCONH(value) (Voir le manuel des librairies du C30).

La nécessité de l'assembleur est que c'est la seule manière de garantir que la suite d'instructions assembleur seront exécutées l'une après l'autre.

a+

[invited5b3bb8b]

Bonjour,

A ok merci beaucoup je comprends mieux cette fonction "__builtin_write_OSCCONL(value )", Je l'avais déjà rencontré mais je ne trouvais pas le sens.

Seul chose également pour configurer les sorties TX et RTS
"RPOR12bits.RP25R = 5;" je comprends pas la première partie avec "RPOR12bits"
Moi je voulais placé TX sur RP10 donc est-ce que cela fonctionne : "RPOR1bits.RP10R = 3;" mais le "1bits" je l'ai un peu mis au hasard.

Encore merci pour vos réponses.

[invitef87f72a7]

bonjour tout le monde,
je suis egalement intéressé par l'utilisation des uart avec un pic 24fj64ga02.

j'explique mon problème:

sur l'uart2 j'ai 3 données a lire, pour cela je change l'affectation des pin pour UART2

	if (data == 0) RPINR19bits.U2RXR = 15;
	if ( data == 1) RPINR19bits.U2RXR = 14;
	if (data == 2) RPINR19bits.U2RXR = 13;

cela fonctionne très bien.

Dans une autre partie du programme je veux lire et écrire sur 2 RS232. (seulement RX et TX)

Rx1 => RB7
Tx1 => RB6

Rx2 => RB3
Tx2 => RB2



envois du 1er message + réponse

RPINR18bits.U1RXR = 7;   // car  RX=> pin RP7
RPOR3bits.RP6R = 3;	//  car TX => Pin RP6

putrsUART(ATZ); //rst modem
j = ReadUART(); // lecture de la réponse "OK"

la même chose sur la seconde RS232

RPINR18bits.U1RXR = 3;   // car RX=> pin RP3
RPOR1bits.RP2R = 3;	//  car TX => Pin RP6

putrsUART(ATZ); //rst modem
j = ReadUART(); // lecture de la réponse "OK"

// PORTB Direction and initial status
//                     +---------------- RB15 = 
//                     |+--------------- RB14 = 
//                     ||+-------------- RB13 = 
//                     |||+------------- RB12 = CSM
//                     ||||+------------ RB11 = SDI
//                     |||||+----------- RB10 = SDO
//                     ||||||+---------- RB9  = SCLK
//                     |||||||+--------- RB8  = CSE
//                     ||||||||+-------- RB7  = RX
//                     |||||||||+------- RB6  = TX
//                     ||||||||||+------ RB5  = LED
//                     |||||||||||+----- RB4  = OSC32
//                     ||||||||||||+---- RB3  = Rx
//                     |||||||||||||+--- RB2  = Tx
//                     ||||||||||||||+-- RB1  =	ICSP
//                     |||||||||||||||+- RB0  = ICSP
#define INIT_TRISB  (0b1110100010011000)

seulement voila les deux message parte sur la même RS232, a savoir (RB6 et RB7)


avez vous une idées?


en vous remerciant pour vote aide !

[invitef87f72a7]

je rectifie :

RPINR18bits.U1RXR = 3;   // RX=> pin RP3
RPOR1bits.RP2R = 3;	// TX => Pin RP2   ET NON RP6

putrsUART(ATZ); //rst modem
j = ReadUART(); // lecture de la réponse "OK"

[invited5b3bb8b]

Moi en fait je n'arrive pas du tout à renvoyer des choses sur l'UART.
Normalement une fois toutes les initialisations faites si j'envoie ce code

	U1STAbits.UTXEN = 0; //reset du buffer
	while(U1STAbits.UTXBF);
	U1TXREG= 0x0032;
	while(U1STAbits.TRMT==0);

Ca devrait fonctionner non?

[invitef87f72a7]

Comment fait tu pour verifier que tu n'envoie rien ?

j'utilise la fonction du code microchip

void putstrUART(unsigned int *buffer)
{
    char * temp_ptr = (char *) buffer;

    // transmit till NULL character is encountered
    if(UART_MODEbits.PDSEL == 3)        // check if TX is 8bits or 9bits
    {
        while(*buffer != 0x00) 			//'\0') 
        {
            while(UART_STAbits.UTXBF); // wait if the buffer is full

            UART_TXREG = *buffer++;    // transfer data word to TX reg
        }
    }
    else
    {
        while(*temp_ptr != 0x00)				//'\0')
        {
            while(UART_STAbits.UTXBF);  // wait if the buffer is full

            UART_TXREG = *temp_ptr++;   // transfer data byte to TX reg
        }
    }
}

[invited5b3bb8b]

Ben je regardais à la broche correspondante le signal sur un oscilloscope.
Sinon maintenant j'arrive à envoyer mais pas sur les broches que je veux.
RP10, RP11 ça ne fonctionne pas.

[RISC]

Salut,

Plusieurs choses très importantes concernant le PPS :

1/ il faut choisir le mode d'utilisation du PPS dans les bits de configuration : statique ou dynamique. Si on choisit statique on ne peut programmer le PPS qu'une seule fois. Si on choisit dynamique on peut reprogrammer le PPS à tout moment, à condition d'utiliser A CHAQUE FOIS qu'on change l'utilisation des broches les fonctions de Lock() et Unlock() sans quoi les broches ne changent pas.

2/ Concernant les registres de programmation, il faut impérativement lire la documentation (le chapitre du Reference Manaual sur le PPS que j'ai déjà cité précédemment).
Les registres RPINR permettent d'affecter des entrées à un ou plusieurs périphériques en entrée.
Les registres RPOR permettent d'affecter une ou plusieurs sorties à des périphériques en sortie.

a+

[invited5b3bb8b]

Bonjour à tous,
Bon voila, j'arrive à envoyer des données grâce à une liaison ZIGBEE et à les recevoir. par contre je n'arrive à traiter les données.
J'explique, je veux que suivant une valeur reçue (exemple : 0x01) j'envoie une trame, mais là ca ne fonctionne pas.
Voila ce que j'ai écrit dans mon programme principal :

while(1)
{
    if (U1RXREG == 0x01)
    {
          mise_en_forme_C02();
          EnvoyerUart(Tab_message_envoyer);
          for(i=0;i<20000;i++);
    }
}

Les 3 lignes à l'intérieur de la fonction if fonctionne correctement si on laisse seulement ça.
Je sais qu'il existe l'interruption mais on veut d'abord tester en scrutation.
Merci pour votre aide.

[RISC]

Salut,

Avant de tester une valeur précise dans U1RXREG, il faut (en mode scrutation) :
* attendre qu'un valeur soir recue
* être sur que la transmission s'est bien passée et que le caractère a été reçu correctement....c'est à dire vérifier que I1FS4bits.U1ERIF <> 0

Tout bon logiciel de gestion UART devrait toujours vérifier les erreurs de réception avant de lire le caractère reçu...cela évite de tester des caractères erronés.

Cela permet de voir également qu'on a des PB de réceptions lors de la mise au point :

  if (I1FS4bits.U1ERIF == 1)
    {
          traitement_erreur_reception();
          I1FS4bits.U1ERIF == 0;
    }

Pour le reste ton message n'est pas clair...je n'ai pas bien compris la différence entre ce qui fonctionne ou pas....

Es-tu sur que c'est le caractère 0x01 que tu dois recevoir (c'est la valeur ASCII de "SOH" ?

Es-tu sûr que la réception fonctionne ? Comment en es-tu sûr ?

a+
a+