Choosing the right microcontroller

I came across this interesting article of Jay Carlson (electronics engineer and embedded software developer) in which he extensively reviews various popular and less known microcontrollers. Good reading material for your next embedded project!

The Amazing $1 Microcontroller

Trying out if all fits well before the final assembly.

Woodworker’s workbench in progress

This year’s Summer holidays give me the opportunity to spend a fair amount of time on my workbench project. So far it enabled me to finish the construction of the worktop and the three supports it will come to rest on. I’ve already made a start on joining them together in a detachable way.

Plenty of little things remain to be done such as adding a wooden frame around the worktop, mounting the vice, sanding everything, and applying a layer of varnish.

I’ve made a compilation of the build process available on this page which I will update as I progress with the workbench.

Gedit logo

Gedit PlantUML plugin 2.0.0 released

Development on the Gedit PlantUML plugin stagnated for while, but the last couple of months I finally managed to find some time to finish the planned redesign. It can be downloaded here.

This release targets Gedit3, and has a cleaner and better design. Firstly, it now uses Gedit for detecting when a PlantUML source file is saved (which triggers the re-generation of the UML), instead of periodically polling the file system. Secondly, it uses a multiprocessing approach to decouple the processing-heavy task of generating UML from Gedit. This greatly improves the responsiveness of Gedit. Lastly, the behavior of the PlantUML Viewer has improved, as it now shows a spinner when UML generation is in progress, and behaves better when moving UML diagrams.

Since most Linux-distro’s (including mine) ship Gedit3 nowadays, I decided to stop the development for the Gedit2 version of the plugin. Its latest development version is still available for download for those who need it.

Enjoy the plugin! If you encounter anything unusual, or would like some feature to be added, please don’t hesitate to contact me!

Laws of Test Driven Development

Test Driven Development

Last week my colleague Auke Klazema held a short presentation on Test Driven Development (TDD) – you can find it on his website. He already explained me the principles of TDD some weeks earlier, and I was able to implement a small Python module the TDD-way since. My initial experience is that TDD forced me to think about how I would want to use the module under creation early in the process. It also forced me to setup the implementation in a way that makes it more easy to verify. I’ll definately give TDD a try – in other words: try to supress the habit of starting with coding the functionality right away 🙂

Two Python ‘features’ I learned today

Every programming language has its own funny, unusual, and good-to-know language constructs. Today, I came to learn two such language constructs in Python.

Finding a needle in a haystack

Consider the following way to check if a needle exists in a haystack:

print("Needle" in "Haystack")

When run, this will print False, as one would expect, since “Haystack” doesn’t contain a substring “Needle”. Python can also check if the “Needle” in a list or tuple, like this:

print("Needle" in ["Needless"])
print("Needle" in ("Needless"))

The first would print False, since “Needle” as a whole word is not an element in the list. The second however would print True, because the 1-tuple is not defined correctly. Consequently, the parenthesis are ignored and “Needle” is found a substring of “Needless”. When the 1-tuple is defined the right way (note the trailing comma) False will be printed:

print("Needle" in ("Needless",))

Something to be aware of!

Using a default value for a function argument

It is very convenient to be able to specify some default value for function arguments. For example like this:

def print_message(message, log_level="INFO"):
    if log_level is "INFO":
        print("INFO:   ", message)
    elif log_level is "WARNING":
        print("WARNING:", message)
    elif log_level is "ERROR":
        print("ERROR   ", message)

If we would call the function with print_message(“Smells like teen spirit”), the “INFO: Smells like teen spirit” would be printed. Note here that the default value for log_level is immutable; it is a string constant, not an object. Now consider the following:

def add_to_basket(item, basket=[]):
    return basket

if __name__ in "__main__":
    print add_to_basket("Bananas")
    print add_to_basket("Apple")
    print add_to_basket("Pear")

Since basket a function argument, I would expect it to have a scope local to the function. In reality however, the three print statements would subsequently output:

['Bananas', 'Apple']
# and
['Bananas', 'Apple', 'Pear']

In other words, basket behaves like a static variable in C would. It appears that Python treats functions just like classes, and that default function arguments are a kind of member data. As long as the default value is immutable you won’t experience this behavior, but when it is a mutable value (a list, dictionary, or other object) the function argument will behave this way.

Good to keep in mind that if I need to use an mutable object as default argument value, I should use the value None and check for this value inside the function in order to set it to its actual default value, e.g.:

def add_to_basket(item, basket=None):
    if basket is None:
    return basket

In case basket equals None, the above example would return a list with only the given item in it.

No more Dutch

So far this website has been a mixture of blog-posts in Dutch and pages in both Dutch and English. The website gets a bit messy this way. Besides that it feels stupid to put time and effort in writing content in more than one language considering that most visitors can read English, and considering that I have little free time anyway. As such, I decided to write posts and pages in English only from now on.

PyCharm Python IDE

Wanneer ik programmeer in C of C++ dan maak ik graag gebruik van een IDE, onder andere vanwege de mogelijkheden die het biedt tot code-completion en refactoring. In het geval van C/C++ gebruik ik veelal Codelite of soms QtCreator. Voor het beetje Python dat ik schreef (voor een PlantUML plugin voor Gedit) gebruikte ik Gedit – Codelite of QtCreator bieden in geval van Python dezelfde functionaliteit. Inmiddels ontwikkel ik op mijn werk ook Python toepassingen en verlang ik toch naar een ontwikkelomgeving die wat geavanceerder is. Na een rondgang langs potentiële Python IDE’s kwam ik uit op PyCharm. Voor de volledigheid hieronder de Python IDE’s die ik heb bekeken:

  • PIDE
  • IDLE
  • Eric
  • Eclipse-pydev
  • PyCharm

