New comer Question in ADSP-BF533

Actually, i want to tell clearly my problem so ,that iam
elaborating...please read till the end.........


Actually i am configuring my system baud rate(RS232) t0 19200,8 data
bits,1 stop bits,no parity.....

and based on the reset values......

MSEL[5:0]=0x0A; and for BF533 EZkit lite kit CLKIN=27Mhz..
so, VCO CLK is:0x0A*27=270MHz...

and on the reset the SCEl=0x05 and DF=0; so,SCLK=VCO/5=54MHz.........

Based on the formula Baud rate=SCLK/(16*divisor);
19200=54*10^6/(16*divisor);
i found divisor =176(APProximately);

and the program is like this:
i want to first configure serial port 19200,8,1,no
so,UART_LCR=0x0083;//enabling DLAB to access DLL and DLH registers
*pUART_DLL=0x00b0;// 176=b0;
*pUART_DLH=0x0000;
then making DLAB clear so,that i can access THR and RBR registers..

and i want to use polling here not the interrupts so, uam dissabling
the interrupts...


just i want to send @ to the BF533 then it will send 'B'..
After wards whatever i will send from system it has to return it....


#include<cdefBF533.h>
//#include<ccblkfn.h>

void serialin()
{
*pUART_LCR=0x0083;
*pUART_DLL=0x00b0;
*pUART_DLH=0x0000;
*pUART_LCR=0x0003;
}



void main()

{

int a;

serialin();

*pUART_GCTL=0x0001;

*pUART_IER=0x0000;

//polling for whether dat ready signal
//is set or not
while(((*pUART_LSR) ^ 0x0060) == 0x0060 );

if ((*pUART_RBR)==0x0040)
{
*pUART_THR='B';
while(((*pUART_LSR) ^ 0x0040) == 0x0000 );

while(1)
{
while(((*pUART_LSR) ^ 0x0060) == 0x0000 );
a=*pUART_RBR;


*pUART_THR=a;
while(((*pUART_LSR) ^ 0x0040) == 0x0000 );
}

}


}


Actually i checked this code in BF533 EZkit-lite...the problem iam
facing is it
is halting at the statement

while(((*pUART_LSR) ^ 0x0060) == 0x0060 ); and unable to move..

may be iam thinking '@' i have entered in the hyperterminal is not
reaching the
UART_RBR register becausse of baud rate mismatches..(or) it is not
coming to receive shift register.........

i have given the baud rate and other settings correctly in the system
serial port....

i don't know any may be the case...
so, if any body know please help...
one more i want to see transmit buffer and receive buffer is it
possible or not..???????????????????????

malli wrote:
> while(((*pUART_LSR) ^ 0x0060) == 0x0060 ); and unable to move..

You do realize that the only thing you can xor with 0x0060 and get a 
result of 0x0060, is 0x0000, right?  I don't understand what you're 
trying to do here.  Why not just do this:

while (!*pUART); // wait until *pUART == 0

-- 
Jim Thomas            Principal Applications Engineer  Bittware, Inc
jthomas@bittware.com  http://www.bittware.com    (603) 226-0404 x536
Having a smoking section in a restaurant is like
having a peeing section in a swimming pool.

malli wrote:

> Actually, i want to tell clearly my problem so ,that iam
> elaborating...please read till the end.........
>> so,UART_LCR=0x0083;//enabling DLAB to access DLL and DLH registers

No, I won't read this to the end, because your code is rubbish. Are you 
seriously expecting anyone to check your unnamed bits and constants 
against the datasheets?

Here is the RS232 driver of HALOS RTOS developed by professionals for 
professionals. You can find all initializations in there.



Vladimir Vassilevsky

DSP and Mixed Signal Design Consultant

http://www.abvolt.com

/*********************************************/

#ifndef __UART_H_INCLUDED
#define __UART_H_INCLUDED

#include "HALOS/Config/main_defs.h"
#include "HALOS/Config/interrupt_assignment.h"
#include "HALOS/Multitask/interrupts.h"
#include "HALOS/Multitask/messages.h"
#include "HALOS/Common/fifo.h"


const u32 DEFAULT_UART_TX_FIFO_SIZE = 16;
const u32 DEFAULT_UART_RX_FIFO_SIZE = 16;
const u32 DEFAULT_UART_BAUD_RATE  = 9600;
const u8  DEFAULT_UART_ID  = 0;



class UART {
            FIFO <u8> *rx_fifo;
            FIFO <u8> *tx_fifo;
            HALOS_MESSAGE hm_rx;
            HALOS_MESSAGE hm_tx;
            u8 id;
            u8 ValidBaudRate(u32 baud_rate);

            void TxIntHandler(); // Called from the interrupt
            void RxIntHandler(); // Called from the interrupt

            friend void UART_RX_Int_Handler(void *);
            friend void UART_TX_Int_Handler(void *);


         public:

             UART(u16 rx_fifo_size = DEFAULT_UART_TX_FIFO_SIZE,
                  u16 tx_fifo_size = DEFAULT_UART_TX_FIFO_SIZE,
                  u32 baud_rate = DEFAULT_UART_BAUD_RATE,
                  u8 uart_id = DEFAULT_UART_ID);

             ~UART();
             u8 GetChar(u8 &x); // returns nonzero on success
             u8 PutChar(u8 x); // returns nonzero on success
             u32 CheckTx();   // Returns number of bytes in Rx FIFO
             u32 CheckRx();   // Returns free space in Tx FIFO
             u8 SetBaudRate(u32 baud_rate = DEFAULT_UART_BAUD_RATE);


             u16 Rx_Msg_Id(); // Sent on every received byte
             u16 Tx_Msg_Id(); // Sent on every transmitted byte

            };

// Aux. functions


static void UART_RX_Int_Handler(void *uart);
static void UART_TX_Int_Handler(void *uart);

#endif

// BlackFin BF537 UART

#include "uart.h"


static const u16 UART_MSG_QUEUE_LENGTH = 4;

#define UDRE_INT_ENABLE         *IER |=  0x0002
#define UDRE_INT_DISABLE        *IER &= ~0x0002

#define RXC_INT_ENABLE          *IER |=  0x0001
#define RXC_INT_DISABLE         *IER &= ~0x0001

#define UART_TX_COMPLETE        ((*LSR)&0x0040)
#define UART_UDRE               ((*LSR)&0x0020)
#define UART_RXC                ((*LSR)&0x0001)

static u16 volatile * const uart_register[NUMBER_OF_UARTS][9] =
  {
   { pUART0_DLL, pUART0_DLH, pUART0_LCR, pUART0_MCR, pUART0_RBR, 
pUART0_IER, pUART0_THR, pUART0_GCTL, pUART0_LSR },
   { pUART1_DLL, pUART1_DLH, pUART1_LCR, pUART1_MCR, pUART1_RBR, 
pUART1_IER, pUART1_THR, pUART1_GCTL, pUART1_LSR }
  };


#define DLL  uart_register[id][0]
#define DLH  uart_register[id][1]
#define LCR  uart_register[id][2]
#define MCR  uart_register[id][3]
#define RBR  uart_register[id][4]
#define IER  uart_register[id][5]
#define THR  uart_register[id][6]
#define GCTL uart_register[id][7]
#define LSR  uart_register[id][8]

//----------- Interrupt id -------------

static const u16 uart_rx_int_id[NUMBER_OF_UARTS] = { 
dma8_uart0_rx_int_id, dma10_uart1_rx_int_id  };
static const u16 uart_tx_int_id[NUMBER_OF_UARTS] = { 
dma9_uart0_tx_int_id, dma11_uart1_tx_int_id  };


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

UART::UART(u16 rx_fifo_size, u16 tx_fifo_size, u32 baud_rate, u8 uart_id)
{
rx_fifo = new FIFO <u8> (rx_fifo_size);
tx_fifo = new FIFO <u8> (tx_fifo_size);

id = uart_id;
if(id > NUMBER_OF_UARTS) id = 0;

Install_Interrupt_Handler(UART_RX_Int_Handler, (void *)this, 
UART_RX_interrupt_priority, uart_rx_int_id[uart_id]);
Install_Interrupt_Handler(UART_TX_Int_Handler, (void *)this, 
UART_TX_interrupt_priority, uart_tx_int_id[uart_id]);


if(!SetBaudRate(baud_rate))
  {
  SetBaudRate(DEFAULT_UART_BAUD_RATE);
  }

*GCTL = 0x0001; // UART clock enable

hm_rx.msg_id = halos_Register_Message(UART_MSG_QUEUE_LENGTH);
hm_rx.msg = this;

hm_tx.msg_id = halos_Register_Message(UART_MSG_QUEUE_LENGTH);
hm_tx.msg = this;
}
//----------------------------------
UART::~UART()
{
UDRE_INT_DISABLE;
RXC_INT_DISABLE;

Remove_Interrupt_Handler(uart_rx_int_id[id]);
Remove_Interrupt_Handler(uart_tx_int_id[id]);


delete(rx_fifo);
delete(tx_fifo);

*GCTL = 0x0000; // Disable UART clock
}

u16 UART::Rx_Msg_Id()
{
return hm_rx.msg_id;
}

u16 UART::Tx_Msg_Id()
{
return hm_tx.msg_id;
}


u8 UART::GetChar(u8 &x)
{
RXC_INT_DISABLE;
ssync();

u8 ret_value = rx_fifo->Get(x);

RXC_INT_ENABLE;

return ret_value;
}

u8 UART::PutChar(u8 x)
{
UDRE_INT_DISABLE;
ssync();

u8 ret_value = tx_fifo->Put(x);

UDRE_INT_ENABLE;

return ret_value;
}


u32 UART::CheckRx()
{
RXC_INT_DISABLE;
ssync();

u32 items = rx_fifo->Items();
RXC_INT_ENABLE;

return items;
}

u32 UART::CheckTx()
{

UDRE_INT_DISABLE;
ssync();

u32 items = tx_fifo->FreeItems();

UDRE_INT_ENABLE;

return items;

}

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

u8 UART::ValidBaudRate(u32 baud_rate)
{
u32 divider, speed, diff;

if(!baud_rate) return 0;
	
divider = BUS_CLOCK/baud_rate;
divider = (divider + 0x0008)>>4; // Round to the nearest and divide by 16

if(!divider) return 0;

if(divider > 65536) return 0;


speed = BUS_CLOCK/divider;  // actual speed x 16

diff = abs((s32)(speed - (baud_rate<<4))); // absolute difference x 16

if((diff<<3) > baud_rate) return 0; // (abs. difference * 128) > 
baud_rate -> low tolerance

return 1;
}
//--------------------------------
u8 UART::SetBaudRate(u32 baud_rate)
{
u32 divider;
u8 dummy;

if(!UART::ValidBaudRate(baud_rate)) return 0;

divider = BUS_CLOCK/baud_rate;
divider = (divider + 0x0008)>>4; // Round to the nearest and divide by 16


UDRE_INT_DISABLE;
RXC_INT_DISABLE;
ssync();

dummy = *RBR; // Clear the interrupt just in case

*LCR  = 0x0083; // 0000 0000 1000 0011 8-bit, no parity, DLL/DHL access
*DLH  = (divider>>8)&0xFF;
*DLL  =  divider&0xFF; // Baud = SCLK/(16*(DLH:DLL))
*LCR  = 0x0003; // 0000 0000 0000 0011 8-bit, no parity, THR/RBR/IER access
*MCR  = 0x0000; // no loopback

ssync();


RXC_INT_ENABLE;

return 1;
}


void UART::RxIntHandler()
{
u8 x;

if(UART_RXC)
  {
  x = (u8)(*RBR);
  rx_fifo->Put(x);
  halos_Send_Message(hm_rx);
  }
}


void UART::TxIntHandler()
{
u8 x;

if(UART_UDRE)
  {
  if(tx_fifo->Items())
   {
   tx_fifo->Get(x);
   *THR = x;
   halos_Send_Message(hm_tx);
   }
  else
   {
   UDRE_INT_DISABLE;
   }
  }
}
//--------------------------------------------------------


static void UART_RX_Int_Handler(void *uart)
{
((UART *)uart)->RxIntHandler();
}

static void UART_TX_Int_Handler(void *uart)
{
((UART *)uart)->TxIntHandler();
}



//======================= <END>  ===================

Jim Thomas wrote:

> ...  Why not just do this:
> 
> while (!*pUART); // wait until *pUART == 0

Jim,

I don't understand that syntax. I would have expected

while (!*pUART); // wait until *pUART !== 0
or while (!*pUART); // wait until *pUART

Jerry
-- 
Engineering is the art of making what you want from things you can get.
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Jerry Avins wrote:
> Jim Thomas wrote:
> 
>> ...  Why not just do this:
>>
>> while (!*pUART); // wait until *pUART == 0
> 
> Jim,
> 
> I don't understand that syntax. I would have expected
> 
> while (!*pUART); // wait until *pUART !== 0
> or while (!*pUART); // wait until *pUART
> 
> Jerry

My mistake.  The comment was wrong.

-- 
Jim Thomas            Principal Applications Engineer  Bittware, Inc
jthomas@bittware.com  http://www.bittware.com    (603) 226-0404 x536
The secret to enjoying your job is to have a hobby that's even worse
   - Calvin's Dad