Connexion de deux kits de démarrage PIC18F en utilisant USART2

Question

Je souhaite connecter deux kits de démarrage PIC18F (avec PIC18F46J50) en utilisant RS232. Comme USART1 est déjà connecté au lecteur de cartes (intégré), je dois utiliser USART2 (j'ai besoin de remapper RX2/TX2 sur les broches RP19/RP20-RD2/RD3).

Je l'ai déjà trouvé un code de démonstration pour l'envoi:

#define _XTAL_FREQ 8000000 //The speed of your internal(or)external oscillator 
#include <p18cxxx.h> 
#include <usart.h> 
int i = 0; 

// CONFIG1L 
#pragma config WDTEN = OFF   // Watchdog Timer (Disabled - Controlled by SWDTEN bit) 
#pragma config PLLDIV =3   // PLL Prescaler Selection bits - Divide by 3 (12 MHz oscillator input) 
#pragma config STVREN = ON   // Stack Overflow/Underflow Reset (Enabled) 
#pragma config XINST = OFF   // Extended instruction set disabled 

// CONFIG1H 
#pragma config CPUDIV = OSC1  // CPU System Clock Postscaler (No CPU system clock divide) 
#pragma config CP0 = OFF   // Code Protect (Program memory is not code-protected) 

// CONFIG2L 
#pragma config OSC = HSPLL   //HS oscillator, PLL enabled, HSPLL used by USB 
#pragma config T1DIG = ON   // T1OSCEN Enforcement (Secondary Oscillator clock source may be selected) 
#pragma config LPT1OSC = OFF  // Low-Power Timer1 Oscillator (High-power operation) 
#pragma config FCMEN = OFF   //Fail-Safe Clock Monitor disabled 
#pragma config IESO = OFF   //Two-Speed Start-up disabled 

// CONFIG2H 
#pragma config WDTPS = 32768  // Watchdog Postscaler (1:32768) 

// CONFIG3L 
#pragma config DSWDTOSC = INTOSCREF // DSWDT Clock Select (DSWDT uses INTRC) 
#pragma config RTCOSC = T1OSCREF // RTCC Clock Select (RTCC uses T1OSC/T1CKI) 
#pragma config DSBOREN = OFF  // Zero-Power BOR disabled in Deep Sleep 
#pragma config DSWDTEN = OFF  // Deep Sleep Watchdog Timer (Disabled) 
#pragma config DSWDTPS = 8192  //1:8,192 (8.5 seconds) 

// CONFIG3H 
#pragma config IOL1WAY =OFF   //IOLOCK bit can be set and cleared 
#pragma config MSSP7B_EN = MSK7  // MSSP address masking (7 Bit address masking mode) 

// CONFIG4L 
#pragma config WPFP = PAGE_1  // Write/Erase Protect Page Start/End Location (Write Protect Program Flash Page 0) 
#pragma config WPEND = PAGE_0  //Start protection at page 0 
#pragma config WPCFG = OFF   //Write/Erase last page protect Disabled 

// CONFIG4H 
#pragma config WPDIS = OFF    //WPFP[5:0], WPEND, and WPCFG bits ignored 

#define USE_AND_MASKS 

unsigned char Txdata[] = "MICROCHIP_USART"; 
void Delay1Second(void); 

void main (void) 
{ 
    unsigned char spbrg=0,baudconfig=0,i=0; 

    // REMAPE ID PORT 

    PPSCON = 0x00;    // unlock peripheral Pin select register 
    RPOR19 = 0x05;    // assign USART2 TX to RP19/RD2 
    RPINR16 = 0x14;    // assign USART2 RX to RP20/RD3 
    PPSCON = 0x01;    // lock peripheral Pin select register 

    TRISDbits.TRISD2 = 0;  // TX2 output 
    TRISDbits.TRISD3 = 1;  // RX2 input 
//------USART Setup ---- 

    Close2USART(); //turn off usart if was previously on 

    spbrg = 51; 

    Open2USART(USART_TX_INT_OFF & 
       USART_RX_INT_OFF & 
       USART_ASYNCH_MODE & 
       USART_EIGHT_BIT & 
       USART_CONT_RX & 
       USART_BRGH_HIGH, spbrg); 

    baudconfig = BAUD_8_BIT_RATE & BAUD_AUTO_OFF; 
    baud2USART (baudconfig); 

    PORTB = 0x03; 

while(1){ 

//------USART Transmission ---- 
    while(Busy2USART());    //Check if Usart is busy or not 
    puts2USART((char *)Txdata);    //transmit the string 
    Delay1Second(); 
    Close2USART(); 
}       
} 

void Delay1Second() 
{ 
    for(i=0;i<100;i++) 
    { 
     __delay_ms(10); 
    } 
} 

Je connecté les deux cartes en utilisant deux fils (sur les broches D2 et D3), et je veux envoyer une chaîne de commission1 à board2. Je pense que j'ai besoin d'utiliser des interruptions pour lire, mais je n'ai trouvé aucun code de démo. De plus, je ne sais pas si les broches de configuration sont correctes. Quelqu'un peut-il me montrer comment recevoir le texte envoyé au tableau n ° 2?

Answer 1

Je suppose que vous avez fait le câblage correctement.

Vous n'avez pas besoin d'interruptions pour recevoir. Cela peut être utile mais ce n'est pas obligatoire. Pour recevoir votre chaîne, il vous suffit de faire:

gets2USART(str, 10); 

Si votre chaîne si 10 caractères (y compris la terminaison null).

Si vous souhaitez recevoir une chaîne d'une longueur arbitraire, vous pouvez écrire votre propre gets2USART à lire jusqu'au terminateur null. Il est en fait assez simple, voici le code source de gets2USART pour vous aider:

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

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

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

De plus, voici le code source de puts2USART:

void puts2USART(char *data) 
{ 
    do 
    { // Transmit a byte 
    while(Busy2USART()); 
    putc2USART(*data); 
    } while(*data++); 
} 

Vous pouvez voir qu'il ya déjà un while(Busy2USART()); , vous n'avez donc pas besoin d'en ajouter un. C'est logique, car l'UART est octet, donc il est occupé quand il envoie un octet, et la fonction doit vérifier chaque octet.

De plus, vous fermez l'UART après utilisation, mais vous bouclez en fait pour refaire l'envoi. Puisque vous venez de fermer l'UART, cela ne fonctionnera pas.