ECE 5725: Design with Embedded Operating Systems Project

01 · Course Introduction

ECE 5725: Design with Embedded Operating Systems is a graduate-level embedded systems course offered by Cornell University's School of Electrical and Computer Engineering.

The course uses the Raspberry Pi 4B and Linux as its primary development platform, combining Python and C++ programming with hardware interfacing and embedded application design.

Unlike projects focused exclusively on low-level microcontroller control, the course emphasizes developing integrated applications within an embedded Linux environment. Hardware interfaces, system software, application logic, and user-facing functions are combined into complete embedded systems.

02 · Learning Objectives

The primary learning objectives included:

• Becoming familiar with the Raspberry Pi 4B development environment

• Managing files, processes, and permissions in Linux

• Developing embedded applications using Python and C++

• Connecting and controlling external hardware through GPIO

• Understanding interactions between operating systems and hardware devices

• Testing, debugging, and deploying embedded software

• Developing hardware-software co-design and system integration skills

03 · Development Environment

The Raspberry Pi 4B served as the primary hardware platform, while system configuration and application development were completed within Linux.

The main technologies included:

• Raspberry Pi 4B: Running applications and interfacing with external hardware

• Linux: Managing files, permissions, processes, and runtime environments

• Python: Rapidly implementing hardware control, data processing, and application logic

• C++: Developing modules requiring greater performance or lower-level control

• GPIO: Connecting buttons, LEDs, sensors, and peripheral devices

• Shell: Configuring the system, executing programs, and supporting debugging

04 · Embedded Linux Practice

During the course, I gained experience in Raspberry Pi system configuration, SD-card backup and recovery, Linux permission management, and application environment setup.

The practical activities included:

• Configuring the Raspberry Pi operating system

• Managing files and directories through the command line

• Setting file permissions with commands such as chmod

• Compiling and running Python and C++ applications

• Managing dependencies and runtime environments

• Backing up and recovering Raspberry Pi SD cards

• Diagnosing software issues through logs and terminal output

These activities provided a foundation for developing and maintaining embedded Linux systems.

05 · Hardware-Software Integration

The course projects required software applications to interact with physical hardware. Programs received external inputs, processed information, and controlled corresponding outputs.

A typical system workflow consisted of:

1. A sensor or hardware component generates an input

2. The Raspberry Pi reads the input through GPIO or another interface

3. A Python or C++ application processes the data

4. The system makes a decision based on the programmed logic

5. An actuator, display, or other device produces an output

6. The system records and presents its operating status

This process strengthened my understanding of the relationship between input, processing, and output in embedded systems.

06 · Software Design

The course emphasized modular software architecture, separating system responsibilities into relatively independent components.

The main software components included:

• Hardware interface initialization

• Input data acquisition

• Data processing and state evaluation

• Application control logic

• Output device control

• System status recording

• Exception handling and recovery

Python supported rapid prototyping and application development, while C++ could be used for components requiring stronger performance or more precise resource control.

07 · System Debugging

Debugging embedded systems requires simultaneous consideration of both software and hardware behavior.

Typical development challenges included:

• Incorrect GPIO configuration

• Insufficient file or execution permissions

• Inconsistencies between hardware connections and pin definitions

• Missing dependencies or runtime configuration

• Unstable input readings

• Incorrect program execution order

• Repeated use of system resources

• Failure to recover after abnormal program termination

I used terminal output, system logs, modular testing, and hardware inspection to locate problems. Individual modules were verified before integration into the complete system.

08 · Course Outcome

Through ECE 5725, I developed a stronger understanding of embedded Linux application development and the relationship between operating systems, software applications, and physical hardware.

The course strengthened my abilities in:

• Raspberry Pi application development

• Linux command-line and permission management

• Python and C++ programming

• GPIO hardware interfacing

• Modular embedded software design

• Hardware-software system integration

• Application testing and troubleshooting

• Embedded system deployment and maintenance

This experience expanded my skills from microcontroller programming to operating-system-based embedded application design and prepared me for developing more complex integrated systems.