Forums

UART0 hyperterminal

Started by Shilpa Shilpa November 14, 2007
Hi all,

I am working on MCB2130 Evaluation board that has LPC2138 philips microcontroller. The UART0 is been connected to COM0 port and UART1 is connected to COM1 port.I have configured the UART0 for receiving the characters from the PC end which would be like connecting a cable from the board to COM1 port of one PC opening a hyperterminal and upon the execution of the code you could write some characters on the terminal.Now, the UART1 is configured for transmitting the same characters obtained from the UART0 RBR register into the hyperterminal connected onto another PC which is connected to COM1.

The issue that I face here is when I enter into debug mode I could see that some characters received into U0RBR register.Now if I disconnect the hyperterminal connected to UART0 and doing a step into of the code I could see the transmission of the characters on the PC.However being connected and executing of the code the control enters into some infinite loop whose address is unknown.Hence I would like to know to how the connection of UART0 hyperterminal to COM0 port on the board doesnot allow the functioning of UART1 on the board i.e. connected to COM1 port.

I am in the mid of project and this matter is quite urgent to me.Hence I would appreciate you guys quick help regarding the same.

Thanks,
Shilu.

--
My life has changed. What about yours?
Log on to the new Indiatimes Mail and Live out of the Inbox!

An Engineer's Guide to the LPC2100 Series

--- In l..., Shilpa Shilpa wrote:
>
> Hi all,
>
> I am working on MCB2130 Evaluation board that has LPC2138 philips
microcontroller. The UART0 is been connected to COM0 port and UART1 is
connected to COM1 port.I have configured the UART0 for receiving the
characters from the PC end which would be like connecting a cable from
the board to COM1 port of one PC opening a hyperterminal and upon the
execution of the code you could write some characters on the
terminal.Now, the UART1 is configured for transmitting the same
characters obtained from the UART0 RBR register into the hyperterminal
connected onto another PC which is connected to COM1.

OK, so you're using the uC to link the two serial ports.

> The issue that I face here is when I enter into debug mode I could
see that some characters received into U0RBR register.Now if I
disconnect the hyperterminal connected to UART0 and doing a step into
of the code I could see the transmission of the characters on the
PC.However being connected and executing of the code the control
enters into some infinite loop whose address is unknown.

Probably bug.

Hence I would like to know to how the connection of UART0
hyperterminal to COM0 port on the board doesnot allow the functioning
of UART1 on the board i.e. connected to COM1 port.

I doubt that this is the case. On my 2129, (similar chip, fewer timers
and less flash but has CAN), both UARTs work fine together. I can
leave a line of text circulating round the UARTs and CAN and, after a
weekend, it's still working.

I'm sorry, but you are going to have to do some more
troubleshooting/debugging. Try getting just one UART working correctly
and reliably, ie. just echoing input characters back to the same port.
Then get both echoing to their own port indpendently and reliably.
Then try crossing the data over.

Do you use an MTOS and/or interrupts or some polling scheme? Polling
UARTs is pretty well hopeless for any non-trivial app.

Rgds,
Martin
I'm currently using IAR Embedded Workbench with a LPC2106, my serial
routine is interrupt driven, all was fine using Hyperterminal and also
with a custom VB60 application used to talk with the micro.
I've see no strange behaviour, may be then you have some bugs into the
rx/tx routine or bad baud rate settings?

Cheers
Fabio


-----Messaggio originale-----
Da: mjames_doveridge [mailto:m...@tuthill.com]
Inviato: mercoled14 novembre 2007 8.57
A: l...
Oggetto: [lpc2000] Re: UART0 hyperterminal

--- In lpc2000@yahoogroups .com,
Shilpa Shilpa wrote:
>
> Hi all,
>
> I am working on MCB2130 Evaluation board that has LPC2138 philips
microcontroller. The UART0 is been connected to COM0 port and UART1 is
connected to COM1 port.I have configured the UART0 for receiving the
characters from the PC end which would be like connecting a cable from
the board to COM1 port of one PC opening a hyperterminal and upon the
execution of the code you could write some characters on the
terminal.Now, the UART1 is configured for transmitting the same
characters obtained from the UART0 RBR register into the hyperterminal
connected onto another PC which is connected to COM1.

