Join or Sign In
Renesas Synergy Platform
Forums & Groups
Synergy - Forum
Synergy - Media Gallery
capacitive touch (4)
e2 studio (32)
Hardware Abstraction Layer (5)
Integrated Solution Development Environment (29)
real-time operating system (4)
Renesas Synergy (17)
Synergy Platform (19)
Synergy software (5)
Synergy Software Package (21)
Synergy Xplorer (4)
Subscribe by email
By view count
By comment count
4 Dec 2017
Debugging Synergy Applications: Setting up and using printf
In the last post, we discussed how a developer can use advanced breakpoints to improve their debugging efficiency. We saw that there are different breakpoint types (hardware, software and flash) in addition to how we can trigger a breakpoint based on evaluating an expression. In today’s post, we will explore how to setup and use printf and discuss the advantages and disadvantages that come with it. The printf...
28 Nov 2017
Debugging Synergy Applications: Efficient Debugging using Breakpoints
The first line of defense used by embedded systems developers when debugging their software is to use breakpoints. Every developer knows how to create a breakpoint and step through code, but in many cases, developers don’t realize what’s happening behind scenes or that there may be more efficient methods available to them. In this post, we will examine how to use and manage breakpoints in the Renesas Synergy™...
28 Nov 2017
Debugging Synergy Applications: A Bug Squashing Technique Overview
Perhaps the greatest challenge facing embedded system developers today is debugging their software. Embedded systems have become complex and I’m not just talking about the software! Microcontrollers today are 32-bit processors, running upwards of 200 MHz with megabytes of flash and on-chip RAM. These chips have as much power and capability as full-fledged microprocessor systems that PC’s had back in the late...
20 Nov 2017
Transitioning to ThreadX® – Optimizing RTOS Applications for Speed
In the last post on Transitioning to ThreadX®, we looked at several different techniques that can be used to minimize an ThreadX® based application for memory usage. In today’s post, we will examine several different techniques that developers can use to maximize their applications for performance. First, a developer needs to recognize that a good RTOS will only use approximately two to four percent available...
14 Nov 2017
Using Renesas Synergy™ Software SSP Module Guides - Part 2
In the last post, we started to examine the module guides by using the AGT module guide as an example. We saw that each module guides provides developers with important information such as: Module features An API overview An operational overview How to use the module in a project How to configure the module And use the module This basic information helps a developer to understand the module and the pieces...
10 Nov 2017
The Renesas Flash Programmer: Programming and Configuration
In the last post, we started to look at the Renesas Flash Programmer and how we could use it to connect to a Renesas Synergy™ microcontroller. We successfully connected the flash programmer, but now we need to use the utility to load our software onto the microcontroller. In this post, we will examine how we can go about loading our code through the flash programmer. Before our application can be loaded onto the...
10 Nov 2017
The Renesas Flash Programmer: Setting up the hardware and software
At some point, after a painless and great experiencing developing a product based on the Renesas Synergy™ platform, it will be time to pass the product on to production and start the next big project. However, before that next project starts, developers need to put in place a way to program the production image into their product. There are several different ways this can be done such as The Renesas Flash Programmer...
30 Oct 2017
Using Renesas Synergy™ Software SSP Module Guides - Part 1
At one point or another, every developer has struggled to get a software module to work the way that they expect it to. Modern microcontrollers have graduated from the simple little 8-bitters into complex, feature rich 32-bit devices. We’ve all seen microcontroller datasheets that easily top two-thousand pages and are just warming up. Digging through and finding what is needed to initialize a peripheral can be daunting...
30 Oct 2017
Getting Familiar with the new Linker Editor
Nearly every embedded system requires that a developer dive into the linker file to parse out space for calibration data, look-up tables or even bootloader and application spaces. Despite modifying the linker file in most applications, developers are generally apprehensive and even intimidated by the linker file contents! All linker files are not created equal and the commands and structure for one compiler will rarely...
15 Sep 2017
Improving Software Quality using the C-Stat Static Code Analysis Tool
Improving Software Quality using the C-Stat Static Code Analysis Tool The excuse that I hear the most from embedded software engineers about why they do not use a static code analyzer is that they are too expensive! The company doesn’t have the budget to purchase the static analyzer and if they do or if they do, they are too time consuming to setup and use. But first, what is a static code analysis tool? Simply...
15 Sep 2017
Debugging Renesas Synergy™ Software Applications: Understanding Error Codes
Debugging a real-time application can be a daunting task for embedded software developers. In the good old days, systems were simple and bare-metal. A single developer could easily write every line of code for the application and still get the project delivered on-time. Embedded systems have changed. Products have become extraordinarily complex not just in their feature sets but in their timing and connectivity requirements...
7 Aug 2017
RAM Optimization Techniques for Renesas Synergy™ Applications
A horrible moment that every developer has encountered at one time or another is when they compile their application only to discover that it doesn’t fit on their microcontroller. The application may have reached its RAM limits or maybe even its code size. One thing is certain, the developer is in for an optimization session. The question is where to begin? For the Renesas Synergy™ Platform, there are several...
20 Jul 2017
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...
13 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...
6 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...
29 Jun 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. Event...
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®: 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...
6 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...
30 May 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...
24 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...
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...
15 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...
20 Apr 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...