3. Unions

Loading...

Del curso dictado por University of Colorado Boulder

Embedded Software and Hardware Architecture

calificaciones

University of Colorado Boulder

Embedded Software and Hardware Architecture

calificaciones

Embedded Software and Hardware Architecture is a first dive into understanding embedded architectures and writing software to manipulate this hardware. You will gain experience writing low-level firmware to directly interface hardware with highly efficient, readable and portable design practices. We will now transition from the Host Linux Machine where we built and ran code in a simulated environment to an Integrated Development Environment where you will build and install code directly on your ARM Cortex-M4 Microcontroller. Course assignments include writing firmware to interact and configure both the underlying ARM architecture and the MSP432 microcontroller platform. The course concludes with a project where you will develop a circular buffer data structure. In this course you will need the Texas Instruments LaunchPad with the MSP432 microcontroller in order to complete the assignments. Later courses of the Specialization will continue to use this hardware tool to develop even more exciting firmware.

De la lección

Designing Embedded Data Structures

Module 3 will introduce the learner to efficient and maintainable ways of organizing data. Most microcontroller programs require some use of structured data in order to track and manipulate the control flow or data in a program. These can be as simple as unions, enumerations or structures, but can be more complex with the use of abstract data structures. While abstract data structures are often discussed in higher level software, there are many simple examples that are used frequently in embedded system software.

1. Introduction to Data Structures3:48

2. Enumerations6:28

4. Structures and Encapsulation7:26

5. Bit Fields8:06

6. LIFO Buffer8:44

7. Circular Buffer7:22

8. Linked List8:08

Conoce a los instructores

Alex Fosdick
Instructor
Electrical, Computer, and Energy Engineering

In this video, we will talk about Unions.

Software developers allocate some type of data in every program,

whether those are constants,

dynamic memory, or local variables.

Usually, all of these have a fixed data type which is immutable.

Meaning, once you declare a piece of data,

you cannot alter its type.

This may or may not be desirable.

Maybe you want your type to be more dynamic.

What if you have a piece of data memory that you want to

interpret as one type in one function and a different type in another?

C programming provides a type to help with this called a Union.

That will allow us to reuse a variable and

interpret numerous ways depending on the types how it's defined.

Unions are a special type that allow a software engineer to define

a structure-like type where all members occupy the same address.

Unions are declared with a Union keyword.

Unlike a structure, where each member comes one right after another in memory,

each element in a Union has some overlap with other members defined in the same type.

Depending on the size,

there would be more overlap.

Unions can contain multiple members of different sizes,

and they are accessed in the same way that you access members in a structure.

You will use the dot operator,

or the inner operator,

if you have a Union pointer.

The size of a Union will be equal to the largest individual member.

And a Union can also be typedef for shorthand declarations for that Union type variable.

Here are a few examples of a Union.

First example shows a simple Union with three members,

X, Y, and Z, each a uint8_t.

The Union size is one byte,

even though there are three members.

If you were to investigate the address of the Union,

as well as each individual member,

you would see that they all share the same address.

I can assign data to the individual members.

If I first assigned to the X member the value of 13,

then a Union will contain the value of 13.

In fact, all members,

if you were to read them,

would contain that value.

If you now set the value to the Y member,

to 65, then the X value will now be overwritten, as well as the Y.

A second example defines a Union with multiple different sizes of members.

Here, we have a Union with a 16 byte array,

a uint8_t variable X,

a uint16_t variable Y,

and a uint32_t variable Z.

The size of this Union will be 16 bytes

because the largest member in this Union is the array,

which is 16 bytes long.

No matter how you use this Union,

it would always allocate 16 bytes,

even if you've never referenced the array variable.

Again, all of these variables occupy the same address.

The difference is that each of these extend further into that 16 byte allocation.

A third example defines a Union containing structures.

Here, we have a Union with two structures defined inside of it,

structure one and structure two.

These two structures have completely different implementations.

One is created with three uint8_t members and

the other is created with three uint32_t members.

If you wish to modify either one of the structure members,

you can do so with a double dot operator to

access the member of the structure inside the Union item.

However, by modifying one structure,

you will also change the other structure's data.

Unions are used regularly in the header files for

the Core Microcontroller Software Interface Standard,

or the CMSIS, provided by ARM.

Let's look at a few examples for the program status registers in the control register.

In these examples, a definition was created for each Core CPU Register using a Union.

The Unions allow for interaction with the register via structure in bit fields,

or by a word size data type.

With the word size data type,

you would need to do your own bit manipulation to access the bit fields in this register.

C programming bit fields provide a built-in way to simplify this bit manipulation.

We will cover that in an upcoming video.

Unions are typically a confusing software construct for developers.

However, here I have a good example to

show how a Union might be used in an embedded system.

In addition to the previous course,

CPU Registers, let's do one with shared memory.

Imagine two different functions that may need to have

a sizable piece of memory to do some data processing in,

and these two functions will be regularly called independent from one another.

They will never be running in parallel,

they will run to completion,

but another might get called.

You may not have enough space to statically allocate two full regions,

one for each of these functions.

Also, allocating and deallocating this memory individually will create unwanted overhead.

What if instead, both functions use

a shared resource that is just made up of a block of memory?

You may allocate this memory at the start of

your program to reduce the overhead at runtime,

and both interact with that one piece.

When function one needs to use this memory and

they want to interpret this space as a large bi-array,

like a character array for string printing.

Function two may want to interpret this memory as an array of structures,

say, a space to track the movement of a ball in space.

We'll call that structure, movement.

When each function runs,

they use a Union variable,

and they access their specific Union variable to interpret the space.

In reality, these are not necessarily functions but instead,

threads in a program running on an embedded operating system.

A process may provide this shared memory region as a resource to

each thread to get used for some amount of time as a storage place for its data.

This shared resource across two functions allows for

efficient reuse of memory without excess overhead,

allocating, and deallocating for each function call.

A space can be allocated in global memory, or a compile time,

with the linker file,

to configure this resource to start with.

Unions are a confusing feature in C programming but they allow for

more dynamic use of a piece of memory where you can interpret more than one way.

A developer may want to reuse a memory location with multiple different types.

Combining Unions and structures can give us

a powerful mechanism to manage and manipulate our memory.

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2018 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play