UART-Verbindung eines DSPIC30F4011 zu PC

Stefan Krüger Gast #7053564
Lesenswert?
• ▲
▼ 
Hallo zusammen,

ich bin aktuell an einem hauseigenen Projekt dran, worin ich einen 
Elektromotor mittels eines Motorcontrollers steuern möchte.

Hierbei arbeite ich aktuell an der Herstellung einer Verbindung meines 
Mikrocontroller DSPIC30F4011 und meinem PC. Als Test will ich dauerhaft 
das unsigned char "48" senden.

Leider scheitert mein Programmcode und ich kriege keine UART-Verbindung 
hergestellt, obwohl ich alles erdenkliche probiert habe. Habe ich einen 
Denkfehler mit den Ports?

Hat jemand Erfahrung oder sieht meinen Fehler in meinem Code?
Ich würde mich sehr über Unterstützung freuen, da ich seit Tagen in 
einer Sackgasse sitze.

Falls noch mehr Infos benötigt werden, kann ich diese sehr gerne geben.

Meinen Code findet ihr hier:

#pragma config FPR = FRC_PLL16
#pragma config FOS = FRC
#pragma config FCKSMEN = CSW_FSCM_OFF

#pragma config WDT = WDT_OFF
#pragma config FPWRT = PWRT_OFF

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <xc.h>
#include <libpic30.h>
#include <math.h>
#include "p30F4011.h"

#define FCY 30000000
#define MILLISEC FCY/30000
#define BAUD 9600               //Baudrate

unsigned char uc_data = 48;

void UART_Init();
void __attribute__((interrupt, no_auto_psv)) _U1TXInterrupt(void);

int main(void) {

    UART_Init();

    while(1)
    {
        printf("Hello\r\n"); // Send text via UART
        __delay32(30000000); // 1 second delay
    }
    return 0;
}

void UART_Init()
{
    TRISF = 0x0005;

    U1MODEbits.PDSEL = 0;
    U1BRG = 194;
    U1STAbits.URXISEL = 0;

    IPC2bits.U1TXIP = 4;
    IEC0bits.U1TXIE = 1;
    IFS0bits.U1TXIF = 0;

    U1MODEbits.UARTEN = 1;
    U1STAbits.UTXEN = 1;

    U1TXREG = uc_data;
}

void __attribute__((interrupt, no_auto_psv)) _U1TXInterrupt(void)
{
    U1TXREG = uc_data;
    IFS0bits.U1TXIF = 0;
}
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Stefan Krüger Gast #7053617
Lesenswert?
• ▲
▼ 
Ich verwende einen MK2 von myAVR.

Ich habe aber die Ausgänge TX und Ground an das Oszilloskop 
angeschlossen und erhalte auch kein Ausgangssignal. Da müsste man ja die 
Übertragung sehen können (bitweise).

Ich schließe einen Fehler des Oszis vorerst aus. Es geht um die 
Programmierung leider…
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Frank K. #7053751
Lesenswert?
• ▲
▼ 
Probiere das mal so:

1
#pragma config FPR = FRC_PLL16

2
#pragma config FOS = FRC

3
#pragma config FCKSMEN = CSW_FSCM_OFF

4


5
#pragma config WDT = WDT_OFF

6
#pragma config FPWRT = PWRT_OFF

7


8
#include <stdio.h>

9
#include <stdlib.h>

10
#include <stdint.h>

11
#include <xc.h>

12
#include <libpic30.h>

13
#include <math.h>

14
#include "p30F4011.h"

15


16
#define FCY 30000000

17
#define MILLISEC FCY/30000

18
#define BAUD 9600               //Baudrate

19


20
unsigned char uc_data = 48;

21


22


23
void UART_Init()

24
{

25
    TRISF = 0x0005;

26


27
    U1MODEbits.PDSEL = 0;

28
    U1BRG = 194;

29
    U1STAbits.URXISEL = 0;

30


31
    U1MODEbits.UARTEN = 1;

32
    U1STAbits.UTXEN = 1;

33
}

34


35
void UART_PutC(unsigned char c)

36
{

37
    U1TXREG = c;

38
  while(U1STAbits.UTXBF);

39
}

40


41
int main(void) {

42


43
    UART_Init();

44


45
    while(1)

46
    {

47
        UART_PutC(uc_data);

48
        __delay32(30000000); // 1 second delay

49
    }

50
    return 0;

51
}


Ohne Garantie - ich hab gerade keine so alten Kamellen da.

fchk
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Jobst M. #7054815
Lesenswert?
• ▲
▼ 
Stefan Krüger schrieb:
> Ich führe TX und Ground auf das Oszilloskop und erhalte nur einen 0
> Volt-Pegel.

Bei korrekt initialisierter Schnittstelle sollte das 1 sein.
Dort liegt dann Dein Problem.

Ich weiß nicht woher das Board ist, aber es gibt Teile, bei denen Rx und 
Tx vertauscht beschriftet sind, mit dem Hintergrund "da kommt Tx vom 
anderen Gerät dran."
Schau also auch mal, was auf Rx passiert.

Gruß
Jobst
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Stefan Krüger Gast #7055414
Lesenswert?
• ▲
▼ 
Servus, danke für deine Antwort.

Ich habe es jetzt mittels dem unten stehenden Code geschafft, eine 
Bitfolge darzustellen.

Leider schaffe ich es nicht, die Bitfolge zu verändern, indem ich andere 
Werte in das Register U2TXREG schreibe.

Wieso funktioniert das nicht?

1
#pragma config FPR = FRC_PLL16

2
#pragma config FOS = FRC

3
#pragma config FCKSMEN = CSW_FSCM_OFF

4


5
#pragma config WDT = WDT_OFF

6
#pragma config FPWRT = PWRT_OFF

7


8
#include <stdio.h>

9
#include <stdlib.h>

10
#include <stdint.h>

11
#include <xc.h>

12
#include <libpic30.h>

13
#include <math.h>

14
#include "p30F4011.h"

15
#include <time.h>

16


17
#define FCY 30000000

18
#define BAUD 9600               //Baudrate

19


20
void delay(int number_of_seconds)

21
{

22
    // Converting time into milli_seconds

23
    int milli_seconds = 1000 * number_of_seconds;

24
    // Storing start time

25
    clock_t start_time = clock();

26
    // looping till required time is not achieved

27
    while (clock() < start_time + milli_seconds) {};

28
}

29


30
    

31
void UART2_Init()

32
{

33
    U2MODEbits.PDSEL = 0;

34
    U2MODEbits.STSEL = 1;   // One ore two Stop bits

35


36
    U2BRG = 194; //Baudrate Predefiner

37


38
    U2MODEbits.UARTEN = 1; //Enabling UART

39
    

40
    U2STAbits.UTXEN = 1; //Enabling Transmission

41


42
    U2STAbits.URXISEL = 0b00;

43
}

44


45
void __attribute__((interrupt, no_auto_psv)) _U2TXInterrupt(void)

46
{

47
    U2TXREG = uc_data;

48
    IFS1bits.U2TXIF = 0b00;

49
}

50
    

51
int main(void) {

52


53
    UART2_Init();

54


55
    while (1) 

56
    {

57
        U2TXREG = "A"; //Erster Buchstabe

58
        delay(2);

59
        U2TXREG = "B"; //Zweiter Buchstabe stetig im Wechsel

60
        delay(2);

61
    }

62
        return 0;

63
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Stefan Krüger Gast #7055525
Lesenswert?
• ▲
▼ 
Servus Bernd,

ja die ist überflüssig, die habe ich jetzt mal weggemacht - Dennoch 
sieht mir die Bitfolge am Oszilloskop nicht nach meiner Eingabe aus.

1
//#pragma config FPR = FRC_PLL16

2
//#pragma config FOS = FRC

3
//#pragma config FCKSMEN = CSW_FSCM_OFF

4
//#pragma config WDT = WDT_OFF

5
//#pragma config FPWRT = PWRT_OFF

6


7
#include <stdio.h>

8
#include <stdlib.h>

9
#include <stdint.h>

10
#include <xc.h>

11
#include <libpic30.h>

12
#include <math.h>

13
#include "p30F4011.h"

14
#include <time.h>

15


16
#define FCY 30000000

17
#define BAUD 9600               //Baudrate

18


19
void delay(int number_of_seconds) {

20
    int milli_seconds = 1000 * number_of_seconds; // Converting time into milli_seconds

21
    clock_t start_time = clock(); // Storing start time

22
    while (clock() < start_time + milli_seconds) {}; // looping till required time is not achieved

23
}

24


25
void UART2_Init() {

26
    U2MODEbits.PDSEL = 0;

27
    U2MODEbits.STSEL = 1; // One ore two Stop bits

28


29
    U2BRG = 194; //Baudrate Predefiner

30


31
    U2MODEbits.UARTEN = 1; //Enabling UART

32
    U2STAbits.UTXEN = 1; //Enabling Transmission

33


34
    U2STAbits.URXISEL = 0;

35
}

36


37
int main(void) {

38
    UART2_Init();

39


40
    while (1) {

41
        U2TXREG = 0b10101010;

42
        delay(2);

43
        U2TXREG = 0b11111111;

44
        delay(2);

45
    }

46
    return 0;

47
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Frank K. #7055528
Lesenswert?
• ▲
▼ 
Stefan Krüger schrieb:

>         U2TXREG = "A"; //Erster Buchstabe
>         delay(2);

Das ist schon mal Unsinn. Du scheinst wohl ersthafte Probleme mit C zu 
haben, so dass Dir die einfachsten Grundlagen fehlen.

1. U2TXREG = "A"; ist in soweit Unsinn, als das "A" ein Zeiger auf einen 
Speicherbereich darstellt, der einen String mit den Werten 0x41 (ASCII 
A) und 0x00 (Stringende ) enthält.

Du willst U2TXREG = 'A'; Mit den einfachen Hochkomma bekommst Du den 
Wert des Zeichens.

2. delay(2); ist auch Unsinn.
Du schreibst in das TXREG Register und musst dann warten, bis es wieder 
frei ist. Das machst Du, indem Du das TXBF Bit im Statusregister 
abfragst, also:

U2TXREG = 'A';
while(U2STAbits.UTXBF);

fchk
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren