Friday, 4 May 2018

Building a TTN gateway

Following a Things Network meeting in my hometown, I decided to try and move things forward by donating a Raspberry Pi / IMST 880A - based gateway to the guys from Zuid-West TV . They have access to a number of high locations in the area, and are currently building a nice metal cabinet with an internal power supply, which will then be installed on top of one of the highest buildings in Bergen op Zoom. More on that later!
However, in the meantime my original TTN gateway in Roosendaal had suddenly gone very quit. As it turns out, the gateway range is suddenly limited to about 10 meters! Clearly something is amiss here? It seems that the internal RF receiver has given up, something that cannot be easily repaired and needs to be looked at by the Things Network team.
As there is no way to predict how long this will take, I've quickly built myself a new gateway, based on the proven Raspberry Pi and IMST IC880A board...

A quick 'n dirty gateway build!

So here's what you need to build yourself a multichannel gateway:

The main parts shown in the picture are a Raspberry Pi 2, the IMST IC880A concentrator board, an adapter board to connect the two, and a small housing to put the gateway into. Quite easy, no? Well, that depends on how fancy you want your gateway to be. I just needed it to be simple and reliable, so here's what I did:

1: Put the concentrator and adapter board together
I wanted my gateway to be as compact as possible, so I've soldered the concentrator directly onto the adapter board. I also cut off the original micro-usb connector from the adapter, because it would not fit in my compact housing. However, the adapter also comes with headers which can be used to plug in the concentrator so it is removable.

2: Connect the adapter to the Raspberry Pi
My housing has slots to hold a pcb board, so I've cut a blank board to size and mounted the gateway on it using 5mm plastic spacers. This way no screws are visible from the outside, which is a bonus :)

3: Slide the gateway assembly in the slots

4: Add power supply connections
 Although it is possible to connect the power supply directly, I much prefer to use a proper power connector. I also added an LED, and made a cutout for the network connector, which makes it look like this:
Wiring power to the board was done by connecting power directly to pins 21 (+VDD) and 22 (GND) of the concentrator board. The adapter will then also power the Raspberry Pi, keeping the number of wires to a minimum.

 5: Put it all together
The other end has the SMA connector, which connects to the IMST board. Removing this end will also allow access to the SD card:
The end result looks like this!

Installing software and registering the gateway

Now that the gateway is finished, you will need to install and configure the whole thing of course. Instead of describing this whole process, I'm going to be lazy and refer you to the excellent walk-through put together by the Things Network Zurich group:

From zero to LoRaWAN in a weekend

They've done a very good job in describing the whole installation, which will result in a fully functional gateway. Great work guys!

Parts list

