R8C UART Problem

Bei te_u1c1 ist t ein T wie in Transmission d.h. Senden. Du musst beim 
Empfänger das re_u1c1 Bit (Enable Reception) auf 1 setzen.

Wie sieht der Codeteil in der UART-Empfängerroutine aus? Denkst du daran 
den RXError (u1rbh) auszulesen, damit ri_u1c1 gelöscht wird?

Hallo,

das T für transmit steht hab ich schon verstanden. Es steht aber im 
Datenblatt, dass dieses Bit auf 1 gesetzt werden soll.........
Hier mein Code:

Zuerst Variablendefinition (fehlt hier)

void read_from_uart(void)
{


  te_u1c1=1;
  re_u1c1=1;

  while(zaehler<13)
  {
   if (ri_u1c1==1) <-- Hier bleibt der Debugger stehen!
   {
    telegramm[zaehler] = u1rbl;
          RXError = u1rbh;
    zaehler++;
   }
  }

  re_u1c1=0;
  te_u1c1=0;
  zaehler=0;

}
void main(void)
{
      zaehler=0;
  u1brg=0x81;    // Bautrate einstellen 9600
  u1mr=0x05;    // 8Datenbits/Int.Clock/1Stopbit/NoParity
  u1c0=0x00;    // LSB zuerst??????Evt. umdrehen
  u1rrm_u1c1=0;  // kontinierlich empfangen aus
  u1pinsel=1;    // P6_6 undP6_7 arbeiten als Uart1

  while(1)
  {
  read_from_uart();
  }
}

Danke und Grüße
han

Den Kommentar "<-- Hier bleibt der Debugger stehen!" verstehe ich nicht.

Kommt der Debugger, weil ein Programmabsturz passiert? Kommt der 
Debugger, weil du ein Trace auf ri_u1c1 sitzen hast? Kommt der Debugger, 
weil du einen Breakpoint gesetzt hast? Wenn ja - Wo sitzt dein 
Breakpoint und welche Werte haben die Variablen?

Wenn du dich wunderst, dass ri_u1c1 auf 1 bleibt; das wird erst 
automatisch gelöscht, wenn u1rbh ausgelesen wird.

Die Initialisierung sieht OK aus, bis auf

1

u1pinsel=1;   // P6_6 (=>TX) und P6_7 (=>RX) arbeiten als Uart1

Da müsste laut Hardwaremanual noch PD6_7 im PD6 Register auf 0 (d.h. als 
Inputpin)gesetzt werden. Und zwar als erster Punkt der UART 
Initialisierung. Wäre einen Versuch Wert.

Die Einlesefunktion würde ich eher so machen:

1

void read_from_uart(void)

2

{

3

  zaehler=0; // Initialisierung nicht so weit weg, beruhigt die Nerven ;-)

4

  while(zaehler<13)

5

  {

6

    /* Zeichen am Empfang (RX) abholen */

7

    /* Warten bis Empfangspuffer mit Bits voll ist */

8

    while(!ri_u1c1)

9

       ;

10

11

    /* dann Empfangspuffer auslesen */

12

    telegramm[zaehler] = u1rbl; // <-- hier BREAKPOINT setzen

13

    RXError = u1rbh;    // ggf. hier im Fehlerfall ein break und 

14

                        // später zaehler als Rückgabewert auswerten

15

    zaehler++;

16

  }

17

  telegramm[zaehler]=0; // Stringabschluss beruhigt die Nerven ;-)

18

}

19

20

void main(void)

21

