<img height="1" width="1" style="display:none" src="https://www.facebook.com/tr?id=1596188457259603&amp;ev=PageView&amp;noscript=1">

Code-block execution time measurement using SWV/ITM tracing [video tutorial]

Posted by Magnus Unemyr on Oct 7, 2016 10:47:22 AM

Most software developers are used to execution time profiling, where the execution time of different C functions are measured and visualized - usually as bar graphs with timing information added to the bars. But what if you want to measure the execution time of a code-block that is not exactly one complete function - and one function only?

Say, you want to measure the execution time of a block of code (for example, 15 lines of C code) somewhere deep within a function, or the time it takes from a push-button is clicked to some result is achieved. In the first example, you only want to measure the execution time of a small part of a C function, and in the latter example, you want to measure the execution time between two events across many functions. In neither of these cases, traditional execution time profiling is of any help. Luckily, you can easily do this using SWV/ITM tracing on Cortex-M microcontrollers. This free video tutorial show you how!

Read More

Topics: ARM Cortex, Debugging, Atollic TrueSTUDIO

ARM development: what do Cortex developers want from a modern IDE?

Posted by Magnus Unemyr on Sep 21, 2016 11:46:28 AM

In terms of ARM development, many software developers spend a major part of the work week in front of their ARM development tools; primarily the IDE with its integrated C/C++ compiler and debugger. How does a modern ARM IDE compare to what embedded developers were using a few years ago?

In this blog post, I will highlight some of the advances the embedded market has made in terms of the C/C++ IDE (including the compiler and debugger itself) – and in particular, what tool features are now available for ARM Cortex developers specifically.
Read More

Topics: ECLIPSE, ARM Cortex, GNU tools (GCC/GDB), Debugging, Embedded Software Development, Project migration, version control, issue management, editing

Are you ready to PACK?

Posted by Magnus Unemyr on Sep 7, 2016 1:12:34 PM

Delivery of standardized software components has always been a problem in the embedded systems market. ARM Ltd. now try to solve that problem by launching the CMSIS-PACK standard for software component discovery and distribution.
It remains to be seen how fast CMSIS-PACK gets traction as a standardized embedded software distribution system and replace other alternative solutions, but Atollic TrueSTUDIO already provides support for CMSIS-PACK to offer you full flexibility.
Read More

Topics: ARM Cortex, Atollic TrueSTUDIO

Read "Advanced development & debugging of ARM-based devices" [whitepaper series]

Posted by Magnus Unemyr on Aug 23, 2016 10:30:00 AM

Old habits can prevent you from making progress. It is often said that even after a long time, you only use the features of a software product you tried when you first installed the product. And so, many ARM Cortex developers still use only basic methodologies like single-stepping, running to breakpoints, and printf() debugging - despite having much more powerful capabilities already installed in their tools.

Make sure you don't fall behind other embedded developers - read this whitepaper to find out what great time-saving and quality-improving capabilities smart developers enjoy!

Read More

Topics: ARM Cortex, Software quality, Debugging, Atollic TrueSTUDIO, Embedded Software Development, version control, Getting Started, issue management

The embedded industry standardize on AGE

Posted by Magnus Unemyr on Aug 2, 2016 10:39:50 AM

The embedded industry has been incredibly fragmented for decades, resulting in inefficiencies and vast duplication of efforts. Small processor core ecosystems had to duplicate commodity "me-too" functionality instead of providing differentiation and innovation. With a plethora of competing CPU cores, the market was full of isolated islands with proprietary microcontroller architectures and their incompatible tool and middleware ecosystems. But finally, the embedded industry is coming of age. In fact, it now standardises on AGE!

Read More

Topics: ECLIPSE, ARM Cortex, GNU tools (GCC/GDB), Embedded Software Development

Specify & Download a Customized Kinetis SDK for TrueSTUDIO

Posted by Stephen Martin on Mar 1, 2016 10:28:01 PM

Supporting a new MCU target with Atollic TrueSTUDIO is much easier if you can import a working project. Did you know that NXP lets you build a customized Kinetis SDK ready to use in TrueSTUDIO?

Kinetis SDK is a collection of comprehensive software enablement for NXP Kinetis Microcontrollers that includes system startup, peripheral drivers, USB and TCP/IP stacks, middleware, and real-time operating system (RTOS) kernels. The Kinetis SDK also includes getting started and API documentation along with usage examples and demo applications designed to simplify and accelerate application development on Kinetis MCUs.

Read More

Topics: ARM Cortex, Debugging, Embedded Software Development, Kinetis

New Tools and Techniques for Cortex-M Debugging

Posted by Stephen Martin on Feb 29, 2016 11:31:50 PM

Embedded debugging has undergone a revolution thanks to innovations in the hardware and development tools. Gone are the days when you were forced to use command line debug and when you had to rely on blinking LEDs and printf() statements. Today's developers can take advantage of new data visualization and analysis tools that can help you quickly diagnose system problems in real time.

