1. Introduction to Data Structures

Loading...

Del curso dictado por University of Colorado Boulder

Embedded Software and Hardware Architecture

calificación

University of Colorado Boulder

Embedded Software and Hardware Architecture

calificación

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 introduce data structures for embedded systems.

All embedded systems need to store data.

That data can take on many different forms.

Data can represent sensor information, control information for

things like motors, or status information for active processes.

Typically, when you think of data, you should think of variables.

Variables are individual storage containers

that you have one specific type.

However, you will often want to store lots of variables, and

often associate one variable with another.

This is where we will begin to use derived and

enumerated text, built in to C-programming, as a mechanism to structure

our program data more efficiently, and create our own data types.

Combining numerous special data types together to form unique and

application dependent data structures can simplify our project design.

Structures are a mechanism that allow a software engineer

to organize data within a program.

They fundamentally allow you to associate certain types, together, and

create a special container for the set of variables.

Structures can be combined with many different features from our programming

languages to allow us to perform special operations.

A structure will allow you to create your own special type made

up of many different standard C-types, derived types, and enumerated types.

Enumerated data types are referred to as enums in C-programming.

Enums are a special type that usually represent a signed or

unsigned integer, about the size of a word.

These will allow us to create constant like types and allow the compiler to do

type checking and produce more maintainable and readable code.

C-programming provides numerous derived data types with very useful features for

storing data.

These include pointers, arrays, structures, and unions.

You have experience with some of these types already.

We will expand upon the structure keyword in C and

utilize unions to make our variables more dynamic in type.

We will then expand on features of the structure, including a special mechanism

called bit fields that will allow you to create smaller data-sized data members.

Taking all these features of structures and associated types, we can begin to

define specialized structures used to manage data, called the data structure.

Nearly every program uses some type of data structure, whether directly or

indirectly.

These are used for a variety of applications.

One could be for messaging from one program to another program, or

from one embedded system to another embedded system.

You could also use a data structure to help store and maintain gathered

information from a sensor, in potentially a contiguous or non-contiguous form.

And, additionally, data structures can allow you to control the program flow and

operation of your process.

There are a subset of data structures we will discuss that are used very regularly

in embedded systems.

These are the LIFO buffer, the circular buffer, and the linked list.

When you define data structures like these, you usually also need to create

associated functions to operate and interact with for your data structure.

Data structures are a very complex topic, and

in no way will we cover all aspects of them in a single module.

Typically, data structures are covered in a normal semester-long university course,

with numerous structure types being covered.

In this short module, we will provide you with a basic background of some of

the useful features and applications of creating your own data types.

Using structures that you will typically see in embedded systems programming.

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