IMST IC880A concentrator board
Raspberry Pi (preferably v2, but v3 will also work)
Adapter board (I used the one from
U.Fl to SMA pigtail
5V / 2A adapter (I used a Raspberry Pi adapter)
A suitable housing (mine is a Hammond 1455K1202)
Power connectors
Some nuts, bolts and spacers (depends on the housing used)

Tuesday, 10 April 2018

Building an outdoor TTN gateway GPA antenna

After playing around with a number of TTN nodes, we quickly discovered that having an indoor antenna on the gateway is not ideal. An outdoor antenna should yield far better results, especially because I do have access to my own rooftop which is about 11 meters high. Commercially available high quality antennas are quite expensive however, so it had to be something simple and DIY.

The DIY way

Luckily for me, several articles have been published already on building TTN antennas. The 868Mhz frequency also means that small and cheap antennas can be built without the need for special or exotic materials. The DIY GPA design described by Lex Bolkesteijn on The Things Network seemed like an excellent starting point, with clear instructions and a good amount of pictures:

So, after a visit to a couple of local parts shops I ended up with this:

The steps below describe the building process. As you can see, I tried to make this GPA antenna as weatherproof as possible, even though it is just an experiment. It will probably turn out to be the first of a long line of antenna experiments, but as long as it is on my roof it will need to be able to function in all kinds of weather so why not be thorough?

First, put together the GPA following the instructions in the original article:

Then, cut the antenna to the correct size and attach the N-type connector:


The result looks something like this:

Last step: put the new antenna up on the roof.

I opted for a wall-mounted bracket so the whole thing would be easily accessible. The DIY GPA now looks like this, about 12 meters high:


So far, so good! The gateway sure seems to pick up a lot more traffic with the new outdoor antenna, although how much of this effect can actually be contributed to the GPA design remains a guess, as just putting the antenna outside will have had a positive effect also. Next step is of course to build a different design (probably a co-linear) and compare. Stay tuned!

Parts list

2mm copper wire (50cm is enough)
crimp-type eyelets (4x)
PVC end caps and tubing (available at the local DIY shop)
3mm x16 screws and nuts (4x)
4mm x13 screws (4x)
N-connector chassis mount
N-connector for Aircell-7 cable
SMA-connector for Aircell-7 cable
Aircell-7 cable (keep this as short as possible!)

Wall mount (I used a satellite dish mount)
Clamps (2x)
Galvanized pipe (I used 28mm central heating pipe)
8mm Screws and plugs (4x)

I was able to build the entire antenna for around 65 Euros. Keep in mind however that the installation materials, cable and connectors were much more expensive than the actual antenna...

Friday, 2 March 2018

The STM32 LoRa Discovery kit: adding sensors

(Playing with the X-NUCLEO-IKS01A2)

So, now that the STM32 board is up and running, it's time to start doing something with it. Luckily for me, the friendly folks at the STMicro stand also put a sensor expansion board in my hands. This X-NUCLEO-IKS01A2 board (what's in a name) carries a number of sensors, as well as extension connectors and such:

Key Features (taken from the STMicro website)

  • LSM6DSL MEMS 3D accelerometer (±2/±4/±8/±16 g) and 3D gyroscope (±125/±245/±500/±1000/±2000 dps)
  • LSM303AGR MEMS 3D accelerometer (±2/±4/±8/±16 g) and MEMS3D magnetometer (±50 gauss)
  • LPS22HB MEMS pressure sensor, 260-1260 hPa absolute digital output barometer
  • HTS221: capacitive digital relative humidity and temperature
  • DIL24 socket for additional MEMS adapters and other sensors
  • Free comprehensive development firmware library and example for all sensors compatible with STM32Cube firmware
  • I²C sensor hub features on LSM6DSL available
  • Compatible with STM32 Nucleo boards
  • Equipped with Arduino UNO R3 connector
  • RoHS compliant 
The board communicates through I2C and libraries can of course be downloaded from the website.

Let's send some data!

 As with the LRWAN1 board, it really pays off to read at least part of the documentation included in the library. After setting up I2C and configuring the library to use the correct addresses, it is pretty easy to create a compact payload for LoRa transmission:

BSP_sensor_Read( &sensor_data );

temperature  = ( int16_t )( sensor_data.temperature * 100 );

pressure     = ( uint16_t )( sensor_data.pressure * 100 / 10 );
humidity     = ( uint8_t )( sensor_data.humidity );
batteryLevel = ( uint8_t )(HW_GetBatteryLevelInMilliVolts( ) / 100);
lightLevel   = ( uint8_t )(HW_GetLightLevelRaw( ));
soundLevel   = ( uint8_t )(HW_GetSoundLevelRaw( ));

(Full source code available on request)

The lightLevel and soundLevel values are not taken from the included sensors. Because the NUCLEO boards include Arduino-style headers, I decided to stick an Arduino breadboard on top, and included (analog) sensors for sound and light, which are read by two ADC channels. So now the whole contraption looks like this:

Now to find a use for the remaining accelerometer sensors... Any ideas? Please let me know!

Sunday, 4 February 2018

Getting started with the STM32 LoRa Discovery Kit

After having done a number of embedded projects using the Microchip processors and development stack, I figured it was about time to try something else for a change. Fortunately I was able to attend the first TheThingsNetwork developer conference in the Netherlands, where I was given an ST Microelectronics B-L072Z-LRWAN1 Discovery board. This board contains everything you need to get started in the world of LoraWAN. The STMicro site lists the following specs:

Key Features
  • CMWX1ZZABZ-091 LoRa® module (Murata)
    • Embedded ultra-low-power STM32L072CZ Series MCUs, based on ARM® Cortex® -M0+ core, with 192 Kbytes of Flash memory, 20 Kbytes of RAM, 20 Kbytes of EEPROM
    • USB 2.0 FS
    • 4-channel,12-bit ADC, 2xDAC
    • 6-bit timers, LP-UART, I2 C and SPI
    • Embedded SX1276 transceiver
    • LoRa® , FSK, GFSK, MSK, GMSK and OOK modulations
    • +14 dBm or +20 dBm selectable output power
    • 157 dB maximum link budget
    • Programmable bit rate up to 300 Kbit/s
    • High sensitivity: down to -137 dBm
    • Bullet-proof front end: IIP3 = -12.5 dBm
    • 89 dB blocking immunity
    • Low RX current of 10 mA, 200 nA register retention
    • Fully integrated synthesizer with a resolution of 61 Hz
    • Built-in bit synchronizer for clock recovery
    • Sync word recognition
    • Preamble detection
    • 127 dB+ dynamic range RSSI
  • SMA and U.FL RF interface connectors
  • Including 50 Ohm SMA RF antenna
  • On-board ST-LINK/V2-1 supporting USB re-enumeration capability
  • USB ST-LINK functions:
  • Board power supply:
    • Through USB bus or external VIN /3.3 V supply voltage or batteries
  • 3xAAA-type-battery holder for standalone operation
  • 7 LEDs:
    • 4 general-purpose LEDs
    • A 5 V-power LED
    • An ST-LINK-communication LED
    • A fault-power LED
  • 2 push-buttons (user and reset)
  • Arduino Uno V3 connectors
  • ARM® mbed (see
 Nice! Sounds like the perfect opportunity to start in the world of STMicro ARM processors (More info can be found on the STMicro website).

So now: how to get it to work? Although there were several workshops on this subject during the conference, there weren't many people that actually got the board to work and connect. The instructors did their best, but the STMicro development stack just isn't as straightforward to install and set up as Arduino's. Each workshop left us struggling with a multitude of drivers to install, accounts to set up and a confusing number of choices on Development tools. A quick Google search revealed that we were not alone in this; countless discussions on forums are describing the same experience. Once home, I decided to take some time to find out what actually needs to be done to get the board to work and do a small tutorial, so here it is!



For this writeup I am going to assume that you already have a TheThingsNetwork account, and are familiar with LoraWAN. If not, please go to the TheThingsNetwork website and create an account (it's free), and read up on LoraWAN and TTN (This link is a good start).
Before downloading from the links below, you will also need to create an STMicro account (Click here). You will need it to access the downloads on their website.

What to get?


STLink driver
The Discovery board comes with a built-in ST-LINK programmer / debugger, for which you will need a driver. This can be downloaded here. Please install this FIRST, before plugging in the Discovery board.

I-CUBE-LRWAN (LoRaWAN software expansion for STM32Cube)
This package contains all libraries and demo projects. It can be downloaded here.

In this tutorial I've decided to use the Keil MDK IDE. You can download it here. Please take the time to create an account and register your version of MDK (it's free for STM32F0 and STM32L0 series processors). You will need to have a license in place to be able to successfully build the demo application.

Putting it all together


Set up communications
Once the driver is installed, you should be able to start communicating with the Discovery board. The board comes pre-loaded with firmware which will send the DevEUI, AppEUI andAppKey over a serial connection. So, let's make this happen!
First, Connect the board and then open your Device Manager. Your board should be listed in the ports list:

On my system the board COM port is COM5. Open a serial monitor program (I used the serial monitor in the Arduino IDE) and select COM5. Now press the Reset button on the board and something like this will appear:

Register your device
Now go to and register your device on the TTN. Never done this before? Not to worry; TheThingsNetwork has an excellent tutorial right here.
The DEVEui will need to be entered during registration; the AppEui and AppKey will be generated during device registration. These we will need to enter in our project.

Enter the keys in your Project
Now it's time to open the demo Project in Keil MDK. Start the program and open the demo project (Project -> Open Project...) located in the I-CUBE package you have downloaded. There is a separate demo project for each Discovery board and tools stack, which leads to a quite complicated directory structure. This is what it should look like:


Load the project file and build it to make sure that all components are OK.
Now it's time to enter the keys. This needs to be done in the file commissioning.h, which is located in the directory Lora\End_Node_inc:

Open the file in MDK and enter the AppEui and AppKey. Do not alter the DevEui; this is not used in OTAA activation. Save the file.

Build the Project and update the Discovery board
Now Rebuild the Project. If the build is successful, you will be able to load the generated firmware into the Discovery board. Use menu Flash -> Download to update the firmware in your device and then press the Reset button on the board.

The serial monitor should now list something like this:

That's it! Your device is now joined and will start sending data to the TTN network. You can of course monitor this in the TTN console.

Next steps?


Getting the device to work is only the first step of course. You will now need to take it further by adding sensors and modifying the code to make it do what you have in mind. Good luck, and please leave feedback below if you found this tutorial useful!

Sunday, 24 June 2012

An All-Tube Stereo Level indicator

Add some tube nostalgia to your modern stereo

Every tube loving electronics enthusiast has some tubes in his/her collection that are designed for such specific tasks, that they are very difficult to use for anything else. One of these difficult tubes is the EABC80 (6AK8). They are found in many older tube radios, and contain a triode and three diodes, two of them connected internally to the cathode of the triode. This makes it very hard to use them for anything other than what they were originally designed for.
Another tube that almost everybody has in their collection is the EM84 (6FG6) tuning indicator. Many people agree that these tubes were the eye-catcher of many tube radios. However, today almost no one uses them anymore. Well, things are about to change! With a few hours of work you can bring those nice indicator tubes back into your living room, and as an added bonus the design uses two EABC80 tubes and a tube rectifier.

Schematic diagram

 As you can see in the schematic diagram, the triode section of the EACB80 is used to amplify the incoming audio signal. The internal diodes are then used to create a negative voltage, which is fed to the input of the EM84. The RC combination connected to the grid of the EM84 provides a peak-hold function, and can of course be altered to suit everyone's individual tastes.

Putting it together

Caution! Tube circuits use lethal voltages! Don't say I didn't warn you!

As can be seen in the pictures, i have made a printed circuit board for my level indicator, but the simple nature and low parts count of this design allows many other ways to build it.  Unfortunately I don't have the time to make and send you a copy of this PCB, but for those of you who want to etch the board themselves, here is the layout in PDF format.
The power transformer I used came from an old Philips radio, but almost any transformer can be used, provided it can supply 6.3V @ 2A and about 500VCT @ 10mA. The 10k resistors in the B+ line can be tweaked to get the correct voltage (should be between 250V and 275V DC). The rectifier tube can be an EZ81 (6CA4) but an EZ80 may be even better, because it has the same size as the rest of the tubes.


Although this stereo level indicator is a great step forward from the usual LED or LCD devices, both in speed and in looks, it is NOT a 100% accurate measuring device. It can be used to compare one recording to another, but lacks the speed and accuracy to provide a reliable clipping detection. But it sure looks cool!
The bandwidth of the device is 20Hz - 100kHz, which is more than enough to ensure an accurate reading for most purposes, and certainly better than most analog meters. However,  as Jukka Tolonen points out in his excellent article on this subject, a 'perfect' peak detector should have an even greater range for adequate peak detection, and should include a full wave rectifier to deal with both negative and positive peaks in the signal. Jukka 's full article can be found here: Peak Reading Level Meter Using Indicator Tubes.
Unfortunately this goal is difficult to achieve with an all-tube design, and would certainly not be a beginners project. Within its limitations however, this level meter gives a fairly accurate view of the incoming audio signal. Adding a full-wave rectifier is of course possible, and could lead to even better results. Solid state diodes are out of the question of course! Besides, that would make things way too easy :-)
A possible idea would be to use EAA91 (6AL5) diodes... if anyone cares to give this a try please let me know!