{

22

  // Normale Initialisierung (Clock, Ports etc.)

23

24

  // UART Initialisierung

25

  u1brg=0x81;   // Bautrate einstellen 9600

26

  u1mr=0x05;    // 8Datenbits/Int.Clock/1Stopbit/NoParity

27

  u1c0=0x00;    // LSB zuerst?????? 

28

                // Ja, ist bei UART normal

29

                // http://www.mikrocontroller.net/articles/UART

30

  u1rrm_u1c1=0; // kontinierlich empfangen aus

31

  u1pinsel=1;   // P6_6 undP6_7 arbeiten als Uart1

32

33

  // UART Einschalten

34

  te_u1c1=1;    // UART-Sender ein (aber derzeit unbenutzt)

35

  re_u1c1=1;    // UART-Empfänger ein

36

37

  while(1)

38

  {

39

    read_from_uart();

40

  }

41

}

Im Hardwaremanual steht übrigens eine Notiz drin, dass man u1rb als 
16-Bit Register auslesen soll. Bisher hatte ich aber noch keine Probleme 
mit zwei getrennten 8-Bit Zugriffen (allerdings war das ein R8C/13)

Die Alternative sähe so aus

1

  {

2

     unsigned int dummy;

3

     dummy = u1rb;

4

     telegramm[zaehler] = (unsigned char) (dummy & 0x00FF); 

5

     RXError = (unsigned char) (dummy>>8);

6

  }

Hallo Stefan,

Danke für Deine Antwort.

Der Debugger bleibt stehen ist eigentlich falsch ausgedrückt. Eigentlich 
bleibt das Programm stehen. Aber nicht weil es abstürzt oder so , 
sondern weil das ri_u1c1 -Flag nicht auf "1" gesetzt wird obwohl ich 
Daten an die UART sende (Timing stimmt, hab ich alles nachgemessen).
Ich habe mir eigentlich gedacht, dass ich den Empfänger mit Debbuger 
laufen lasse (Run), dann an der Stelle die Du markiert hattest einen 
Breakpoint setze (telegramm[zaehler] = u1rbl; // <-- hier BREAKPOINT 
setzen) dann die Daten sende. Nun sollte eigentlich das Programm am 
Breakpoint halten. Das tut es aber nicht. Wenn ich dann den Debugger 
anhalte steht er in der Zeile: while(!ri_u1c1).

Uart1 Pin RxD und TxD hatte ich in einem anderen File, welches mit 
compiliert wird auf "0" gesetzt.

Ich werde jetzt Deine Lösung genau anschauen und das ganze nochmals 
probieren.

Danke und Grüße
han

Welchen Debugger nimmt du?

Wenn es einer der "normalen" On-Chip-Debugger (FoUSB/UART-Debugger, E8 
Emulator Debugger) ist, kannst du auf die Register und TXD1/RXD1 von 
UART1 nicht zugreifen. Beim E8 steht im User Manual: "UART1 is used by 
the E8 emulator. Do not use UART1 in the user program.". Was passiert, 
wenn du dein Programm auf UART0 abänderst?

Den "exotischen" Emulator Debugger PC7501, der den kompletten µC 
emuliert, wirst du IMHO nicht haben, oder?

Hallo,

Danke für die Antwort.

Ich hab den E8 und werde mal auf UART0 umschalten.......

Danke und Grüße
han

Hallo,

so wie es aussieht funktionert es nun. Hab auf UART0 umgeschaltet. Ich 
möchte aber auch noch die UART1 ohne E8 testen......

Grüße und Danke
han

Gibt es bei der UART1 noch was besonderes zu beachten?? Was muss ich mit 
dem Pin 6_5 machen soll ich den als Input schalten und auf "0" legen?

Was ist ein R8C1B??

Grüße

Ok habs. UART1 läuft auch........

Aber trotzdem was ist R8C1B??

Grüße

> Aber trotzdem was ist R8C1B??

Ein lax geschriebener µC aus der R8C/1B Gruppe

http://www.renesas.com/fmwk.jsp?cnt=r8c1b_root.jsp&fp=/products/mpumcu/m16c_family/r8c_tiny_series/r8c1b_group/

ach ja ok, wusste nicht, dass es unter diesem Begriff ein Controller 
gibt.

Grüße
han