Übertragung PIC24 zu WLAN-Modul über UART2

[Gisti (Gast)]

Bei dem Versuch ein WLAN Modul über UART zu initialisieren habe ich 
UART2 wie unten dargestellt initialisiert:

Bei debuggen habe ich jetzt festgestellt, dass beim Einlesen eines 
Characters (z.B.

 U2TXREG = '1';

) das U2TXREG bzw U2RXREG, also das Transceive Register bzw. das 
Transmit Register immer "leer bleiben" (also Value: 0xOOOO bzw Char: 
"..."). Ich habe versucht beim Setup für UART Transmit mich genau an die 
Schritte im Datenblatt zu halten, trotzdem scheint es noch irgendwo bei 
der Initialisierung zu haken. Jemand ne Idee was ich falsch gemacht 
haben könnte?

    #define FCY 10000000    // FCY = FOSC/2
    #define BAUDRATE 9600
    #define BRGVAL ((FCY/BAUDRATE)/16)-1

    U2MODEbits.BRGH = 0;  // Bit3 16 clocks per bit period, BRGH = 0: BRG generates 16 clocks per bit period (16x baud clock, Standard mode)
    U2BRG = BRGVAL; // Baud Rate setting for 9600
    

    // 9600 baud, 8 bits data, 1 stop bit, no parity, and no flow control
    // 2.
    U2MODEbits.PDSEL = 0;  // Bits1,2 8bit-data, No Parity, PDSEL = 0: 8-bit data, no parity
    U2MODEbits.STSEL = 0;  // Bit0 One Stop Bit, STSEL = 0: One Stop bit

    //  Later, receive interrupts are enabled. Transmit interrupts remain disabled.
    // 3.
    IEC1bits.U2TXIE = 0;  // disable Transmit Interrupts
    IEC1bits.U2RXIE = 0;  // disable Recieve InterruptsU2STAbits.URXISEL = 0;      //  UARTx Receive Interrupt Mode Selection bits; 0x  = Interrupt flag bit is set when a character is received
    U2MODEbits.UEN = 0;     // Bits8,9 TX,RX enabled, CTS,RTS not, -> no Flo Control

    // Peripheral Pin Select
    // URX
    TRISFbits.TRISF4 = 1;  // RF4 input - U2RX pin;    /*  Uart Rx is an input */
    RPINR19 = 0;
    RPINR19bits.U2RXR = 0b1100100; // RF4 pin - RP100 assigned to U2RX function


    // UTX
    TRISFbits.TRISF5 = 0; // RF5 output - U2TX pin;  /*  Uart Tx is an output */
    RPOR9 = 0;
    RPOR9bits.RP101R = 0b000011; // RF5 as U2TX; RP101 tied for UART2 transmit

    // 5.
    U2MODEbits.UARTEN = 1;  // 1 = UARTx is enabled; all UARTx pins are controlled by UARTx as defined by UEN<1:0>
    // The UTXEN bit should not be set until the UARTEN bit has been set; otherwise UART transmissions will not be enabled.

    // 6.
    U2STAbits.UTXEN = 1;    // Bit10 TX pins controlled by periph, UTXEN = 1:  Transmit  is  enabled,  U2TXIF is set

[Hermann U. (Firma: www.pcb-devboards.de) (gera82)]

Gisti schrieb:
> // Peripheral Pin Select
>     // URX
>     TRISFbits.TRISF4 = 1;  // RF4 input - U2RX pin;    /*  Uart Rx is an
> input */
>     RPINR19 = 0;
>     RPINR19bits.U2RXR = 0b1100100; // RF4 pin - RP100 assigned to U2RX
> function
>
>     // UTX
>     TRISFbits.TRISF5 = 0; // RF5 output - U2TX pin;  /*  Uart Tx is an
> output */
>     RPOR9 = 0;
>     RPOR9bits.RP101R = 0b000011; // RF5 as U2TX; RP101 tied for UART2
> transmit

auf die schnelle aufgefallen, ändere das mal:

     // URX
     TRISFbits.TRISF4 = 1;  // RF4 input - U2RX pin;    /*  Uart Rx is an input */

     // UTX
     TRISFbits.TRISF5 = 0; // RF5 output - U2TX pin;  /*  Uart Tx is an output */


      __builtin_write_OSCCONL(OSCCON & (~(1<<6))); // clear bit 6 

        RPINR19 = 0;
        RPINR19bits.U2RXR = 0b1100100; // RF4 pin - RP100 assigned to U2RX 
        RPOR9 = 0;
        RPOR9bits.RP101R = 0b000011; // RF5 as U2TX; RP101 tied for UART2 

      __builtin_write_OSCCONL(OSCCON | (1<<6));    // Set bit 6

Gruß
Hermann

[Gisti (Gast)]

Danke sehr. War leider erfolglos.

[Hermann U. (Firma: www.pcb-devboards.de) (gera82)]

Gisti schrieb:
> Danke sehr. War leider erfolglos.

Ja was heißt es, kommt am TXPin nichts raus, hast du ein OSZI da?

Oder kommt was falsches raus, dann stimmen die Timings nicht, Zb. 
Einstellung von QUARZ:

/* Macros for Configuration Fuse Registers :*/
_FOSCSEL(FNOSC_PRIPLL & IESO_OFF)
_FOSC   (POSCMD_XT & OSCIOFNC_OFF & IOL1WAY_OFF & FCKSM_CSECMD)

oder Takteinstellung z.B.:

/********************************************************************************
 *                                                                              *
 *  Funktion:      OSCswitching                                                 * 
 *                                                                              *
 *------------------------------------------------------------------------------*
 *  Description: 
 ********************************************************************************/
void OSCswitching(void) 
{
   
// Hier muss dann einstellen
// PLLFBD = ?;    /* M = ? */
// CLKDIVbits.PLLPOST = ?;  /* N1 = ? */
// CLKDIVbits.PLLPRE = ?;  /* N2 = ? */

 CLKDIVbits.DOZEN = 0;  /* Processor clock and peripheral clock ratio forced to 1:1 */

 RCONbits.SWDTEN = 0; //Disable Watch Dog Timer

 __builtin_write_OSCCONH(0b011);  //Initiate clock switch to HS with PLL

 __builtin_write_OSCCONL(0b001);  //Start clock switching

 while (OSCCONbits.COSC != 0b011) //Wait for clock switch to occur

 while(OSCCONbits.LOCK!=1) {};    //Wait for PLL to lock
}

falls am TX Pin nichts raus kommt, dann ist die Einstellung von PIN (z.B 
Peripheral Pin Select etc.)

        // PORTF Einstellung: 
        LATF  = 0x0000;
        TRISF = (1 << 4);  // RF4 input - U2RX pin; // RF5 output - U2TX pin;
 //       CNENF = 0;  //CN PINS konfigurieren

PPS Einstellung:

      __builtin_write_OSCCONL(OSCCON & (~(1<<6))); // clear bit 6 

        RPINR19bits.U2RXR = 100;     // RF4 pin - RP100 assigned to U2RX 
        RPOR9bits.RP101R = 0b000011; // RF5 as U2TX; RP101 tied for UART2 

      __builtin_write_OSCCONL(OSCCON | (1<<6));    // Set bit 6

Und als letztes kommt UART Einstellung:

    #define FCY 10000000UL    // FCY = FOSC/2
    #define BAUDRATE 9600UL
    #define BRGVAL ((FCY/BAUDRATE)/16UL)-1UL

// UART2
       U2MODEbits.USIDL = 0;        /* Continue in Idle mode */
       U2MODEbits.LPBACK = 0;        /* Disable LoopBack */
       U2MODEbits.PDSEL = 0b00;      /* 8-bit data, no parity */
       U2MODEbits.STSEL = 0;        /* One Stop bit */
                       
       U2BRG = BRGVAL;              /* Baud rate generator */

       IFS1bits.U2RXIF = 0;        /* Clear interrupt flag */
       IPC7bits.U2RXIP = 5;        /* Set to highest priority */
       IEC1bits.U2RXIE = 1;        /* Enable receive interrupts */

    
       U2MODEbits.UARTEN = 1;              /* Enable UART module 2 */
       U2STAbits.UTXEN = 1;              /* Enable transmission, overrides TRIS settings */

Gruß
Hermann

[Gisti (Gast)]

Hallo und vielen Dank für die ausführliche Antwort.
Dann mal von Anfang an:

Ich nutze internen FRC mit PLL.

_FOSCSEL(FNOSC_FRCPLL);      // Internal FRC oscillator with PLL
_FOSC(FCKSM_CSDCMD & OSCIOFNC_ON  & POSCMD_NONE);
              // Clock Switching is enabled and Fail Safe Clock Monitor is disabled
              // OSC2 Pin Function: OSC2 is Clock Output
              // Primary Oscillator Mode: XT Crystanl

_FWDT(FWDTEN_OFF); // Watchdog Timer enabled/disabled by user software
_FICD(ICS_PGD1 & JTAGEN_OFF); // Communication Channel: PGC1/EMUC1 and PGD1/EMUD1

Die Takteinstellung habe ich wie folgt vorgenommen:
Ich bekomme eine Oszillatorfrequenz von 21MHz -> Inputclock: Fcy=Fosc/2 
= 10,5 MHz. Diese errechnete Frequenz nutze ich auch als define FCY 
10500000 über die die Baudrate ermittelt wird.

 // Fosc= 7.37M*40/(2*7)=21Mhz für 10,5 Mips Input Clock =Fcy; 7.37 da OSCTUN = 0b000000
    PLLFBD = 38; // M=40
    CLKDIVbits.PLLPOST = 0b00; // N2=2
    CLKDIVbits.PLLPRE = 0b00101; // N1=7
    OSCTUN = 0;             // Tune FRC oscillator
    RCONbits.SWDTEN = 0; // Disable Watch Dog Timer " "RCON Control register; SWDT: 1: WDT is enabled 0: WDT disabled"

