Gartner says the Internet of Things installed base will grow to 26 Billion units by 2020

Do you want to be part of it?

Of course you do. And that’s why are are proud to announce the launch of Productize, a pre production agency devoted to assisting customers from concept to live test of connected objects.

Electronics are more accessible than ever and can be embedded anywhere. Because of the availability of the needed infrastructure and very low consumption electronics maturity, the objects of the IoT will invade our daily lives in no time.

And reinvent many businesses. What can it do for yours? How will you keep up or even be ahead?

Inquiries here : contact us!


Image source :

The Internet of Things. A critique of ambient technology and the all-seeing network of RFID

An interesting read when it comes to tomorrow’s cities with a huge lot of technology involved. Rob van Kranenburg explains how the adoption of the technologies of the City Control is not inevitable, nor something that we must kindly accept nor sleepwalk into.

A must read!

Nest Labs bought by Google for more than 3 billions USD. But why?

A month ago, Google bought Nest Labs.

What do they get for that (huge) price?

Well, they locked Tony Fadell to Google.

When Fadell left Apple, everyone expected something big to happen. He came with a thermostat and the disappointment was real. Because no one could understand how smart that was. 3 years later, Google got that right. Fadell beat Apple on this one and the big innovations steps in the smartphones and TV’s are behind. The next target are homes and cars. So for the price, Google now has the hardware (at which it has been struggling big time – Motorola, Nexus, Chromebook…), the guy and the network of connected homes.

Well done.

Competition, prepare to strike back.

Especially as Google got it all figured out : it’s all about hardware (and the software that runs on it) and that’s why Nest Team will become Google’s core hardware group!

More info here.

using efm32 simplicitystudio under Linux

So I went to a workshop yesterday mostly about the Silabs/Energy Micro micro-controllers. The workshop was rather interesting, but the workshop was done with the tools in Windows 7. As I’m working almost exclusively under Linux since 1998, this was quite a painful experience for me. Especially USB device handling is so much smoother in Linux. But enough about my windows pain. The EFM32 micro-controllers are based around ARM Cortex and seem to be genuinely nice ICs with a bunch of special low-power features. I’m not going to list all those as this is not a marketing post, you can find enough information about that on the internet already.

I came back home with two very nice dev-boards, which is pretty cool in itself!

EFM32 ZERO GECKO running a nice Space Invaders clone demo
EFM32 WONDER GECKO running a light sense demo


When I arrived back home I started reading up a bit more about the ICs and one of the first things I found  in a vid on youtube is that the simplicity studio is also available for Linux and OSX.

Going to the silabs download website only gave a download for windows, but a quick google brought me to the Energy Micro forum where there is a beta download or simplicity studio for Linux and OSX available. After a few tricks it works smoothly in Linux, if only I had known that a day sooner 😉


What I did to get a working installation on on my x86-64 Debian Jessy laptop:
  • download the simplicity studio beta
  • unzip the zipfile somewhere
  • enter the studiow/ map
  • start the shell script: ./
This will provide you with an installer for the simplicity studio software. This installer will install all the needed software. When the software is installed you can start simplicity studio itself also with ./
In the simplicity studio main tool page press the add-remove button and use it to install everything. This will download all the examples, demos and app-notes.
Now while the main tool works, I quickly found out that most sub-tools didn’t. It turned out that because simplicity studio is a 32-bit application and my system is 64-bit, I was missing some 32-bit libraries it needs, although I could imagine some people also missing some libraries on their 32-bit system.
A quick apt-get to the rescue:
sudo apt-get install libusb-0.1-4:i386 libqt4-svg:i386 
Depending on your system you may need to install some more missing libraries. This is rather easy to see as if you started simplicity studio from the command-line it will print out a missing library when you access a tool that is needing it.


The easiest way to play with the dev-kits is run some of the demos. Connect the board with the mini usb cable and press the Demos button in simplicity studio. Select a demo and press start. It will upload the demo and start the energyAware profiler program allowing you to real-time monitor the current consumption for that particular demo.

Compilers & Uploading

Demos are fun, but compiling your own code requires some more setup.
  • download and install the arm-gcc compiler from
  • in simplicity studio press examples, select the dev-board you’re using (EFM32WG_STK3800 for the wonder gecko, EFM32ZG_STK3200 for the zero gecko)
  • choose the blink example (or another one)
  • press open folder, this will open some gui explorer for your desktop environment
  • go to that directory in the shell, in my case it is /some/path/kits/EFM32WG_STK3800/examples/blink
  • enter the armgcc directory
  • there is a makefile there called Makefile.blink
  • open the file with an editor and a definition for your toolchain location to it, in my case I added
 LINUXCS := /some/path/gcc-arm-embedded/gcc-arm-none-eabi-4_7-2013q3
  • alternatively you could just export that LINUXCS to the environment
  • now do:
make -f Makefile.blink
  • it will now have made a file blink.bin in the exe/ subdirectory
  • you can upload this bin file with the tool called “energyAware commander”, this should be easy
  • alternatively you can use energyAware commander to upload from the commandline:
./ --flash /some/path /kits/EFM32WG_STK3800/examples/blink/armgcc/exe/blink.binThe same principle works for other examples and app-notes.

Some more pics

a closeup of the 128×128 sharp memory LCD display on the ZERO GECKO
ZERO GECKO running an analog clock demo
Cortex-M0+ closeup
Cortex-M4 closeup

a look inside the shielding can of the BLE112 Bluetooth Low Energy module

Given that I accidentally damaged this Bluetooth Low Energy anyway, I thought it interesting to take a look what is inside the shielding can with a macro lens.

Here you see the bluegiga BLE112 module on a board with the shield still in place:


And here I removed the metal shielding can:

As you can see no real surprises here:

The central unit is a Texas Instruments CC2540 SoC Bluetooth Low Energy module.
On the lower right of it sits a 32 Mhz crystal for the main clock.
Above it is what I assume the 32.768 kHz low speed clock crystal.

The antenna was already visible with the can in place, but what’s interesting is the second companion chip inside the can. I assume it is some kind of filter for the antenna.

Besides that just a few passives and that is it!

using madparts for making electronics footprints: an eleborate example

In this blog post I’m discussing a more complex footprint I’ve made and how I made it with madparts based on the vendor’s specification. More specifically I’m making a footprint for the Bluegiga BLE113 Bluetooth Low Energy module.

Lets start by collecting all the needed data.

The physical dimensions of the module are found in the spec page 16:
This will be used to define the physical boundaries of the package.
Next is the landing pattern. It can be found on page 17 of the specification:
 This is used to define the pads for the module.
The order of the pins can be found on page 7:
Finally the specification also gives a clearance for the antenna on page 20:
This means we’ll have to add a restrict area to the part for this clearance area.
let’s write code!
Define the size of the module as found in the physical dimensions:


  module_dx = 9.15
  module_dy = 15.74

Define the size of the pad as found in the recommended landing pattern:

  pad_dx = 2
  pad_dy = 0.5

The horizontal pads need an adjustment from the center of the module. The landing pattern defines 5.35mm between the two columns of pads, and we orient from the center of the pad so in total this gives and adjustment value of:

  pad_hadj = (5.35+pad_dx)/2

The landing pattern tells us the distance between pads:

  pad_between = 0.8

The pinout description gives the number of pins:

  n_left = 18
  n_down = 6
  n_right = 12

The physical dimension tells us the distance from the bottom of the module to the center of the bottom left and right pad. This works because the pad centers are the same for the physical diagram and the landing pattern.

  lr_pad_from_bottom = 1.45

Now this gets a bit tricky. We need to calculate the vertical adjustment needed for the column of pads, but this is relative to the center of the module. The trick is to take pad 18, move it to the 0 point, then to the bottom of the module, and then use the lr_pad_to_bottom adjust value specified in the spec.

  pad_vadj = ((n_left-1)/2)*pad_between  # move pad 18 to 0
  pad_vadj -= module_dy/2                # move pad 18 down to bottom
  pad_vadj += lr_pad_from_bottom         # and back up by 1.45

Let’s draw a rectangle to document the module shape, and draw a silk around it to make it easily visible on the board later.

  r1 = make_rect module_dx, module_dy, 0.1, 'docu'
  r2 = make_rect module_dx+0.2, module_dy+0.2, 0.1, 'silk'

Let’s define the pad shape with the earlier defined constant. we want 100% round corners.

  pad = new Smd 
  pad.dx = pad_dx
  pad.dy = pad_dy = 100

Now lets make the left row of pads. First make them, then adjust the x and y by the values we calculated earlier.

  l1 = single pad, n_left, pad_between
  l1 = adjust_x l1, -pad_hadj
  l1 = adjust_y l1 , pad_vadj

Next the bottom row. clone and rotate the pad, and create a horizontal row of pads. Adjust the y as specified in the landing pattern figure. Finally renumber starting with the number after the last number we used for the first column of pads.

  l2 = rot_single (rotate90pad clone pad), n_down, pad_between
  l2 = adjust_y l2, -module_dy/2+lr_pad_from_bottom-0.55
  l2 = generate_names l2, n_left

Finally the right row. Again a single row of pads. Reverse the order. Renumber starting after the last number used for the down pads.

  l3 = single pad, n_right, pad_between
  l3 = reverse l3
  l3 = generate_names l3, n_left+n_down
  l3 = adjust_x l3, pad_hadj
  l3 = adjust_y l3, pad_vadj+(n_right-n_left)/2*pad_between

Let’s add a name somewhere inside the module, a bit below the top:

  name = new Name (module_dy/2-1)

Let’s add a rectangular for the restrict area. This is a but messy but it boils down to placing it right above pas 36 and 3.5mm on the right of the left side of the module.

  k = new Rect
  k.type = 'restrict'
  k.dx = module_dx
  k.dy = module_dy/2-l3[n_right-1].y
  k.x = -module_dx/2+3.5+k.dx/2
  k.y = l3[n_right-1].y+pad_dy/2+k.dy/2

Finally combine it all in a list and we’re done.

  combine [name, r1,r2, l1, l2,l3, k]

The latest version of the full file can be found at

This is a screenshot:

And this is the part in eagle cad:

And in kicad:

programming the attiny10 in linux

The attiny10 (and it’s brothers attiny4,5 and 9) is a cute little 6-pin SOT23-6 AVR micro-controller. The very tiny footprint and low price makes it interesting as replacement for e.g. the 555 in simple circuits.

attiny10 sitting between a 5050 RGB LED and a 555 timer IC

Programming it seems to have been quite involved but the more recent gcc supports it just fine, making it finally easier to use. I tested with 4.8.1 downloaded from Atmel, as the one provided by Debian (also 4.8.1) did not yet have the definitions for the attiny10. It seems like the public source tree for the avr tool lags behind quite a bit against the Atmel provided toolchain …

For programming I’m using an AVRISP-MKII. I updated it to the latest firmware. This updating unfortunately requires avrstudio in windows; programming itself works fine in Linux.. You may also need a recent avrdude. I’m using 6.0.1.

Programming requires that the chip is powered by 5V according to the spec. I can confirm that this is the case because I tried it with 3.3V and it didn’t work, it tries to program but fails on verification.

Once programmed the chip runs all the way down to 1.8V.

The pin mapping is pretty obvious:

attiny10 pinout:

  2. GND
  4. PB2
  5. VCC
  6. PB3/RESET
AVRISP-MkII pinout:
  1. MISO
  2. VCC
  3. SCK
  4. MOSI
  5. RESET
  6. GND
And the mapping:
  • GND – GND
  • VCC – VCC
The following C++ code blinks a LED every second on pin PB2:
#include <util/delay.h>
#include <avr/io.h>

static inline void setup() {
  // configure PB2 pin
  PUEB &= ~_BV(PUEB2);   // disable Pull-Up
  DDRB |= _BV(DDB2);     // enable Output mode
  PORTB &= ~_BV(PORTB2); // set output to Low

int main() {


  while (true) {

    PORTB &= ~_BV(PORTB2);

    PORTB |= _BV(PORTB2);

  return 0;

The following makefile builds it and uploads it with the help of avrdude:

# Makefile loosely derived from generated avr toolchain makefile

PROG   := avrispmkii
MCU    := attiny10
F_CPU  := 1000000
TARGET := blink

COMMONFLAGS = -g -Os -funsigned-char -funsigned-bitfields 
  -fpack-struct -fshort-enums -Wall -DF_CPU=$(F_CPU) -mmcu=$(MCU)

CFLAGS = -std=gnu99 $(COMMONFLAGS) -Wstrict-prototypes 

CXXFLAGS = -std=gnu++11 $(COMMONFLAGS) -fno-exceptions -fno-rtti 

ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref

# TODO fuses
# FUSE:=-U lfuse:w:0xff:m -U hfuse:w:0xd9:m -U efuse:w:0xff:m

AVRDUDE:=avrdude -c $(PROG) -p $(MCU)

TC = /your/path/to/avr8-gnu-toolchain-linux_x86_64

CC      = $(TC)/bin/avr-gcc
CXX     = $(TC)/bin/avr-c++
OBJCOPY = $(TC)/bin/avr-objcopy
OBJDUMP = $(TC)/bin/avr-objdump
SIZE    = $(TC)/bin/avr-size

default: $(TARGET).hex




%.hex: %.elf
 $(OBJCOPY) -O ihex -R .eeprom $< $@
 $(SIZE) $@

%.elf: %.o
 $(CC) $(CFLAGS) $< --output $@ $(LDFLAGS)

%.o : %.c
 $(CC) -c $(CFLAGS) $< -o $@

%.o :
 $(CXX) -c $(CXXFLAGS) $< -o $@

%.s : %.c
 $(CC) -S $(CFLAGS) $< -o $@

%.o : %.S
 $(CC) -c $(ALL_ASFLAGS) $< -o $@

 -rm *.hex
 -rm *.lst
 -rm *.obj
 -rm *.elf
 -rm *.o

In action:

Entry without preview image

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.

  1. Nulla consequat massa quis enim.
  2. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu.
  3. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo.

Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus.

Read more