OK, so you're using the uC to link the two serial ports.

> The issue that I face here is when I enter into debug mode I could
see that some characters received into U0RBR register.Now if I
disconnect the hyperterminal connected to UART0 and doing a step into
of the code I could see the transmission of the characters on the
PC.However being connected and executing of the code the control
enters into some infinite loop whose address is unknown.

Probably bug.

Hence I would like to know to how the connection of UART0
hyperterminal to COM0 port on the board doesnot allow the functioning
of UART1 on the board i.e. connected to COM1 port.

I doubt that this is the case. On my 2129, (similar chip, fewer timers
and less flash but has CAN), both UARTs work fine together. I can
leave a line of text circulating round the UARTs and CAN and, after a
weekend, it's still working.
I'm sorry, but you are going to have to do some more
troubleshooting/debugging. Try getting just one UART working correctly
and reliably, ie. just echoing input characters back to the same port.
Then get both echoing to their own port indpendently and reliably.
Then try crossing the data over.

Do you use an MTOS and/or interrupts or some polling scheme? Polling
UARTs is pretty well hopeless for any non-trivial app.

Rgds,
Martin







Hi Shilu,

I was having a similar problem (different board though) and it just
turned out that when I was
running instead of single stepping I was loading registers too quickly
for them to be read
out at the baud rate I had set up, and then overrunning the arrays.
This causes the memory
allocation error (if I remember correctly) which then looks like an
endless loop.

Hope that helps a little

EM

On Nov 14, 2007 5:28 AM, Shilpa Shilpa wrote:
> Hi all,
>
> I am working on MCB2130 Evaluation board that has LPC2138 philips
> microcontroller. The UART0 is been connected to COM0 port and UART1 is
> connected to COM1 port.I have configured the UART0 for receiving the
> characters from the PC end which would be like connecting a cable from the
> board to COM1 port of one PC opening a hyperterminal and upon the execution
> of the code you could write some characters on the terminal.Now, the UART1
> is configured for transmitting the same characters obtained from the UART0
> RBR register into the hyperterminal connected onto another PC which is
> connected to COM1.
>
> The issue that I face here is when I enter into debug mode I could see that
> some characters received into U0RBR register.Now if I disconnect the
> hyperterminal connected to UART0 and doing a step into of the code I could
> see the transmission of the characters on the PC.However being connected and
> executing of the code the control enters into some infinite loop whose
> address is unknown.Hence I would like to know to how the connection of UART0
> hyperterminal to COM0 port on the board doesnot allow the functioning of
> UART1 on the board i.e. connected to COM1 port.
>
> I am in the mid of project and this matter is quite urgent to me.Hence I
> would appreciate you guys quick help regarding the same.
>
> Thanks,
> Shilu.
>
> --
> My life has changed. What about yours?
> Log on to the new Indiatimes Mail and Live out of the Inbox!
>
Hi,

Thx for the reply. Yup I am using the Microcontroller to link the two ports.

Can you pls mail me the 2129 code of yours that seem to work so that I can try implementing the same on my board?

"Try getting just one UART working correctly
and reliably, ie. just echoing input characters back to the same port.
Then get both echoing to their own port indpendently and reliably.
Then try crossing the data over."

I am sorry that I coul not get to what do you exactly means by echoing to their own port independently.I have configured UART0 for receiving characters and I could see that once I run the code I am able to receive the characters from the PC i.e write the characters onto the hyperterminal connected to COM0 port inturn connected to CPU of the PC.Do you mean the choing of characters this way?

Also pls do explain me about the crossing over the data.

I use interrupt mode.I have configured UART0 in interrupt mode.Once the interrupt occurs which could be by hitting the character on hyperterminal(connected to COM0 port on the board), the control enters into ISR.Inside ISR I am retreiving the data from U0RBR regsiter putting the data into an array.Here I initialise UART1 and then write back the same array of data into U1THR regsiter.

