UART0 Programmierung M16C/62P

Guest
Hallo Zusammen

Ich möchte Euch um Rat fragen betreffend der Programmierung des UART0
auf meinem Glyn Board EVBM16C/62P
Zum schreiben des Codes verwende ich den Tasking Compiler.

Hier mal ein Auszug aus dem Code:
#define startbit 002
#define stoppbit 004

unsigned char rxchar;
int result;
int u;
char rxbuffer[10];

unsigned char x;
char size;

_interrupt(18) void
se_int_receive( void )
{
x = U0RBL;
switch ( x )
{
case startbit:
u = 0; //u ist ein Zähler - zähler auf 0 setzten
break;
case stoppbit: //kommt das stoppbit, alle rxbuffer addieren
result rxbuffer[0]+
rxbuffer[1]+
rxbuffer[2]+
rxbuffer[3];
break;
default:
u = 0; //
rxbuffer = x;//byte um byte in den rxbuffer
u++;
**************************************************************
Die Initialisierung der Schnittstelle sieht so aus:

flag_TI = 1;
U0BRG = 0x67; /* baudrate 9600
U0MR = 0x5; /* no parity, 8 data-bits, 1 stop-bit, internal clock
*/
U0C0 = 0x10; /* no cts/rts, prescaler = F1 */
U0C1 = 0x5; /* enable receiver and transmitter */

U0IRS = 1; /* TX complete */
U0RRM = 1; //UART0 continous mode oli
U0SMR = 0x2; //update per byte oli

S0TIC |= 0x6; /* Set UART0 transmit interrupt priority */
S0RIC |= 0x6; /* Set UART0 transmit interrupt priority */

PD6_3 = 1;
PD6_2 = 0;
*******************************************************************

Die Daten welche ich empfangen möchte mit 9600 baud sind:
<STX> [Byte1] [Byte2] [Byte3] [Byte4] <EOT>
*******************************************************************
Nun meine Problem ist, dass ich immer nur das erste Byte empfangen kann
und die anderen 3 nicht.
Das Start- und das Stoppbit spricht überhaubt nicht an.

Hat jemand ein Lösungsvorschlag für dieses Problem? wie ich auch die
anderen Bytes auswerten kann.
Stimmt die Initialisierung?
Evt. mache ich einen Grundsätzlichen Fehler, welchen ich mir gerne
erklären lasse.

oder Hat jemand eine lauffähige Routine um diese eingehenden Daten aus
4 Bytes abfragen zu können?

Besten Dank jetzt schon

Oli
 
huber_oliver@freesurf.chschrieb:
"
Hallo Zusammen

Ich möchte Euch um Rat fragen betreffend der Programmierung des UART0
auf meinem Glyn Board EVBM16C/62P
Zum schreiben des Codes verwende ich den Tasking Compiler.

Hier mal ein Auszug aus dem Code:
#define startbit 002
#define stoppbit 004

unsigned char rxchar;
int result;
int u;
char rxbuffer[10];

unsigned char x;
char size;

_interrupt(18) void
se_int_receive( void )
{
x = U0RBL;
switch ( x )
{
case startbit:
u = 0; //u ist ein Zähler - zähler auf 0 setzten
break;
case stoppbit: //kommt das stoppbit, alle rxbuffer addieren
result =
rxbuffer[0]+
rxbuffer[1]+
rxbuffer[2]+
rxbuffer[3];
break;
default:
u = 0; //
^^^^^^^^------- Das wird so nix!
Click to expand...

= x;//byte um byte in den rxbuffer
Hier wird dann immer in rxbuffer[0] geschrieben!
u++;
**************************************************************
Die Initialisierung der Schnittstelle sieht so aus:

flag_TI = 1;
U0BRG = 0x67; /* baudrate 9600
U0MR = 0x5; /* no parity, 8 data-bits, 1 stop-bit, internal clock
*/
U0C0 = 0x10; /* no cts/rts, prescaler = F1 */
U0C1 = 0x5; /* enable receiver and transmitter */

U0IRS = 1; /* TX complete */
U0RRM = 1; //UART0 continous mode oli
^^^^^^^^^^^^-- in der doc steht "Must always be "0""
U0SMR = 0x2; //update per byte oli
^^^^^^^^^^^^-- was ist das???

S0TIC |= 0x6; /* Set UART0 transmit interrupt priority */
S0RIC |= 0x6; /* Set UART0 transmit interrupt priority */

PD6_3 = 1;
PD6_2 = 0;
*******************************************************************

Die Daten welche ich empfangen möchte mit 9600 baud sind:
STX> [Byte1] [Byte2] [Byte3] [Byte4] <EOT
*******************************************************************
Nun meine Problem ist, dass ich immer nur das erste Byte empfangen kann
und die anderen 3 nicht.
Das Start- und das Stoppbit spricht überhaubt nicht an.

Hat jemand ein Lösungsvorschlag für dieses Problem? wie ich auch die
anderen Bytes auswerten kann.
Stimmt die Initialisierung?
Evt. mache ich einen Grundsätzlichen Fehler, welchen ich mir gerne
erklären lasse.

oder Hat jemand eine lauffähige Routine um diese eingehenden Daten aus
4 Bytes abfragen zu können?
Click to expand...

Ich hab mal einen Ausschnitt angehängt der läuft, allerdings auf UART2
mit 9 Datenbits, 2 Stopbits und 2400baud.

____________________________________________________________________

/*****************************************************************************
***
***
*** Funktion : initCAN
***
*** Description: init system for CAN function
***
*** Input : non
***
*** Output : non
***
***
***
*****************************************************************************/
void initCAN( void)
{
unsigned char err;

// dissable interrupts
OS_ENTER_CRITICAL();

u2brg = 51;
// u2brg = 5; // 16MHz / 16 / (u2brg+1)


u2mr = 0x36; // 0111 0110
// |||| ||||
// |||| ||||
// |||| ||||
// |||| ||||
// |||| |||+- Transfer data bits long
// |||| ||+-- Transfer data bits long
// |||| |+--- Transfer data bits longt
// |||| | 1 0 0: Transfer data 7 bits long
// |||| | 1 0 1: Transfer data 8 bits long
// |||| | 1 1 0: Transfer data 9 bits long
// |||| | 1 0 1: serial I/O invalid
// |||| | 1 0 1: Inhibited
// |||| | 1 0 1: Inhibited
// |||| | 1 0 1: Inhibited
// |||| +---- Must always be fixed to "0"
// |||+------ 0: One stop bit
// ||| 1: Two stop bits
// ||+------- Valid when bit 6 = "1"
// || 0: Odd parity
// || 1: Even parity
// |+-------- 0: Parity disabled
// | 1: Parity enabled
// +--------- 0: No reverse
// 1: Reverse

u2c0 = 0x11; // 0XX1 X000
// |||| ||||
// |||| ||||
// |||| ||||
// |||| ||||
// |||| |||+- BRG count source select bit
// |||| ||+-- BRG count source select bit
// |||| || 0 0: f1 is selected
// |||| || 0 1: f8 is selected
// |||| || 1 0: f32 is selected
// |||| || 1 1: Inhibited
// |||| |+--- Valid when bit 4 = "0"
// |||| | 0: CTS function is selected
// |||| | 1: RTS function is selected
// |||| +---- 0: Data present in transmit
register
// |||| (during transmissin)
// |||| 1: No data present in transmit
register
// |||| (transmission completed)
// |||+------ 0: CTS/RTS function is enabled
// ||| 1: CTS/RTS function is disabled
// ||+------- Nathing is assigned
// |+-------- Must always be "0"
// +--------- 0: LSB first
// 1: MSB first

u2c1 = 0x95; // 10X0 X1X1
// |||| ||||
// |||| ||||
// |||| ||||
// |||| ||||
// |||| |||+- 0: Transmission disabled
// |||| ||| 1: Transmission enabled
// |||| ||+-- 0: Data present in transmit
buffer register
// |||| || 1: No data present in transmit
buffer register
// |||| |+--- 0: Reception disabled
// |||| | 1: Reception enabled
// |||| +---- 0: No data present in receive
buffer register
// |||| 1: Data present in receive
buffer register
// |||+------ 0: Transmit buffer empty (TI =
1)
// ||| 1: Transmit is completed (TXEPT
= 1)
// ||+------- Invalid
// |+-------- 0: No reverse
// | 1: Reverse
// +--------- 0: Output disabled
// 1: Output enabled

u2smr = 0x00; // X010 XXXX
// |||| ||||
// |||| ||||
// |||| ||||
// |||| ||||
// |||| |||+- Must always be "0"
// |||| ||+-- Must always be "0"
// |||| |+--- Must always be "0"
// |||| +---- Must always be "0"
// |||+------ 0: Rising edge of transfer clock
// ||| 1: Underflow signal of timer A0
// ||+------- 0: No auto clear function
// || 1: Auto clear at occurrence of
bus collision
// |+-------- 0: Ordinary
// | 1: Falling edge of RxD2
// +--------- Must always be "0"

s2ric = UART2_IRQ_RX_PRIORITY;
// ---- XXXX
// ||||
// |||+-- Interupt priority level select
bit
// ||+--- Interupt priority level select
bit
// |+---- Interupt priority level select
bit
// | 000: Level 0 (interrupt
disabled)
// | 001: Level 1
// | 010: Level 2
// | 011: Level 3
// | 100: Level 4
// | 101: Level 5
// | 110: Level 6
// | 111: Level 7
// +----- Interupt request bit
// 0: Interrupt not requested
// 1: Interrupt requested

s2tic = UART2_IRQ_TX_PRIORITY;
// ---- XXXX
// ||||
// |||+-- Interupt priority level select
bit
// ||+--- Interupt priority level select
bit
// |+---- Interupt priority level select
bit
// | 000: Level 0 (interrupt
disabled)
// | 001: Level 1
// | 010: Level 2
// | 011: Level 3
// | 100: Level 4
// | 101: Level 5
// | 110: Level 6
// | 111: Level 7
// +----- Interupt request bit
// 0: Interrupt not requested
// 1: Interrupt requested

// enable interrupts
OS_EXIT_CRITICAL();

// create flags
CAN_Event = OSFlagCreate(0x00, &err);
// create mailbox
CANCommMbox = OSQCreate(&CANCommMsg[0], 10);
// create semaphore
CAN_UART_Transmit_Sem = OSSemCreate(1);
// create semaphore
CAN_UART_Receive_Sem = OSSemCreate(0);

// init task
OSTaskCreate(CAN, NULL, TOS(Task6Stk),UART_PRIO);
}
/*****************************************************************************
***
***
*** Funktion : uart2rx
***
*** Description: receive interrrupt function
***
*** Input : non
***
*** Output : non
***
***
***
*****************************************************************************/
void uart2rx( void )
{
unsigned char err;

// get data
tuiData= u2rb;

// post signal
OSSemPost(CAN_UART_Receive_Sem);

// set flag
OSFlagPost(CAN_Event, REC_IRQ_EVENT, OS_FLAG_SET, &err);
}
/*****************************************************************************
***
***
*** Funktion : ReceiveGetByte
***
*** Description: receive get data function
***
*** Input : Daten
***
*** Output : Error
***
***
***
*****************************************************************************/
unsigned char ReceiveGetByte( unsigned int* uiData)
{
unsigned char ucError;

// wait for semaphore or reset counter
OSSemPend( CAN_UART_Receive_Sem, 50, &ucError);

// if not reset counter
if( ucError == OS_NO_ERR)
{
// mask und set data
*uiData = tuiData & 0x01FF;

// clear flag
OSFlagPost(CAN_Event, REC_IRQ_EVENT, OS_FLAG_CLR, &ucError);
return SUCCESS;
}
// return with error
return ERROR_TIME_OUT;
}