If you are developing for a Cortex-M target we'd like to introduce you to some ways to help you take your debugging to another level: find bugs more easily, and get new insights into the behavior of your system. Over the past year we have written a series of blog articles that will give you a good introduction to some of these easy-to-use tools and techniques.

Read More

Topics: ARM Cortex, Debugging, Embedded Software Development

Use profiling to avoid system bottlenecks [advanced Cortex-M debugging]

Posted by Magnus Unemyr on Jan 18, 2016 1:46:06 PM

Creating an optimized system is not always easy; there are so many places bottlenecks can occur, and understanding how the different parts of the system behaves are not always trivial.

The solution is called execution time profiling, that helps you measure how long time different parts of the system executes. Most Cortex-M devices enables execution time profiling without any expensive debug hardware, thanks to Serial Wire Viewer (SWV) event tracing. 

Read More

Topics: ARM Cortex, Debugging, Atollic TrueSTUDIO

How to perform runtime error checking on Cortex-M devices

Posted by Magnus Unemyr on Dec 18, 2015 9:17:47 AM

Embedded development is difficult, and embedded debugging may be even more so. Thus it is important to use the best tools in your toolbox. It appears to me that many Cortex-M developers are not fully aware of the powerful debug capabilities included in their Cortex-M based microcontrollers, like STM32, Kinetis, LPC or EFM32. This is valid for the super-useful Serial Wire Viewer (SWV) real-time event and data tracing capabilities, but perhaps even more so, the hard fault crash analyzis capabilities integrated in the Cortex-M core.

For example, our Atollic TrueSTUDIO debugger includes a hard fault crash analyzer, which detects hard-to-find runtime errors during full-speed target execution. Perhaps your system crashes a couple of times every week due to a sensor reading out-of-range values, causing a pointer error to bring the CPU to a hard fault due to accessing illegal memory or on misaligned address  boundaries.  Or your code performs a division by zero, once a week. These types of problems can be really hard to find and solve.

Read More

Topics: ARM Cortex, Debugging, Atollic TrueSTUDIO, SEGGER J-Link, ST-LINK

Atollic TrueSTUDIO v5.3.1 has been released!

Posted by Magnus Unemyr on Aug 11, 2015 2:12:07 PM

Despite the summer holidays being in full swing, our development team have today launched a new version of Atollic TrueSTUDIO, v5.3.1, which is a first-class C/C++ compiler and debugger IDE for professional ARM Cortex developers.

In particular STM32 and Kinetis developers will benefit from this new release, thanks to the improved integration with Freescale's ProcessorExpert software configuration tool, as well as extended target support for STM32 and Kinetis families. The new release includes improved support for Cortex-M7  targets too.

Read More

Topics: ECLIPSE, ARM Cortex, GNU tools (GCC/GDB), Debugging, Atollic TrueSTUDIO, RTOS

Real-time "live" variable watch on Cortex-M processors [debugger tips]

Posted by Magnus Unemyr on Jul 28, 2015 11:38:00 AM

ARM Cortex-M processors like STM32, Kinetis or EFM32 support live variable watch, a debugger feature that update the variables in a watch view in (almost) real-time as the target system executes at full speed. This feature is incredibly useful and can quickly help identify many bugs. Still, it appears many Cortex-M developers are not aware of this important debug capability.

I wrote another blog post on this topic some months ago, but I keep getting questions on the subject so I will cover live "real-time" variable watch once more. I would argue this capability is so useful and important, that professional embedded developers should not use an IDE without this ability. Let’s see how live variable watch debugger windows can be useful.

Read More

Topics: ARM Cortex, Debugging, Atollic TrueSTUDIO, SEGGER J-Link, ST-LINK

ARM Cortex devices are increasingly becoming dual-core: Are you ready?

Posted by Magnus Unemyr on Jul 20, 2015 1:16:00 PM

More and more ARM Cortex devices are dual-core, such as NXP’s LPC4300 with its Cortex-M4 and Cortex-M0 combo, or Freescale’s Vybrid equipped with Cortex-A5 and Cortex-M4 cores. Embedded systems using dual-core devices are typically fairly sophisticated, with an increased application complexity, which increases debugging difficulties compared to single-core systems as well.

Embedded systems developers moving from single-core to dual-core devices then ask: How do you develop and debug an embedded system using a dual-core processor? From a code development point of view, it is fairly easy. Just create two different projects in your ARM Cortex C/C++ IDE, and create each application project as if the device was a single-core processor. But how to debug asymmetric dual-core devices where the cores are not even using the same CPU core?

Read More

Topics: ARM Cortex, Debugging, Atollic TrueSTUDIO, SEGGER J-Link

The new standard in ARM development