i.e

Inside U0ISR
data[i]=U0RBR;
/***initialise UART1**/
U1THRa[i];

Also I would like to tell you that the data will be written into U1THR there by onto hyperterminal only if I am including the UART1 initialisation inside the U0ISR.

Thanks,
Shilu

----- Original Message -----
From: mjames_doveridge
To: l...
Sent: Wed, 14 Nov 2007 13:27:18 +0530 (IST)
Subject: [lpc2000] Re: UART0 hyperterminal

--- In l..., Shilpa Shilpa wrote:
>
> Hi all,
>
> I am working on MCB2130 Evaluation board that has LPC2138 philips
microcontroller. The UART0 is been connected to COM0 port and UART1 is
connected to COM1 port.I have configured the UART0 for receiving the
characters from the PC end which would be like connecting a cable from
the board to COM1 port of one PC opening a hyperterminal and upon the
execution of the code you could write some characters on the
terminal.Now, the UART1 is configured for transmitting the same
characters obtained from the UART0 RBR register into the hyperterminal
connected onto another PC which is connected to COM1.

OK, so you're using the uC to link the two serial ports.

> The issue that I face here is when I enter into debug mode I could
see that some characters received into U0RBR register.Now if I
disconnect the hyperterminal connected to UART0 and doing a step into
of the code I could see the transmission of the characters on the
PC.However being connected and executing of the code the control
enters into some infinite loop whose address is unknown.

Probably bug.

Hence I would like to know to how the connection of UART0
hyperterminal to COM0 port on the board doesnot allow the functioning
of UART1 on the board i.e. connected to COM1 port.

I doubt that this is the case. On my 2129, (similar chip, fewer timers
and less flash but has CAN), both UARTs work fine together. I can
leave a line of text circulating round the UARTs and CAN and, after a
weekend, it's still working.

I'm sorry, but you are going to have to do some more
troubleshooting/debugging. Try getting just one UART working correctly
and reliably, ie. just echoing input characters back to the same port.
Then get both echoing to their own port indpendently and reliably.
Then try crossing the data over.

Do you use an MTOS and/or interrupts or some polling scheme? Polling
UARTs is pretty well hopeless for any non-trivial app.

Rgds,
Martin

--
My life has changed. What about yours?
Log on to the new Indiatimes Mail and Live out of the Inbox!
Hi,

Thanks a lot for sharing this.I tried using this and could see that though the terminal is connecetd it hits the breakpoint.One of the reason I found out was the signals DTR and RTS used in COM0 port in MCB2130 board were routed to Reset signals.hence whenever the hyperterminal was connected it was pulled to reset which was avoiding the control to hit the breakpoint.
However the option for disabling this sigbals routing was absent in hyperterminal whereas the bray terminal provided this option.I disabled it and succedded in hitting the breakpoint.

I would also like to know if you did had the code that explains my implementation to share with me so that I could go ahead with my application.

Thanks,
Shilu
----- Original Message -----
From: Shilpa Shilpa
To: b...@home.nl
Sent: Wed, 14 Nov 2007 14:49:54 +0530 (IST)
Subject: Re: [lpc2000] UART0 hyperterminal

I would try and lt you knw..
----- Original Message -----
From: Bart Caumon
To: l...
Cc: Shilpa Shilpa
Sent: Wed, 14 Nov 2007 13:14:21 +0530 (IST)
Subject: Re: [lpc2000] UART0 hyperterminal

Are you using ms hyperterminal? I've had problems with using it and with the mcb2100 board.

Now I use brays terminal

Under downloads:
http://www.smileymicros.com/index.php?module=pagemaster&PAGE_user_op=view_page&PAGE_id&

cheers
---- Shilpa Shilpa schrijft:

============Hi all,

I am working on MCB2130 Evaluation board that has LPC2138 philips microcontroller. The UART0 is been connected to COM0 port and UART1 is connected to COM1 port.I have configured the UART0 for receiving the characters from the PC end which would be like connecting a cable from the board to COM1 port of one PC opening a hyperterminal and upon the execution of the code you could write some characters on the terminal.Now, the UART1 is configured for transmitting the same characters obtained from the UART0 RBR register into the hyperterminal connected onto another PC which is connected to COM1.

The issue that I face here is when I enter into debug mode I could see that some characters received into U0RBR register.Now if I disconnect the hyperterminal connected to UART0 and doing a step into of the code I could see the transmission of the characters on the PC.However being connected and executing of the code the control enters into some infinite loop whose address is unknown.Hence I would like to know to how the connection of UART0 hyperterminal to COM0 port on the board doesnot allow the functioning of UART1 on the board i.e. connected to COM1 port.

I am in the mid of project and this matter is quite urgent to me.Hence I would appreciate you guys quick help regarding the same.

Thanks,
Shilu.

--
My life has changed. What about yours?
Log on to the new Indiatimes Mail and Live out of the Inbox!

--
My life has changed. What about yours?
Log on to the new Indiatimes Mail and Live out of the Inbox!
Dear Shilu,



"I could see that UART1 could be used to transmit and UART0 could be

used to receive."



well in my project I'm using UART1 for data exchange (then rx and tx)

with a my VB60 coded application and I'm using UART0 just to perform the

in-circuit programming for the micro, hence I've no taken a look to the

UART0 behaviour as a simple serial interface behaviour.



What I can suggest to you is adapt my code to get it working with the

UART0, I think is a simple matter to change the holding transmitter

register name and the assignement to the interrupt vector and handler,

all should be work in the same manner.



Cheers

Fabio Filippa







-----Messaggio originale-----

Da: Shilpa Shilpa [mailto:s...@indiatimes.com]

Inviato: mercoledì 14 novembre 2007 12.49

A: l...

Cc: Fabio Filippa

Oggetto: Re: R: R: [lpc2000] Re: UART0 hyperterminal











Primarily I would like to appreciate your long and fast response.Thanks

for the same.



>From your mail what I understand is the UART1 transmission and Reception

of characters is taking

place but in my case I would like to transmit the characters the U0RBR

register has.



Also sometime back I had checked receiving characters from PC using

UART1 and could see that this is not operational.I am not sure for what

reason however I could see that UART1 could be used to transmit and

UART0 could be used to receive.



Hence any thoughts regarding this if you could share ould be really

gr8!!



Thanks,

Shilu



----- Original Message -----

From: Fabio Filippa < fabio.filippa@

tekel.it>

To: lpc2000@yahoogroups .com

Sent: Wed, 14 Nov 2007 16:12:21 +0530 (IST)

Subject: R: R: [lpc2000] Re: UART0 hyperterminal



Well, at first I'll past here my serial rx/tx routine, this is used with



a simple ASCII based protocol, start char is done with $ character and



the end of the command is done with the % character.



Put the following definition on the top of the main file:



#define MAXSERBUF 24



unsigned char SerialBufferRx[MAXSERBUF]; // USART1: rx buffer



unsigned char SerialBufferTx[MAXSERBUF]; // USART1: tx buffer



[CODE START]



void USART1_rx(unsigned char rxbyte)



{



SerRx = rxbyte; // Store on SerRx the received



char trough the serial port



if (SerRx == '$') // if is the starting char clear



the received char counter



RxCtr = 0;



if (SerRx != '%') // The current char is different



to the end one?



{



SerialBufferRx[RxCtr]=SerRx; // Store the received char into



the rx buffer



RxCtr = RxCtr + 1; // Update the buffer pointer



if (RxCtr >= MAXSERBUF) // Check for extra bytes - prevent



overflw of the rx buffer



{



RxCtr = 0; // overflow



rsFlag = 0; // skip the current data received



}



}



else



{



SerialBufferRx[RxCtr]=SerRx; // Write the last received char



into the rx buffer



rsFlag = 0x01; // A serial command was received



(we can check it at the main level code)



}



return;



}



[CODE END]



and here is the transmitting one:



[CODE START]



void USART1_tx(void)



{



while(U1LSR_bit.THRE == 1)



{



if (TxMaxChr > 0)



{



if ((TxCtr + 1) > TxMaxChr)



{



U1IER_bit.THREIE = 0;



TxCtr = 0;



TxMaxChr = 0;



}



else



{



U1THR = SerialBufferTx[TxCtr];



TxCtr = TxCtr + 1;



}



}



else



break;



}



return;



}



[CODE END]



Of course you've also to set the right interrupt handler in order to



point the rx/tx serial interrupt routine.



[CODE START]



// ----------------------



// UART1 interrupt handler



// ----------------------



static void UART1Interrupt()



{



volatile unsigned char statusReg;



volatile unsigned char dummy;



statusReg = U1IIR;



switch(statusReg & 0x0E)



{



case 0x06: // Receiver Line Status



dummy = U0LSR; // Read LSR to clear bit



break;



case 0x0C: // Character time out



indicator interrupt (CTI)



case 0x04: // Receiver data available



(RDA)



(*uart1rx_function)(U1RBR); // Call received byte



callback function



break;



case 0x02: // THRE interrupt



(*uart1tx_function)(); // Call tx buffer empty



callback function



break;



default:



break;



}



return;



}



[CODE END]



And also you've to set the interrupt vector:



[CODE START]



// -----------------------------------



// Inizializza interrupt per UART1



// -----------------------------------



void LPC210xInitUART1Interrupt(void(*uart1rx_func)(unsigned char),



void(*uart1tx_func)())



{



// Setup uart1 callback functions.



uart1rx_function = uart1rx_func;



uart1tx_function = uart1tx_func;



VICIntSelect &= ~VIC_UART1_bit; // IRQ on UART1.



VICVectAddr5 = (unsigned int)&UART1Interrupt;



VICVectCntl5 = 0x20 | VIC_UART1; // Enable vector



interrupt for UART1.



VICIntEnable = VIC_UART1_bit; // Enable UART 1



interrupt.



// Enable byte received interrupt



U1IER = 0x01;



return;



}



[CODE END]



Now you've also to initialize the LPC2106 register and set the I/O pin



in order to get all working properly, here the initialization code (I'm



using the serial port with 9600, N, 8, 1 without handshake), my external



crystal is equal to 14.745 MHz and the core frequency will be set to the



maximum available (look later into the code for the PLL settings):



[CODE START]



// ----------



// UART1 functions



// ----------



#define BAUDRATE 9600 // Put



this line at the top of the file



#define BAUDRATEDIVISOR ( (PCLKFREQ/(BAUDRATE * 16.0)) + 0.5 ) // Put



this line at the top of the file



void LPC210xInitUART1()



{



volatile unsigned char tmpVar;



PINSEL0_bit.P0_8 = 0x1; // Set pin function to TxD (UART1)



PINSEL0_bit.P0_9 = 0x1; // Set pin function to RxD (UART1)



U1IER = 0x00; // disable all UART1 interrups



tmpVar = U1IIR; // clear interrupt id



tmpVar = U1RBR; // clear receive reg. (to reset possibly intr)



tmpVar = U1LSR; // clear linestatus (to reset possibly intr)



tmpVar = U1MSR; // clear modemstatus (to reset possibly intr)



U1LCR = 0x83; // select divisor latches (DLAB)



U1DLL = (unsigned char) ((unsigned short)BAUDRATEDIVISOR & 0x00ff);



// set for 9600 Baud



U1DLM = (unsigned char)(((unsigned short)BAUDRATEDIVISOR >> 8) &



0x00ff); // set for 9600 Baud



U1LCR = 0x03; // 8 bit character length, 1 stop bit, Disable



parity generation and checking, Disable break transmission



U1FCR = 0x07; // Enable and reset FIFO, trigger level 0



(default=’h1)



U1MCR = 0x00; // DTR off, RTS off, Disable modem loopback mode



return;



}



[CODE END]



Into the your main function you've also to initialize the interrupt and



other stuff before keep all working then:



[CODE START]



void main(void)



{



// ----------------------



// System initialization, this will map the exception vectors.



// This function is provided with the IAR sample project



// ----------------------



LPC210xSystemInit();



// ----------------------



// VPB Divider



// ----------------------



VPBDIV = 0x01; // Peripheral clock equal to core



clock



// ----------------------



// PLL settings to keep 60 MHz internal clock



// with external crystal of 14.745 MHz.



// M = 4, P = 2



// ----------------------



PLLCFG = 0x23;



PLLCON = 0x01;



PLLFEED = 0xAA;



PLLFEED = 0x55;



while (!(PLLSTAT & 0x400)) {}



PLLCON = 0x03;



PLLFEED = 0xAA;



PLLFEED = 0x55;



// Here you can set your I/O pins...



// ----------------------



// UART1 initialization



// ----------------------



LPC210xInitUART1();



// ----------------------



// Disable the IRQ before make the IRQ setup



// ----------------------



__disable_interrupt();



// ----------------------



// Setup interrupt controller and set the USART IRQ



// ----------------------



LPC210xInitVIC(); // Init the



interrupt vector



LPC210xInitUART1Interrupt(USART1_rx, USART1_tx); // Init the USART1



callback function



// ----------------------



// All was done then I can enable the IRQ



// ----------------------



__enable_interrupt();



// Now make your work from this point...



}



[CODE END]



In order to transmit data trough the serial port you can use this simple



code:



[CODE START]



SerialBufferTx[0] = '$'; // Start char



SerialBufferTx[1] = 'H'; //



SerialBufferTx[2] = 'Y'; //



SerialBufferTx[3] = 'M'; //



SerialBufferTx[4] = 'A'; //



SerialBufferTx[5] = 'T'; //



SerialBufferTx[6] = 'E'; //



SerialBufferTx[7] = '!'; //



SerialBufferTx[8] = '%'; // End char



TxMaxChr = 9; // Max number of char that I've to



transmit



TxCtr = 1; // Transmitting char counter



U1FCR_bit.TFR = 1; // Reset the UART1 FIFO TX without



transmitting anythings



U1THR = SerialBufferTx[0]; // Send the first char to start the



transmitting task



U1IER_bit.THREIE = 1; // Enable the transmitting interrupt



[CODE END]



To check if somethings is going on the serial port simply test the



rsFlag variable, if this is set to 1 you've somethings wait in your rx



buffer.



I'm using this code before approach the LPC2106 microcontroller with the



Microchip PIC family, sligthy different due to the different micro



assignement and register but the basic idea is the same.



Final words



------------



Hope this can help you in some way, I know this is a long reply, but I'm



sure that sharing your own knowledge and experience is a better way to



increse the skill and echange idea with other people, of course I know



that somethings can keep some effort and time in developing and testing



(all the code reported is by myself) but also sharing is the only way to



cooperate in order to keep better result, unfortunatly not all the



people think in this direction, but you also know that this is the real



life ... :-)



Cheers



Fabio Filippa



-----Messaggio originale-----



Da: Shilpa Shilpa [mailto: shilu72000@indiatim

es.com]



Inviato: mercoledì 14 novembre 2007 10.16



A: lpc2000@yahoogroups .com



Cc: Fabio Filippa



Oggetto: Re: R: [lpc2000] Re: UART0 hyperterminal



Hi,



Thanks for the reply.



Can you pls tell me if this is happenning in your code efficintly?



data[i]=U0RBR;



U1THR=data[i];



U0RBR==U1THR???



In the sense when you type some characters on hypertrminal connected to



UART0 do you observe the same characters apprearing on the hypertrminal



connected to UART1 to another PC(say)?



Thanks,



Shilu



----- Original Message -----



From: Fabio Filippa < fabio.filippa@



tekel.it>



To: lpc2000@yahoogroups .com



Sent: Wed, 14 Nov 2007 14:19:09 +0530 (IST)



Subject: R: [lpc2000] Re: UART0 hyperterminal



I'm currently using IAR Embedded Workbench with a LPC2106, my serial



routine is interrupt driven, all was fine using Hyperterminal and also



with a custom VB60 application used to talk with the micro.



I've see no strange behaviour, may be then you have some bugs into the



rx/tx routine or bad baud rate settings?



Cheers



Fabio



-----Messaggio originale-----



Da: mjames_doveridge [mailto: mjames@tuthill.



com]



Inviato: mercoledì 14 novembre 2007 8.57



A: lpc2000@yahoogroups .com



Oggetto: [lpc2000] Re: UART0 hyperterminal



--- In lpc2000@yahoogroups .com,



Shilpa Shilpa wrote:



>



> Hi all,



>



> I am working on MCB2130 Evaluation board that has LPC2138 philips



microcontroller. The UART0 is been connected to COM0 port and UART1 is



connected to COM1 port.I have configured the UART0 for receiving the



characters from the PC end which would be like connecting a cable from



the board to COM1 port of one PC opening a hyperterminal and upon the



execution of the code you could write some characters on the



terminal.Now, the UART1 is configured for transmitting the same



characters obtained from the UART0 RBR register into the hyperterminal



connected onto another PC which is connected to COM1.



OK, so you're using the uC to link the two serial ports.



> The issue that I face here is when I enter into debug mode I could



see that some characters received into U0RBR register.Now if I



disconnect the hyperterminal connected to UART0 and doing a step into



of the code I could see the transmission of the characters on the



PC.However being connected and executing of the code the control



enters into some infinite loop whose address is unknown.



Probably bug.



Hence I would like to know to how the connection of UART0



hyperterminal to COM0 port on the board doesnot allow the functioning



of UART1 on the board i.e. connected to COM1 port.



I doubt that this is the case. On my 2129, (similar chip, fewer timers



and less flash but has CAN), both UARTs work fine together. I can



leave a line of text circulating round the UARTs and CAN and, after a



weekend, it's still working.



I'm sorry, but you are going to have to do some more



troubleshooting/debugging. Try getting just one UART working correctly



and reliably, ie. just echoing input characters back to the same port.



Then get both echoing to their own port indpendently and reliably.



Then try crossing the data over.



Do you use an MTOS and/or interrupts or some polling scheme? Polling



UARTs is pretty well hopeless for any non-trivial app.



Rgds,



Martin







--



My life has changed. What about yours?



Log on to the new Indiatimes Mail and Live out of the Inbox!







--

My life has changed. What about yours?

Log on to the new Indiatimes Mail and Live out of the Inbox!













Very wise advice. There are way too many gotchas.

--- In l..., "mjames_doveridge" wrote:
>
> --- In l..., Shilpa Shilpa wrote:
> >
> > Hi,
> >
> > Thanks a lot for sharing this.I tried using this and could see that
> though the terminal is connecetd it hits the breakpoint.One of the
> reason I found out was the signals DTR and RTS used in COM0 port in
> MCB2130 board were routed to Reset signals.hence whenever the
> hyperterminal was connected it was pulled to reset which was avoiding
> the control to hit the breakpoint.
> > However the option for disabling this sigbals routing was absent in
> hyperterminal whereas the bray terminal provided this option.I
> disabled it and succedded in hitting the breakpoint.
> > Take out the clips that connect up the DTR/RTS to the reset/ISR
> system. Disconnect any hardware handshake lines. Set flow control to
> 'none'.
>
> Any time you meet RS232, do this first. get it transferring
> *something*, then think about flow-control later.
>
> Rgds,
> Martin
>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SGksCgpUaGFua3MgZm9yIHRoZSByZXBseS4KCkNhbiB5b3UgcGxzIHRlbGwgbWUgaWYgdGhp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