An alternative register access..?

[silentlights]

Hi Guys, I am looking for an alternative means of register access in a
microcontroller . Currently my get() function looks like this..
------------------------
implementation in comm.c
------------------------
/*A simple get() function*/
unsigned char port0_get_char( void)
{
unsigned char input_c;

// Poll the SSR RDRF bit until it is ready
while ( !(Serial_Port0_ Status_Register .BIT.RDRF))
{ ; }

input_c = Serial_Port0_Re ceive_Data_Reg;

// Clear the SSR RDRF bit
Serial_Port0_St atus_Register.B IT.RDRF = SET_BIT_LOW;

return input_c;
}
............... ............... ............... ............

This means if I have 4 ports I have to define get()/put() functions for 4
serial ports 4 different times.. although the procedure is the same while
the registers are different. Is there a smater way of doing it... where
there could be only one function and access the registers in the functions
using pointers.. does any have a suggestion.. Here is how I defined the
header files.. is there an alternative way of defining the registers..

Thanks in advance
Densil
-------------------------------------------------
Header file
------------------------
definition in hardware.h
------------------------
struct st_sci { /* struct SCI
*/
union { /* SMR
*/
unsigned char BYTE; /* Byte Access
*/
struct { /* Bit Access
*/
unsigned char CA :1; /* C/A
*/
unsigned char CHR :1; /* CHR
*/
unsigned char PE :1; /* PE
*/
unsigned char OE :1; /* O/E
*/
unsigned char STOP:1; /* STOP
*/
unsigned char MP :1; /* MP
*/
unsigned char CKS :2; /* CKS
*/
} BIT; /*
*/
} SMR; /*
*/
unsigned char BRR; /* BRR
*/
union { /* SCR
*/
unsigned char BYTE; /* Byte Access
*/
struct { /* Bit Access
*/
unsigned char TIE :1; /* TIE
*/
unsigned char RIE :1; /* RIE
*/
unsigned char TE :1; /* TE
*/
unsigned char RE :1; /* RE
*/
unsigned char MPIE:1; /* MPIE
*/
unsigned char TEIE:1; /* TEIE
*/
unsigned char CKE :2; /* CKE
*/
} BIT; /*
*/
} SCR; /*
*/
unsigned char TDR; /* TDR
*/
union { /* SSR
*/
unsigned char BYTE; /* Byte Access
*/
struct { /* Bit Access
*/
unsigned char TDRE:1; /* TDRE
*/
unsigned char RDRF:1; /* RDRF
*/
unsigned char ORER:1; /* ORER
*/
unsigned char FER :1; /* FER
*/
unsigned char PER :1; /* PER
*/
unsigned char TEND:1; /* TEND
*/
unsigned char MPB :1; /* MPB
*/
unsigned char MPBT:1; /* MPBT
*/
} BIT; /*
*/
} SSR; /*
*/
};

#define P_SCI0 (*(volatile struct st_sci *)0xFFFF78) /* SCI0
Address*/
#define P_SCI1 (*(volatile struct st_sci *)0xFFFF80) /* SCI1
Address*/
#define P_SCI2 (*(volatile struct st_sci *)0xFFFF88) /* SCI2
Address*/
#define P_SCI3 (*(volatile struct st_sci *)0xFFFDD0) /* SCI3
Address*/

--------------------
definition in comm.h
--------------------
#define Serial_Port0_Co ntrol_Register P_SCI0.SCR
#define Serial_Port0_St atus_Register P_SCI0.SSR

#define Serial_Port1_Co ntrol_Register P_SCI1.SCR
#define Serial_Port1_St atus_Register P_SCI1.SSR
....
----------------------------------------------------------

[Dan Pop]

In <Xn************ **************@ 212.27.42.74> Emmanuel Delahaye <em**********@n oos.fr> writes:

In 'comp.lang.c', "Mark A. Odell" <od*******@hotm ail.com> wrote:

Although I agree with you in principle, I must say I use carefully
packed bit-fields often.

I once have been bitten by an Motorola to Intel bit order changes. Once
was fine. More would be silly.

So you switched CPUs in mid-project? How, praytell, did you expect your

No. It was more a problem of data exchange between two different
architecture s.

So, it had exactly zilch to do with our discussion. Of course, it is
sheer stupidity to try to map an externally imposed data format with a
structure, if you expect any kind of code portability.

But even in this case, you still use a structure and a couple of
conversion functions from external buffer format to internal structure
format and from internal structure format to external buffer format,
so that all the ugliness is restricted to these two functions.
And these two functions can be portably implemented, even if the
internal structure layout is implementation-specific.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[silentlights]

Hi,
The compiler tell that, SCI is not type compatable. Could you let me know
what could be the reason.

Thanks
Densil

[silentlights]

Hi,
The other methods you had suggested were little confusing for me. I could
get the switch case suggestion, it is simple. I am also trying something
like,

#define ACCESS(TYPE, LADR) (*((TYPE volatile *) (LADR)))
#define S_PORT(ADR) (ACCESS(st_sci, ADR))
#define SPORT0_TYPE S_PORT
#define SPORT0_ADR 0xFFFF78
#define SPORT1_TYPE S_PORT
#define SPORT1_ADR 0xFFFF80
#define SPORT2_TYPE S_PORT
#define SPORT2_ADR 0xFFFF88

void putChar(S_PORT PORTNAME, char VAL);
char getChar(S_PORT PORTNAME);

Could someone tell me what I made as mistake here..? Do you have an idea
of how I can do the header definitions in this way..?

Thanks in advance
Densil

[Mark A. Odell]

"silentligh ts" <si**********@y ahoo.co.uk> wrote in
news:57******** *************** *******@localho st.talkaboutpro gramming.com:

Hi,
The other methods you had suggested were little confusing for me. I
could get the switch case suggestion, it is simple. I am also trying
something like,

#define ACCESS(TYPE, LADR) (*((TYPE volatile *) (LADR)))
#define S_PORT(ADR) (ACCESS(st_sci, ADR))
#define SPORT0_TYPE S_PORT
#define SPORT0_ADR 0xFFFF78
#define SPORT1_TYPE S_PORT
#define SPORT1_ADR 0xFFFF80
#define SPORT2_TYPE S_PORT
#define SPORT2_ADR 0xFFFF88

void putChar(S_PORT PORTNAME, char VAL);
char getChar(S_PORT PORTNAME);

Could someone tell me what I made as mistake here..? Do you have an idea
of how I can do the header definitions in this way..?

I think you need to dispense with the macros. What was so confusing about
my serial port picker table? Macros have problems that functions do not
and should only be used where a function cannot reasonably do the job.

--
- Mark ->
--

[Arthur J. O'Dwyer]

On Wed, 14 Jul 2004, silentlights wrote:

#define ACCESS(TYPE, LADR) (*((TYPE volatile *) (LADR)))
#define S_PORT(ADR) (ACCESS(st_sci, ADR)) void putChar(S_PORT PORTNAME, char VAL);
char getChar(S_PORT PORTNAME);

Could someone tell me what I made as mistake here..?

Simple --- expand the macros and look for syntax errors.

void putChar(S_PORT PORTNAME, char VAL);

Here's a syntax error already --- S_PORT is an undefined identifier.
Did you mean perhaps

void putChar(S_PORT( ) PORTNAME, char VAL);

? That would expand to

void putChar((*((st_ sci volatile *) ())) PORTNAME, char VAL);

which is again a syntax error. Or you might have meant

void putChar(S_PORT( PORTNAME), char VAL);

which would expand to

void putChar((*((st_ sci volatile *) (PORTNAME))), char VAL);

which is /again/ a syntax error. What are you trying to do here?
Declare a function parameter, obviously, but what type is it supposed
to have? If it's a pointer to 'volatile st_sci', then just write

void putChar(st_sci volatile *PORTNAME, char VAL);

and be done with it. Make a macro

#define S_PORTD(ident) st_sci volatile *ident

void putChar(S_PORTD (PORTNAME), char VAL);

if you really want to, but that looks a lot like overkill to me.
Perhaps you'd better give some context...

-Arthur

[silentlights]

What are you trying to do here? Declare a function parameter, obviously,
but what type is it supposed
to have?

I am trying to declare a function Eg. getChar. I have 4 serial ports
(Ports 0,1,2 & 3)and I want to write a single function putChar() common
for all ports. Inside the function I have to access the registers of
individual ports like PORT1->Data_Registe r or something like PORT1.DR. The
structure of the registers are defined in the st_sci structure.

In which case, I have pass an argument which has the address of the group
of registers which belong to Port 1. Inside the function, I have to handle
a particular register using the passed parameter. And then I landed up in
a piece of code like,

#define ACCESS(TYPE, LADR) (*((TYPE volatile *) (LADR)))
#define S_PORT(ADR) (ACCESS(st_sci, ADR))

#define SPORT0_TYPE S_PORT
#define SPORT0_ADR 0xFFFF78
#define SPORT1_TYPE S_PORT
#define SPORT1_ADR 0xFFFF80
#define SPORT2_TYPE S_PORT
#define SPORT2_ADR 0xFFFF88
#define sci S_PORT

//typedef S_PORT sci;

char getChar(sci PORTNAME);

char getChar(sci PORTNAME)
{
char data = PORTNAME.RDR;
return data;
}

Thanks in advance
Densil

[silentlights]

You are right abt the code Mark, I appreciate your reply. I dont want to
execute a function which finds me an address everytime I am into a
getChar() function. Instead, I want to pass the address of the register
directly into the getChar function which would read the registers of the
corresponding ports. And this I want to reach using macros. I could use a
simple switch case block or the way you had suggested. A call to a
function costs me 8 cycles and then the execution of the function takes me
more. If I have a chance to pass it directly, then I have the read done
with less overhead.

Cheers
Densil