Das Peripheral Pin Select nehme ich für UTX bzw. RTX wie folgt vor:

// Peripheral Pin Select
    // URX
    TRISFbits.TRISF4 = 1;  // RF4 input - U2RX pin;    /*  Uart Rx is an input */
    RPINR19 = 0;
    RPINR19bits.U2RXR = 0b1100100; // RF4 pin - RP100 assigned to U2RX function


    // UTX
    TRISFbits.TRISF5 = 0; // RF5 output - U2TX pin;  /*  Uart Tx is an output */
    RPOR9 = 0;
    RPOR9bits.RP101R = 0b000011; // RF5 as U2TX; RP101 tied for UART2 transmit

Abschließend die UART Einstellung:

#define FCY 10500000ULL    // FCY = FOSC/2 unsigned long long
#define BAUDRATE 9600
#define BRGVAL ((FCY/BAUDRATE)/16)-1

// configure U2MODE
  U2MODEbits.UARTEN = 0;  // Bit15 TX, RX DISABLED, ENABLE at end of func
  //U2MODEbits.notimplemented;  // Bit14
  U2MODEbits.USIDL = 0;  // Bit13 Continue in Idle
  U2MODEbits.IREN = 0;  // Bit12 No IR translation
  U2MODEbits.RTSMD = 0;  // Bit11 Simplex Mode
  //U2MODEbits.notimplemented;  // Bit10
  U2MODEbits.UEN = 0;    // Bits8,9 TX,RX enabled, CTS,RTS not
  U2MODEbits.WAKE = 0;  // Bit7 No Wake up (since we don't sleep here)
  U2MODEbits.LPBACK = 0;  // Bit6 No Loop Back
  U2MODEbits.ABAUD = 0;  // Bit5 No Autobaud (would require sending '55')
    // Load a value into Baud Rate Generator.  Example is for 9600.
    // See section 19.3.1 of datasheet.
    //  U2BRG = (Fcy/(16*BaudRate))-1
    //  U2BRG = (10,5/(16*9600))-1, INPUT CLOCK Fcy = 10,5MHz
   

    // 1.
    U2MODEbits.BRGH = 0;  // Bit3 16 clocks per bit period, BRGH = 0: BRG generates 16 clocks per bit period (16x baud clock, Standard mode)
    U2BRG = BRGVAL; // Baud Rate setting for 9600
    // U2BRG = 67;  // 10Mhz osc, 9600 Baud, 8 Datenbit, 1 Stopbit, Kein Parity Bit, keine Flow Kontrolle

    // 9600 baud, 8 bits data, 1 stop bit, no parity, and no flow control
    // 2.
    U2MODEbits.PDSEL = 0;  // Bits1,2 8bit-data, No Parity, PDSEL = 0: 8-bit data, no parity
    U2MODEbits.STSEL = 0;  // Bit0 One Stop Bit, STSEL = 0: One Stop bit

    //  Later, receive interrupts are enabled. Transmit interrupts remain disabled.
    // 3.
    IEC1bits.U2TXIE = 0;  // disable Transmit Interrupts
    IEC1bits.U2RXIE = 0;  // disable Recieve Interrupts

    // Transmit Interrupts ganze Zeit disabled, received Interrupts später enabled -> main
    // 4.

    // Load all values in for U1STA SFR
  U2STAbits.UTXISEL1 = 0;  //Bit15 Interrupt when Char is transferred (1/2 config!)
  U2STAbits.UTXINV = 0;  //Bit14 N/A, IRDA config, hier: IREN = 0 -> UTXINV = 0:
  U2STAbits.UTXISEL0 = 0;  //Bit13 Other half of Bit15
  //U2STAbits.notimplemented = 0;  //Bit12
  U2STAbits.UTXBRK = 0;  //Bit11 Disabled
  U2STAbits.UTXEN = 0;  //Bit10 TX pins controlled by periph
  U2STAbits.UTXBF = 0;  //Bit9 *Read Only Bit*
  U2STAbits.TRMT = 0;  //Bit8 *Read Only bit*
  // U2STAbits.URXISEL = 0;  //Bits6,7 Int. on character recieved
  U2STAbits.ADDEN = 0;  //Bit5 Address Detect Disabled
  U2STAbits.RIDLE = 0;  //Bit4 *Read Only Bit*
  U2STAbits.PERR = 0;    //Bit3 *Read Only Bit*
  U2STAbits.FERR = 0;    //Bit2 *Read Only Bit*
  U2STAbits.OERR = 0;    //Bit1 *Read Only Bit*
  U2STAbits.URXDA = 0;  //Bit0 *Read Only Bit*
        
        U2STAbits.URXISEL = 0;      //  UARTx Receive Interrupt Mode Selection bits; 0x  = Interrupt flag bit is set when a character is received
        U2MODEbits.UEN = 0;     // Bits8,9 TX,RX enabled, CTS,RTS not, -> no Flo Control


    // 5.
    U2MODEbits.UARTEN = 1;  // 1 = UARTx is enabled; all UARTx pins are controlled by UARTx as defined by UEN<1:0>
    // The UTXEN bit should not be set until the UARTEN bit has been set; otherwise UART transmissions will not be enabled.

    // 6.
    U2STAbits.UTXEN = 1;    // Bit10 TX pins controlled by periph, UTXEN = 1:  Transmit  is  enabled,  U2TXIF is set