___________________________________________________________________-

Dirk
 
huber_oliver@freesurf.ch wrote:


switch ( x )
{
case startbit:
u = 0; //u ist ein Zähler - zähler auf 0 setzten
break;
case stoppbit: //kommt das stoppbit, alle rxbuffer addieren
result =
rxbuffer[0]+
rxbuffer[1]+
rxbuffer[2]+
rxbuffer[3];
break;
default:
u = 0; //
rxbuffer = x;//byte um byte in den rxbuffer
u++;
Click to expand...

also wennn das Startbit kommt, Zähler auf Null setzen.
wenn das erste Nutzbit kommt, u auf null setzen und in den Buffer mit dem
Index u schreiben
wenn das zweite Nutzbit kommt, u=0 setzen und in buffer mit dem Index u
schreiben
Wenn das Stoppbit kommt, alles addieren.

Merkst du, was hier schiefläuft??


Robert


--
'Vom Standpunkt eines Beamtenrechtlers aus betrachtet ist der Tod die
schärfstwirkenste aller bekannten, langfristig wirkenden Formen der
vollständigen Dienstunfähigkeit.'
aus: Kommentar zum Beamtenrecht.
 
Ja Danke für den Tipp.

Natürlich funktioniert das so nicht:
default:
u = 0; //
rxbuffer = x;//byte um byte in den rxbuffer
u++;

darf natürlich hier nicht 0 gesetzt werden.
sonst wird ja immer wieder die gleiche Stelle im Char[] beschrieben.

Also ich habs korrigiert und es funktioniert

Ist ja schön, wenns nur das ist. Kleine Ursache, grosse Wirkung.

Danke nochmal für Eure Hilfe

Oli
 
You must log in or register to reply here.

Welcome to EDABoard.com

Sponsor

Back
Top