(Article originally published in VALVE magazine 2/2003)

Thursday, 21 June 2012

Real bass from a pair of cans... at a price

Lots of bass.. no kiddin' !

As a developer, i tend to spend quite some time at my desk, trying to concentrate to come up with solutions to programming challenges. However, in our new office building we don't have the luxury of separate rooms. Instead, we are all in one big open space. While this has its advantages (more interaction, and a nice, roomy atmosphere to name a few), the drawback is also evident: no quiet places to just think and write code! So I went looking for a pair of headphones suitable for office use. Obviously my trusty Sennheiser HD590 would not fit the bill. I still think they are very nice sounding, but they are also too big, and too expensive to just leave at the office. And on top of that they are open, which means that a lot of sound will leak at higher volumes - a good way to annoy your co-workers!

What am I looking for?


My perfect pair of office cans have to be comfortable enough to wear for several hours a day. Because of the music I like to listen to at work, they have to be able to produce serious amounts of bass, without leaking too much sound to the outside world. And of course they need to be cheap enough to leave them at the office without requiring a personal safe!

So here it is: the Sony MDR-XB300


After spending way to much time looking around on the internet, I decided to buy the MDR-XB300, a pair of on-ear, closed  system headphones from Sony. These can be had for around $30.00, are very comfortable, and promised to have Extra Bass (hence the 'XB'). Webshop delivers them at your doorstep without shipping costs, and with a 30-day return policy. What's there to lose?