PyCharm installeren

Ik geef er de voorkeur aan om PyCharm niet te installeren vanaf de PyCharm website, maar via een Getdeb repository. Aan /etc/apt/sources.list.d/additional-repositories.list moet de volgende regel moet worden toegevoegd:

deb xenial-getdeb apps

Ik gebruik Linux Mint 18 (gebaseerd op Ubuntu 16.04), dus in mijn geval moet ik de xenial variant hebben. Eenmaal toegevoegd zijn nog een drietal commando’s nodig om PyCharm te installeren:

wget -q -O- | sudo apt-key add -
sudo apt-get update
sudo apt-get install pycharm

C’est tout!

Generic Data Structures Library in C

Wanneer ik programmeer in C++ maak ik graag gebruik van de Standard Template Library. Voor embedded software systemen geldt echter vaak de verplichting/limitatie tot het programmeren in C in plaats van C++. Ik vroeg me daarom onlangs af of er ook een C-equivalent bestaat voor de C++ STL.

Een korte zoektocht naar vrij beschikbare implementaties van geavanceerde datatypen (zoals de lijst, vector en de queue) volgde. Ik had niet de verwachting dat er een dergelijke set geavanceerde datatypen (ADT’s) zou bestaan voor C in een template-achtige vorm, maar ik was wel verrast slechts één resultaat te vinden. Ik vond de Generic Data Structures Library van Nicolas Darnis. De bibliotheek bevat C implementaties van een hele reeks aan ADT´s, onder andere: (singly/doubly) linked list, tree, matrix, stack, heap, hash, queue, en nog enkele anderen.

Het GDSL project lijkt actief en bovendien is de uitgebreide API goed gedocumenteerd en voorzien van voorbeeld-code. Wat mij betreft een interessante ADT-bibliotheek om in een C (embedded) software project eens uit te proberen!


Na lang zoeken heb ik een WordPress-thema gevonden dat consistent is en er goed uitziet, ook op mobiele apparaten. Het biedt me de mogelijkheid om projecten waarbij ik betrokken ben geweest (of nog steeds ben) op een portfolio-pagina weer te geven. Een drietal software-projecten zijn inmiddels toegevoegd.

Buurtlinux is een website waarop Linux-gebruikers en Linux-professionals hun hulp en diensten aanbieden. Andere computergebruikers, die Linux een keer willen uitproberen of die een vraag of probleem hebben omtrent Linux, kunnen op een kaart zoeken naar Linux-hulp bij hun in de buurt (Nederland en België). Inmiddels wordt Buurtlinux beheerd door de Nederlandse Linux Gebruikers Groep.

Voor kleine embedded systemen betekent het gebruik van de meeste besturingssystemen een zware overkill. Met Golem heb ik destijds geprobeerd om een lichtgewicht en veel simpeler besturingsysteem te maken dat gebruik maakt van cooperative multitasking.

Gedit PlantUML-plugin
Ik maak in mijn werk meer en meer gebruik van UML en vond het lastig een programma te vinden waarmee ik op een prettige wijze UML-diagrammen kan tekenen. Het programma PlantUML biedt de mogelijkheid om ‘scriptenderwijs’ UML-diagrammen te genereren. Ik maak veel gebruik van Gedit en heb daarom een plugin geschreven waarmee je vanuit PlantUML bronbestanden automatisch de bijbehorende UML-diagrammen kunt genereren.

Wooden workbench for furniture makers (

Het ontwerp van een houtwerkbank

Na flink op Pinterest te hebben rondgestruind en een bezoek te hebben gebracht aan heb ik een uiteindelijk ontwerp gemaakt van de houtwerkbank die ik voor mezelf wil gaan maken.

Hoewel timmermanswerkbanken en meubelmakerswerkbanken doorgaans gemaakt worden van beukenhout, kies ik ervoor om vurenhout te gebruiken. Ik houd hier in mijn ontwerp wel rekening mee door voor een veel massievere constructie te kiezen.

Deze tijdelijke werkplek zal worden vervangen door de werkbank

Deze tijdelijke werkplek zal worden vervangen door de werkbank

De houtwerkbank zal tussen drie muren komen te staan en zal een blad krijgen hebben van ongeveer 220 cm bij 80 cm. Ik verwacht dat ik er vooral staand aan zal werken en om die reden neem ik de werkhoogte van ons aanrechtblad als hoogte over. Deze is 95 cm.

Deze schets geeft een idee van de opbouw en maten van de werkbank.

Deze schets geeft een idee van de opbouw en maten van de werkbank.

Mijn idee is om een drietal stevige staanders te maken, zoals die links in de ontwerpschets te zien is. De staander in het midden zal iets afwijken van de andere twee staanders om ruimte te bieden voor de in het midden geplaatste bankschroef.

Het werkblad zal bestaan uit een elftal aan elkaar gelijmde (geschaafde) vurenhouten balken (44×70) met daarop een 12 mm dikke multiplex plaat. De totale dikte bedraagt daarmee net geen 6 cm. Om dit verlijmde pakket heen komt een hardhouten lijst; voor de afwerking en om het zachte vurenhout te beschermen.

Het werkblad zal met elk van de staanders worden verbonden door middel van bouten en moeren, zodat het geheel demontabel blijft voor het geval dat nodig is. Onderlangs worden op dezelfde manier twee balken aan de staanders verbonden, voor de stevigheid. In de ruimtes onder het werkblad, passen links en rechts van de bankschroef (als het goed is) precies twee IKEA kastjes uit het IVAR kasten-systeem.

Ik hoop op deze manier een stevige en goed werkbare houtwerkbank te maken, die optimaal de ruimte in onze bijkeuken benut en ook nog eens betaalbaar is.