Ich versuche nun einen String einzu lesen über die beiden Funktionen:

void ConsolePut(char c)
{
        // while( !ConsoleIsPutReady() );
        while(!(U2STAbits.TRMT)); // 1  = Transmit  Shift  Register  is  empty  and  the  transmit  buffer  is  empty
//        while ( U2STAbits.UTXBF);   // wait while Tx buffer full
        // (i.e.,  the  last  transmission  has completed)
        U2TXREG = c;
}
void ConsolePutString(char* str)
{
    char c;

    while( (c = *str++) )
        ConsolePut(c);
}

Ich lese folgenden String ein:

ConsolePutString("$$$");

Als Antwort der WLAN Moduls würde ich den String "CMD" erwarten.
Wie kann ich überprüfen, ob ich diesen String empfangen habe?

Ich habe mir das so überlegt, dass ich das U2RXREG Register in einem 
Char speichere und diesen dann in einem Array ablege.
Das sieht dann im Code wie folgt aus:

char data;
char output[256]={0};
int y = 0;

while (1)
    {

            while(U2STAbits.URXDA) // 1  = Receive buffer has data; at least one more character can be read
            {
                data = U2RXREG;
                output[y++] = data;

            }


    }

Dieses Array kann ich jetzt vermutlich nur im Debugg- Modus auslesen. 
Ich hätte jetzt vermutet dass am Ende des Programms (d.h. nach einiger 
Wartezeit nach Senden des Arrays) sich die erwartete Antwort "CMD" des 
Moduls befinden müsste. Gibt es Möglichkeiten außerhalb des Debug Modus 
das Array auszulesen?

Gibt es andere Alternativen das Received Register auszulesen und zu 
illustrieren?

Vielen Dank schon mal!

[Hermann U. (Firma: www.pcb-devboards.de) (gera82)]

Ist dein Aufbau korrekt, TX/RX Pins nicht verrauscht/kurzgeschlossen?
Was für ein µC Typ hast du? Guckmal die Errata, vielleicht steht ja was 
über UART2 drinne.

Gisti schrieb:
> Ich lese folgenden String ein:
> ConsolePutString("$$$");
> Als Antwort der WLAN Moduls würde ich den String "CMD" erwarten.
> Wie kann ich überprüfen, ob ich diesen String empfangen habe?

Kannst du das mit einem Oszilloskop überprüfen, damit kannst du Fehler 
auf Minimum einkreisen.
http://de.wikipedia.org/wiki/UART

Bitdauer korrekt, 104µs?

Gisti schrieb:
> Dieses Array kann ich jetzt vermutlich nur im Debugg- Modus auslesen.
Ja genau unter "Watch" kannst die output[256] Array ansehen.

Gisti schrieb:
> Gibt es Möglichkeiten außerhalb des Debug Modus
> das Array auszulesen?
Ja zum Beispiel am Display, wenn du ein angeschlossen hast ;-)

Gisti schrieb:
> Gibt es andere Alternativen das Received Register auszulesen
ja ich mach das im Interrupt, das musst du natürlich erst einschalten:

    IEC1bits.U2RXIE = 1;  // Recieve Interrupts

void __attribute__((__interrupt__,no_auto_psv)) _U2RXInterrupt(void)
{
  

  IFS1bits.U2RXIF = 0; // clear RX interrupt flag

/* Check for receive errors */
  if(U2STAbits.FERR == 1)
   {
    }
/* Must clear the overrun error to keep UART receiving */
  if(U2STAbits.OERR == 1)
    {
    U2STAbits.OERR = 0;
    }
   /* Get the data */
    if(U2STAbits.URXDA == 1)
     {
       ReceivedEncPosition[PAOi] = U2RXREG & 0b01111111; //7 bit
       PAOi++;
     
     }
 
}

Gruß
Hermann