Question

On an embedded system we have a setup that allows us to read arbitrary data over a command-line interface for diagnostic purposes. For most data, this works fine, we use memcpy() to copy data at the requested address and send it back across a serial connection.

However, for 16-bit hardware registers, memcpy() causes some problems. If I try to access a 16-bit hardware register using two 8-bit accesses, the high-order byte doesn’t read correctly.

Has anyone encountered this issue? I’m a ‘high-level’ (C#/Java/Python/Ruby) guy that’s moving closer to the hardware and this is alien territory.

What’s the best way to deal with this? I see some info, specifically, a somewhat confusing [to me] post here. The author of this post has exactly the same issue I do but I hate to implement a solution without fully understanding what I’m doing.

Any light you can shed on this issue is much appreciated. Thanks!

Answer 1

In addition to what Eddie said, you typically need to use a volatile pointer to read a hardware register (assuming a memory mapped register, which is not the case for all systems, but it sounds like is true for yours). Something like:

// using types from stdint.h to ensure particular size values // most systems that access hardware registers will have typedefs // for something similar (for 16-bit values might be uint16_t, INT16U, // or something)  uint16_t volatile* pReg = (int16_t volatile*) 0x1234abcd;  // whatever the reg address is  uint16_t val = *pReg;  // read the 16-bit wide register 

Here’s a series of articles by Dan Saks that should give you pretty much everything you need to know to be able to effectively use memory mapped registers in C/C++:

• ‘Mapping memory’
• ‘Mapping memory efficiently’
• ‘More ways to map memory’

• ‘Sizing and aligning device registers’

• ‘Use volatile judiciously’

• ‘Place volatile accurately’
• ‘Volatile as a promise’