• Measuring the Renesas Synergy™ Software SSP’s Software Quality

    Software quality is often either overlooked in embedded applications or assumed to be appropriate. Developers will often mention how their software is high quality or trust that the software they are provided is quality software. Ask a developer what metrics they use to measure software quality and the crickets will start chirping. Software quality is a measurable entity and the Renesas Synergy™ Platform was developed…

    • 20 Jul 2017
  • Transitioning to ThreadX® – Optimizing RTOS Applications for Memory Usage

    Surprise! You probably thought that our series on real-time operating systems was over. As it turns out, we missed an incredibly important topic that every developer needs to be aware of, optimizations! There are several areas where a developer may want to optimize their software such as performance and memory usage. In this post, we will discuss several techniques and tips for optimizing a ThreadX® based application…

    • 13 Jul 2017
  • Blocking versus Non-Blocking Renesas Synergy™ Software Components

    In many instances, developers working in a real-time environment need to know whether a driver or framework component that they are working with is going to exhibit blocking or non-blocking behavior. A blocking component will prevent any other component or function from executing while the component is being called. A non-blocking component on the other hand will start to perform the work but will allow other components…

    • 6 Jul 2017
  • Transitioning to ThreadX®: Event Chaining

    During the last dozen or so posts, we have been discussing how to use the real-time operating system ThreadX® within the Renesas Synergy™ Platform. The basics on how to setup a task, synchronize tasks and even common issues have been discussed. In today’s final post on transitioning to ThreadX, we are going to look at an advanced technique known as event chaining that is only available in ThreadX.


    • 29 Jun 2017
  • Transitioning to ThreadX®: Thread Starvation

    In the last several posts, we have been exploring common issues that developers encounter when designing an embedded system with an RTOS. So far, we have discussed priority inversion and dead locks which are potentially the most dangerous and elusive issues that a developer will encounter. In most instances, all the issues that a developer can encounter are self-inflicted through design oversights or improper implementation…

    • 23 Jun 2017
  • Transitioning to ThreadX®: Getting over the Jitters

    In the last several posts, we have been exploring common issues that developers encounter when designing an embedded system within an RTOS. In today’s post, we are going to look at a commonly overlooked issue with real-time embedded systems, thread jitter.

    Thread jitter should be a topic that every embedded software developer is familiar with even if they are nothing more than a super loop programmer. Thread jitter…

    • 23 Jun 2017
  • Transitioning to ThreadX®: Avoiding Deadlock

    In the last post, we discussed priority inversions and how developers can minimize and avoid them in their RTOS based applications. Priority inversions are not the only potential issue that developers can encounter. Another potential issue that developers may encounter that can wreak havoc on their system is known as the deadlock (also called the deadly embrace).


    Deadlock occurs when two or more threads are blocked waiting…

    • 6 Jun 2017
  • Transitioning to ThreadX: Avoiding Priority Inversion Issues

    Using a real-time operating system (RTOS) such as ThreadX® can go a long way in helping embedded software engineers manage their systems timing requirements and thread behavior. Embedded software developers who are just beginning to use an RTOS may not realize it but there are several potentially disastrous conditions that a developer can get their system into if they don’t carefully architect their software, manage their…

    • 30 May 2017
  • Transitioning to ThreadX®: Customizing ThreadX

    The Renesas Synergy™ Platform by default provides ThreadX® as a precompiled library. There is a huge benefit to doing this in that a developer doesn’t need to compile the source with their project which can dramatically increase compilation speed. There may be times though when a developer doesn’t want to use the default ThreadX configuration values. When this does happen, there is a simple process that developers can…

    • 24 May 2017
  • Transitioning to ThreadX®: Memory Pools

    In the last several posts, we have been examining the different tools available in ThreadX® real-time operating system (RTOS), that can be used to synchronize threads such as semaphores, mutexes, event flags and message queues. Task synchronization isn’t the only important concept RTOS application developers need to understand. Memory management is just as important if a system is going to behave properly and maintain…

    • 24 May 2017
  • Transitioning to ThreadX: Message Queues

    Embedded software applications occasionally may need to pass data around the application. When data needs to be passed or when data being received is going to be used to synchronize thread execution, a developer may decide to use a message queue. In this post, we will explore message queues and how to use them.


    A message queue is the primary method within an RTOS to transmit information from one thread to the next. A…

    • 15 May 2017
  • Transitioning to ThreadX: Event Flags

    Thread synchronization is typically done using semaphores and message queues. Developers often overlook a very efficient method for synchronizing task which is the event flag. In this post, we will examine the event flag object in detail and learn when and where we should use event flags over more traditional RTOS objects such as semaphores.

    An event flag group is essentially thirty-two individual bits that exist within…

    • 20 Apr 2017
  • Transitioning to ThreadX: Mutexes

    In this series, we are currently examining the different objects that exist within ThreadX to help developers synchronize events, tasks and move data around their applications. In this post, we are going to examine the mutex.


    A mutex is used for mutual exclusion which is where its name comes from, MUTual EXclusion (MUTEX). A mutex provides a method for a thread to gain access to a shared resource or even to a critical…

    • 20 Apr 2017
  • Transitioning to ThreadX: Semaphores

    In this series, we are currently examining the different objects that exist within ThreadX to help developers synchronize events, tasks and move data around their applications. In this post, we are going to examine the most commonly used RTOS object, the semaphore.

    A semaphore can play many roles in a real-time embedded application. First and most preferred, is that semaphores are used to notify the application that an…

    • 6 Apr 2017
  • Transitioning to ThreadX: Task Synchronization

    Threads are a great mechanism to break-up an application into smaller, more manageable pieces. Once a developer starts to create threads in their application, it becomes necessary to figure out how to synchronize the threads. Not every thread will exist in a vacuum all by itself. In many instances, threads will work together to fulfill the system requirements. In this post, we will examine the synchronization objects…

    • 29 Mar 2017
  • Introduction to the Synergy Wi-Fi Framework

    More embedded systems are requiring internet connectivity today than ever before. A number of these systems are looking to connect to the internet through wireless solutions rather than through Ethernet for added flexibility and mobility. Integrating Wi-Fi connectivity into embedded systems is often complicated and requires developers to get support from many disparate vendors such as MCU suppliers, Wi-Fi chipset or module…

    • 13 Mar 2017
  • Transitioning to ThreadX: Getting up to speed with TraceX

    In the last several posts, we have been examining how important threads are to a real-time embedded system. Each thread acts as its own semi-independent program that must have its stack properly sized and the right priority to ensure that it gets its share of CPU time. Threads are a key concept and most discussions around real-time design is focused on task behavior and synchronization. In this post, we will examine TraceX…

    • 4 Mar 2017
  • Transitioning to ThreadX: Managing Thread Priorities

    So far in this series we have been discussing how to create threads and properly size their stack so that developers are able to efficiently use their RAM while not risking a stack overflow. There is far more to thread management than simply getting the stack size correct. Developers need to understand how to make sure that all their threads will be able to meet their real-time deadlines. In order to accomplish this,…

    • 28 Feb 2017
  • Transitioning to ThreadX: How to Size the Stack for a Thread

    In the last post, we discussed how a thread is a semi-independent program and saw how every thread has a Thread Control Block (TCB) associated with it. The TCB allows a developer to configure how a thread will behave and set the stack size that will be associated with the thread. Don’t forget that every thread will have its own private stack in addition to the stack that is used during initialization. So how do we make…

    • 22 Feb 2017
  • Transitioning to ThreadX: Creating Threads

    Having access to a Real-time Operating System (RTOS) provides embedded system developers many advantages such as:

    • Breaking the software up into semi-independent programs
    • Deterministic scheduling
    • Providing pre-emption (highest available priority threads run first)
    • Providing a common tool set to synchronization activities within the software

    In the bare-metal universe, developers must fight with their system to adjust…

    • 10 Feb 2017
  • Coming up to Speed with e2 Studio 5.2.1 New Features

    There are few things that are as exciting as getting new tools and gadgets and the recent e2 Studio 5.2.1 release is no different! The latest release is packed with exciting new features that are designed to help make life easier for developers by simplifying the development process. In this post, we are going to examine the highlights and understand how they can benefit developers. For a quick feature overview, examine…

    • 1 Feb 2017
  • Using the new tool to create a Custom Board Support Package Pack

    A few months ago, I wrote a post about how to Create a Custom Board Support Package which demonstrated how to use batch files and some magic to make your very own board support packages. As you may remember, the process was far from straight forward but it got the job down. The latest e2 studio release now includes an export tool that is built into the development environment and dramatically simplifies creating a custom…

    • 27 Jan 2017
  • Switching from e2 Studio to IAR Embedded Workbench® for Renesas Synergy™

    For some time now, the Synergy Platform has had the IAR Embedded Workbench® for Renesas Synergy ™ development environment and compiler available to developers. Engineers that have been using e2 Studio might be hesitant to convert their e2 projects into IAR Workbench projects. Doesn’t this seem like it is going to be time consuming and require quite a bit of work? As it turns out, converting an e2 Studio project…

    • 26 Jan 2017
  • Importing and Exporting Synergy Software Projects

    One benefit that developers using the Renesas Synergy™ Platform get is the ability to leverage existing projects and integrate them into their own products. These projects could come as Synergy Application Projects that are used to become familiar with the platform or custom projects that are developed in-house to speed up development. Importing and exporting Synergy Software projects is slightly different and unique…

    • 19 Jan 2017
  • Synergy Platform Resources Every Developer needs to Know

    Getting up to speed on a new component, framework or platform can seem like a daunting task. There is so much to learn and so little time that without a little assistance, the process is overwhelming and time consuming. Renesas has pulled together numerous resources and made them available to developers to assist them in getting through the learning curve as quickly as possible. In this post, we will walk the reader through…

    • 19 Jan 2017