Know your Tool – Optimize C Code for microcontrollers

One of the talks in the “Embedded Linux Conference 2016” was about best practices to optimize C for microcontrollers. This talk deserves to be mentioned to Electronics-lab readers.

The presenter Khem Raj worked on Comcast’s (broadcasting and cable television company) reference design kit for STB, Gateway and IoT platforms.

We will cover some important points that have been suggested by the presenter:

Optimization Levels

Optimization in compilers in general (GCC is the one in Khem’s case) has different levels (5 Levels: Os, O1, O2, O3 and Og). Os is for size optimization while O1, O2 and O3 are for performance.

Optimization Levels - From Khem’s slides
Optimization Levels – From Khem’s slides


Linker which is an important tool in microcontrollers’ software toolchain, is mentioned in Khem’s talk.

Linker script is written in the linker command language and controls the memory layout of the output file (what goes where). Moreover, Linker can output a map file which is very useful when you want to track down references to symbols in the MCU memory.

Linker Script File - From Khem’s slides
Linker Script File – From Khem’s slides


GNU GCC has a collection of binary tools; they are called (binutils); and objdump is one of them. It interleaves your assembly code with source code so you can do disassembling using it.


Talking about best practices with variables. If the concept of local, global, volatile, const and static are blurred for you, then watching this presentation will clarify them besides other important terms.

Khem also mentioned special integer types in C99; they are “fast” and “least” types. So you can allocate your variable like that:

  • Fixed width unsigned 8 bit integer uint8_t
  • Minimum width unsigned 8 bit integer uint_least8_t
  • Fastest minimum width unsigned 8 bit integer uint_fast8_t

To ensure portability of your code, Khem advised to use portable datatypes using uint{8,16,32,64}_t type declaration. This avoids effects of changing size of int type across different processors (compilers).

Using global and local variables is another concern. Khem advised to use local variable as much as possible. Global variable needs to be loaded from memory and stored back every time it is used. So if you use a global variable in a loop you will have multiple loading and storing operations.

Khem’s presentation has other tips about: array subscript Vs. pointer access, loop increments Vs. loop decrements and other stuff. Make sure to watch the presentation, all of it!

Screens become speakers, smartphones can lose micro-speakers

by Graham Prophet @

Redux (London UK) has followed earlier announcements of its surface-wave-based haptics technology with a version specifically targeted at the smartphone, with which it aspires to “kill off smartphone micro-speakers”.

FPGA eink controller

Julien @ build a custom board to control e-ink display. He writes:

The idea is to control an old broken kindle 3 eink display with a FPGA. I started looking at and since eink constructor is so secretive that you can’t find any information. I got some success with a stm32f4 microcontroller but was disapointed by the poor performance (low refresh, black and white only). So I decided to do something better using an FPGA and some memory, I started with the ice40 Olimex board

FPGA eink controller – [Link]

Individually addressable incandescent lamps

Michael wrote an article on controlling a bunch of lamps individually with WS2811 drivers and Arduino. [via]

I simply used the same technology as LED strips to allow communication between lamp modules. LED strips have RGB LEDs with an embedded driver chip which uses PWM (pulse width modulation) to control the duty cycle on the red, green, and blue LEDs. This combined LED/chip is called WS2812 or WS2812B. On older LED strips, the driver chip was not embedded into the LED itself, but was a separate chip called WS2811. These standalone driver chips are somewhat obsolete now which means they are cheap! I got 50 of them on eBay for $5.00. Since these modules use the same technology as LED strips, the same code can be used. Adafruit’s NeoPixel library is a very simple way to control LEDs, so we can control each lamp easily. The lamp is controlled by the “blue” pin on the WS2811 so that is the value to set.

Individually addressable incandescent lamps – [Link]


ESP32 Web Server – Arduino IDE

Rui @ tipped us with his latest project. He writes:

In this project you’ll create a standalone web server with an ESP32 that can toggle two LEDs using the Arduino IDE programming environment. If you want to learn more about the ESP32 dev board, read my Getting Started Guide with ESP32.

ESP32 Web Server – Arduino IDE – [Link]

Smallest seismic sensor uses vibration spectral analysis

Graham Prophet @ discuss about a new small seismic sensor from Omron:

Omron Electronic Components believes it has the world’s smallest class size seismic sensor, specifically designed to trigger the shutdown of potentially hazardous or easily damaged systems in the event of an earthquake.

Smallest seismic sensor uses vibration spectral analysis – [Link]

Simple circuit indicates a low battery

@ writes:

The Design Idea in Figure 1 indicates a low-battery condition in an audio test instrument that is powered by four AA cells. As the instrument was otherwise an all-discrete design, this same approach seemed more in keeping with the spirit of the project than the use of a single-sourced integrated circuit.

Simple circuit indicates a low battery – [Link]

ESPurna-H, A Compact Open Source Hardware Wireless Power Wall Switch

Controlling your AC loads using wireless power switch is not a new concept. Several commercial products from several vendors can be found on the market such as Xiaomi’s Mi Smart Socket Plug, SAMSUNG’s SmartThings Power Outlet and Sonoff Pow WiFi Switch from ITEAD.

Using ESP8266 makes the building of a customized WiFi power switch more affordable especially if you start with Sonoff Pow WiFi Switch design and you use a special Arduino C firmware called ESPurna developed by Xose (tinkerman) which is an open source firmware for ESP8266 based wireless switches such as Sonoff POW and many others.

After Xose has built the software ــ ESPurna, he decided to build his own smart switch board to meet his special needs. ESPurna-H electronic design is very similar to Sonoff POW’s one; it uses ESP12 module as a controller and as WiFi transceiver.


AC power monitoring is done using HLW8012 IC which is also present in Sonoff POW. This IC monitors both voltage and current of the AC power, and output RMS voltage, current and active power encoded as a 50% duty cycle square wave where the frequency is proportional to the magnitude. I should mention that ESPurna supports interfacing with HLW8012. In addition AC load is enabled/disabled by using a 10A relay.

ESPurna-H uses HLK-PM01 AC-DC step-down power supply module. The 100-240 VAC input range so the board can be used anywhere in the world and the good performance made Xeos select this module.

HLK-PM01 Inside (Image Source ــ )
HLK-PM01 Inside (Image Source ــ )
HLK-PM01 Inside (Image Source ــ )
HLK-PM01 Inside (Image Source ــ )

ESPurna-H has another option to enable/disable the relay using a capacitive touch switch using TTP223 module.

Xose designed the board with Eagle CAD and released the schematics, PCB layout and other hardware design files on Github.

Source: cnx-software

Exploring Eagle CAD ULPs #5 – Place50.ULP Place All Parts of The Board to The Position in The Schematic

Welcome to the 5th post of the “Exploring Eagle CAD ULPs” series. Each post will be about one  useful ULP in Eagle CAD.

“ULP” User Language Program is a plain text file which is written in a C­-like syntax and can be used to access the EAGLE data structures and to create a wide variety of output files. You can think about it as a plug-in for Eagle.

You can reach the posts published in this series using the following link.

In this post, we will discuss an autoplacer ULP. Normally, Eagle CAD places parts in the board without any considerations to electrical connections, and there isn’t any built-in auto-placing tool in Eagle.

Without the help of ULPs, you will need to do this task manually by moving connected parts near to each other. However, some ULPs can solve this problem ــ manual placement is a time consuming task when the PC can help us !.

Place50 ULP has a simple and smart idea. It’s an autoplacer which places all parts of the board to the position in the schematic. To use this ULP first download it from Autodesk website to run it in schematic. Running this ULP from schematic editor will generate a script file in your home directory. Now open board editor and run the script file “place.scr”.

I made a little edit to the original ULP to make the script file be saved in the same directory of the project rather than the home directory. Download it from here.