The test


Right out of the box this pair of  'phones delivers what's on the box: deep bass, and LOTS OF IT! In fact, too much bass for many kinds of music. In contrast, the mids and highs are almost nonexistent. After some 50 hours of break-in this improves somewhat, but it still sounds like having a subwoofer strapped to your head. But you know what? That's fine with me, because I wasn't looking for audiophile quality anyway!
Leakage is much less than the open HD590's, and very much acceptable for office use. The pads are soft enough to allow listening for hours on end, but not so soft that they will slide off of your head.
The built-in laptop audio amp seems to struggle sometimes because of the low impedance (24 Ohms), so the sound may benefit from a decent headphone amplifier.  This I will review in my next post!



They may not be for everyone, but for me, they get the job done. Lots of bass, and good damping of outside noise. They are now a permanent part of my office setup.

Sunday, 8 January 2012

It's there at last... MPLAB X.

Good news from the people at Microchip: MPLAB X, the new IDE for programming PIC microcontrollers, has finally come out of beta and is now available for download. At the moment of writing this article, the Microchip website still lists MPLAB X as being in beta, but the link already points to the released 1.00a version. You can find the download here: Download MPLAB X IDE.
This link will likely change within a couple of weeks, as the new IDE will be officially released, so here is the link to the official MPLAB homepage:

After playing around with MPLAB 8.xx for some time, i have to say that MPLAB X is an enormous improvement. Gone is the cluttered multiwindow environment, with it's confusing layout and non-intuitive structure. MPLAB X looks a lot more like Microsoft's Visual Studio IDE, for me the benchmark of a good development suite. I haven't spent much time in the new IDE yet, but as far as i have seen it's a big step forward. Much less clutter, a more logical interface, and much improved project management. Watch this blog for a more in-depth article, coming soon!

Tuesday, 29 November 2011

Elmer 160 -  PIC introduction

Want to get started with PIC microcontrollers? If so, here's a link to a nice introductory course:

Elmer 160 - Course Lessons

This course will get you started with programming controllers using Microchip's MPLAB development suite, available as a free download from the Microchip website.

So now it's a stopwatch.

After watching the numbers flash by, produced by the code in my previous article, i now tweaked the program to do something useful for a change. The display will now count to 59.9 seconds, and resets when a button is pressed. It still isn't very sophisticated, and a $2.00 wristwatch will actually do a much better job, but that wasn't the point :-)

Tuesday, 22 November 2011

A small step for mankind, a giant leap for... me!

Finally, last night I had some time to spare... enough to fire up MPLAB, Microchip's microcontroller development studio. I'd spent some time trying to learn to program in assembler, then in C, but gave up in frustration. But, as any true geek knows, projects like this keep on nagging in the back of your mind. So, I decided to give it another go, this time trying to make a counter on the LED display of my homemade controller board, using a PIC16F630:

For some reason, this 16F630 controller never, ever does what it's supposed to do, at least not in my world. This time however, I was determined to get the bastard to submit to my will, instead of the other way around! After an hour or so, I came up with the following:

//Includes & references
#include <htc.h>

//Processor configuration (look in processor header file for definitions)

#define _XTAL_FREQ    4000000
#define DIGIT0        RA0
#define DIGIT1        RA1
#define    DIGIT2        RA2
#define    BUTTON1        RA5

//Global variables
//int counter = 0;

//Put initialization code here
void init (void)
    //Disable interrupts
    INTCON        = 0b00000000;
    PIE1        = 0b00000000;
    //Set options
    OPTION_REG    = 0b10000111;
    //Switch off comparator to enable digital I/0
    CMCON        = 0b00000111;
    //Set port directions
    TRISA        = 0b00101000;
    TRISC        = 0b00000000;
    //T1CON        = 0b00110101;

/**** Function prototypes ****/
void ShowDigit (int Number);

/**** Main function block ****/
void main (void)
    int count = 0;
    int i = 0;
    for (;;)
        //Blank display before digit switch
        switch (i)
            case (0):
            //Digit 2 (MSB)
            //PORTA = 0b11111011;
            DIGIT0 = 1;
            DIGIT1 = 1;
            DIGIT2 = 0;
            case (1):
            //Digit 1
            //PORTA = 0b11111101;
            DIGIT0 = 1;
            DIGIT1 = 0;
            DIGIT2 = 1;           
            case (2):
            //Digit 0 (LSB)
            //PORTA = 0b11111110;
            DIGIT0 = 0;
            DIGIT1 = 1;
            DIGIT2 = 1;
            //PORTA = 0b11111111;
        //Show next number
        if (i > 2)
            i = 0;
        if (count > 9)
            count = 0;
        //Reset counters when sw1 is pressed
        if (!BUTTON1)
            i = 0;
            count = 0;

/**** Functions ****/

//Call with 0 - 9 to show digit. All other values blank the display.
void ShowDigit (int Number)
    switch (Number)
        case (0):
        PORTC = 0b000000;
        RA4 = 1;
        case (1):
        PORTC = 0b111001;
        RA4 = 1;
        case (2):
        PORTC = 0b100100;
        RA4 = 0;
        case (3):
        PORTC = 0b110000;
        RA4 = 0;
        case (4):
        PORTC = 0b011001;
        RA4 = 0;
        case (5):
        PORTC = 0b010010;
        RA4 = 0;
        case (6):
        PORTC = 0b000010;
        RA4 = 0;
        case (7):
        PORTC = 0b111000;
        RA4 = 1;
        case (8):
        PORTC = 0b000000;
        RA4 = 0;
        case (9):
        PORTC = 0b010000;
        RA4 = 0;
        //Defaults to blank
        PORTC = 0b111111;
        RA4 = 1;   


Predictably, this did not work... at first. The output ports would not react the way I wanted, resulting in strange characters on the display. As a last resort, i turned to the 16F630 manual. And Eureka! Because of the fact that many of the controller's pins have multiple functions, it is very important to set up the peripherals correctly. Switching off the internal comparator by including the command:

CMCON        = 0b00000111;

did the trick! So now i've got a 3-digit counter of sorts, which counts from 0 to 9 across the 3 digits, and resets when a button is pressed. Next step is to implement multiplexing, and make this into a useful counter / stopwatch. Also, the button should activate an interrupt, making it more responsive. The way things are going, this may take another year.. but hey, at least now it works!

Update: Let's watch the result: