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
....
----------------------------------------------------------

[Case]

silentlights wrote:

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..
You can simply define the function like this:

unsigned char get_char(int port)
{
volatile struct st_sci *sci;

switch(port)
{
case 0; sci = 0xFFFF78; break;
case 1; sci = 0xFFFF80; break;
case 2; sci = 0xFFFF88; break;
case 3; sci = 0xFFFDD0; break;
}

while (!sci->SSR.BIT.RDRF )
{
/* empty */
}

.......
}

You may want to create new defines for the addresses.

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
...
----------------------------------------------------------

[Mark A. Odell]

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

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;
}

Purely from a C perspective (since there are no comm. ports in C) I'd
write a getchar() to read from a default comm. port and have it call
lower level function that take an arg. E.g.

int myStdin;

static int getCharFromPort (int port, unsigned char *pInChar)
{
static const unsigned long commPortAddr[] =
{
0xFFFF78, /* SCI0 */
0xFFFF80, /* SCI1 */
0xFFFF88, /* SCI2 */
0xFFFDD0 /* SCI3 */
}
struct CommPort *pCommPort = (struct CommPort *) commPortAddr[port];
int failures = !0;

if (!pCommPort->err)
{
if (pInChar) *pInChar = pCommPort->rbuf;
failures = 0;
}

return failures;
};
/* Yes 'int' */
int getchar(void)
{
/* getchar() defaults to myStdin which is a global
*/
unsigned char inChar;
int failuures;

failures = getCharFromPort (myStdin, &inChar);
if (failures)
{
failures = EOF;
/* also set error indicator
*/
}

return failures;
}
--
- Mark ->
--

[Mark A. Odell]

"Mark A. Odell" <od*******@hotm ail.com> wrote in
news:Xn******** *************** *********@130.1 33.1.4:

struct CommPort *pCommPort = (struct CommPort *) commPortAddr[port];

A little check would be good here.

struct CommPort *pCommPort;

if (port < sizeof commPortAddr / sizeof *commPortAddr)
{
pCommPort = (struct CommPort *) commPortAddr[port];
}
else
{
/* failure */
}

--
- Mark ->
--

[Emmanuel Delahaye]

In 'comp.lang.c', "silentligh ts" <si**********@y ahoo.co.uk> wrote:

Hi Guys, I am looking for an alternative means of register access in a
microcontroller .

The bitfield trick you are using is attractive but deceiving. It's not
portable and should not be used in an external interface. It is recommended
to use bitwise operators. This may help:

http://mapage.noos.fr/emdel/clib/ed/inc/BITS.H

--
-ed- get my email here: http://marreduspam.com/ad672570
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=c99
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

[Mark A. Odell]

Emmanuel Delahaye <em**********@n oos.fr> wrote in
news:Xn******** *************** ****@212.27.42. 66:

In 'comp.lang.c', "silentligh ts" <si**********@y ahoo.co.uk> wrote:

Hi Guys, I am looking for an alternative means of register access in a
microcontroller .

The bitfield trick you are using is attractive but deceiving. It's not
portable and should not be used in an external interface. It is
recommended to use bitwise operators. This may help:

Although I agree with you in principle, I must say I use carefully packed
bit-fields often. It greatly enhances debugging with an ICE and make the
code far more readable, IMHO. One must decide how likely one's driver is
to be ported from one microcontroller to another or from one compiler to
another. In fact, many microcontroller drivers are for built-in
peripherals so they cannot be moved to another CPU type. As for compilers
changing, I don't change them for a given CPU, ever. Everything in
balance...

--
- Mark ->
--

[Emmanuel Delahaye]

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.

--
-ed- get my email here: http://marreduspam.com/ad672570
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=c99
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

[Mark A. Odell]

Emmanuel Delahaye <em**********@n oos.fr> wrote in
news:Xn******** *************** ****@212.27.42. 74:

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
Intel CPU integrated peripheral driver to work on a Motorola CPU? Of
course you didn't because it was not a built-in peripheral driver was it?
For anything not built into the CPU, I would not use bit-fields either.
However, for built-in, CPU-specific peripherals I do use bit-fields.

--
- Mark ->
--

[Emmanuel Delahaye]

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
architectures.
Intel CPU integrated peripheral driver to work on a Motorola CPU? Of
course you didn't because it was not a built-in peripheral driver was it?
For anything not built into the CPU, I would not use bit-fields either.
Agreed.
However, for built-in, CPU-specific peripherals I do use bit-fields.

Possibly, but the true problem was about some asynchronous data link between
a PC and a 68k machine. Trust me, bitwise (well named!) rocks, and bitfields
simply don't work.

And to conclude, I'm used I write and debug on x86, and then recompile and
download to different targets like 68k or PowerPC.

--
-ed- get my email here: http://marreduspam.com/ad672570
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=c99
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

[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.

As long as you can rewrite the structure definition, the bit-field
approach is still, by far, the preferable solution, in terms of code
readability/maintenability. As Mark said, most of such code is so
hardware specific (drivers for built-in processor features) that it
doesn't even make sense to talk about porting issues.

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