Since websites change over the time, there might be some broken links in this page. However, it is possible to obtain the content by searching the title of the page on any search engine such as Google.

Using requirements planning in embedded systems design:
Part 1 - Dissecting the requirements document
Part 2 - Extracting communications pathway requirements
Part 3 - Defining system timing requirements
Part 4 - Defining the system-level design
Part 5 - Managing communications between tasks
Part 6 – Determining your system’s task timing parameters

I don't need no stinkin' requirements!

I desperately need stinkin' requirements

Examining your most important tools

Getting disciplined about embedded software development:
Part 1 - Any idiot can write code
Part 2 - The Seven Step Plan
Part 3 - The value of postmortems

Picking the right system design methodology for your embedded apps: Part 1, Part 2

The basics of being Agile in a real-time embedded systems environment: Part 1, Part 2, Part 3

Software development team collaboration across disciplines using UML/SysML

Embedded system design with open source software: doing it right

Treat programmable hardware design as a high level system task

Clearing the hurdles of HLS adoption

Viewpoint: Why programmability is now a game changer

Using platform independent models to proliferate code across multiple application environments

Need for modeling tools rises with design complexity

Electronic System Level (ESL), anyone?

Designing with an embedded soft-core processor

Is software the new hardware?

It’s not just about hardware anymore

On design metrics

The four Rs of efficient system design

Hardware Design Requires Hardware Design Languages

Making embedded processing development easy

Architecture of safety-critical systems

KESO: A Java VM an MCU developer could love? Maybe

Selecting 8-bit MCUs: A practical guide

Microcontroller architectures, then and now

Achieving better software performance through memory-oriented code optimization: Part 1, Part 2

A guide to domain specific modeling:
Part 1: Code- vs. model-driven design
Part 2: Modeling examples
Part 3: Higher abstraction levels

Building a digital watch using Domain Specific Modeling:
Part 1 – Creating a watch modeling language
Part 2 – Putting it all together
Part 3 – code generation for watch models

Modeling of embedded designs:
Part 1: Why model?
Part 2: Modeling method examples
Part 3: Where to model

DSM in home automation network design:
Part 1 - Building a model-based language
Part 2 – Using a model-generated language

Android, Linux & Real-time Development for Embedded Systems

Back to the Basics - Practical Embedded Coding Tips
Part 1, Part 2, Part 3, Part 4, Part 5 Part 6

The basics of programming embedded processors
Part 1, Part 2, Part 3, Part 4, Part 5, Part 6, Part 7, Part 8, Part 9.

Using SystemC to build a system-on-chip platform

Down & dirty with HW/SW co-design:
Part 1 - Reviewing the fundamentals.
Part 2 - Co-synthesis algorithms
Part 3 - Cosynthesis of multiprocessors
Part 4 – Multi-objective optimization

Implementing a new real-time scheduling policy for Linux:
Part 1, Part 2, Part 3

Understanding embedded-system-boot techniques

Basics of SoC I/O design:
Part 1 - The building blocks
Part 2 – Hot swap & other implementation issues

Guide to VHDL for embedded software developers:
Part 1 – Essential commands
Part 2 - More essential commands
Part 3 - ALU logic & FSMs

Accelerating algorithms in hardware

FPGA programming step by step

Basics of core-based FPGA design:
Part 1 – core types & trade-offs
Part 2 – System design considerations
Part 3 – Picking the right core options
Part 4 – Implementing a design

The art of FPGA construction

Generate FPGA accelerators from C

Seventeen steps to safer C code

Fundamentals of Booting for Embedded Processors

Tutorial: Floating-point arithmetic on FPGAs

Doing Math in FPGAs: Part 1, Part 2, Part 3 Part 4 Part 5 Part 6

Six Rules for Writing Clean Code

Getting started with Embedded Linux: Part 1, Part 2, Part 3, Part 4, Part 5, Part 6, Part 7, Part 8, Part 9, Part 10, Part 11

Bluetooth 4.0: An introduction to Bluetooth Low Energy: Part 1, Part 2

The MCU guy's introduction to FPGAs: The Hardware, The Software

How I test software

Developing a good bedside manner

Why debugging takes way longer than you'd think

Debugger Tips: 8 ways breakpoints can save your next software project

Five top causes of nasty embedded software bugs

The lawyers are coming!

Li Mei’s list of debugging secrets

Tips on building & debugging embedded designs: Part 1, Part 2

Ten tips for debugging MCU

In-target embedded software test automation and quality

Making embedded system debug easier: useful hardware & software tips

Verifying embedded software functionality: Why it’s necessary

The Art of Test:
Part 1: Boards, Subassemblies, & Products
Part 2: Controlling the Test
Part 3: Lessons Learned

7 Tips for debugging embedded software

Getting Started with Multicore

Transitioning to multicore processing

How to analyze C-code for parallelization

Getting real (time) about embedded Windows by using virtualization

Getting real (time) about embedded GNU/Linux

Myths and realities of real-time linux software systems

How to use new unit testing tools & techniques to improve software quality

The basics of doing PID design:
Part 1 - Classical control theory
Part 2 - Building PID predictive controls
Part 3 - Freewheeling with PID controls

Tips for efficient embedded code generation

Industrial sensors and control - The basics: Part I, Part II, Part III Part IV Part V

Introduction to Web Services

From Pong to PlayStation 3: Video games through the years

All About Batteries:
Part 1: Introduction
Part 2: Specifications & Terminology
Part 3: Lead-Acid Batteries
Part 4: Alkaline Batteries
Part 5: Carbon Zinc Batteries
Part 6: Zinc-Air
Part 7: Lithium Thionyl Chloride
Part 8: Zinc/Silver-Oxide
Part 9: Sodium Sulfur (NaS)
Part 10: Lithium Sulfur Dioxide (LiSO2)

ASIC, ASSP, SoC, FPGA – What's the Difference?

Introducing FPGA-Based Acceleration for High-Frequency Trading

Why and how to measure your RTOS performance

Useful things to know about Ph.D. Thesis Research

The illustrated guide to a Ph.D.

A lógica da redação científica

IEEE Spectrum's Special Report: Top 11 Technologies of the Decade

Embedded Systems - High Performance Systems, Applications and Projects (eBook - open access)

Embedded Systems - Theory and Design Methodology (eBook - open access)

Reverse Engineering - Recent Advances and Applications (eBook - open access)

So this is progress

The Biggest-Little Revolution: 10 Single-Board Computers for Under $100

Raffaello D'Andrea: The astounding athletic power of quadcopters

Unified Modeling Language (UML)

The UML Profile for MARTE: Modeling and Analysis of Real-Time and Embedded Systems

Eclipse Modeling Project

Introducing EMF - Chapter 2 from the book “EMF: Eclipse Modeling Framework, 2nd Edition”.

An introduction to ATL concepts (M2M/Atlas Transformation Language)

ATL User Guide - Introduction

Eclipse Modeling Framework (EMF) - Tutorial

Eclipse Modeling Framework (EMF) - Persisting models via XMI

Papyrus UML Project, MDT Papyrus

Top Cased Project

Prof. Dr.-Ing. Carlos Eduardo Pereira's website
UFRGS' Embedded Systems Lab
UFRGS' Control, Automation and Robotics Lab

Prof. Dr.rer.nat. Franz Josef Rammig's website
HNI's Distributed Embedded Systems Lab

UFSC's Software/Hardware Integration Lab