Tools to help you prototype: Raspberry Pi Zero W

This new member of the Raspberry Pi family may surprise you.

With its tiny form factor (around 7 cm x 3 cm) and a relatively good variety of I/0 interfaces, this device promises to bring processing power and radio heterogeneity to Wireless Sensor Networks (WSN) and IoT deployments.

It is not risky to affirm that using the Pi Zero W as a sensor node can open a lot of opportunities. From taking advantage of the USB OTG to plug additional wireless communication interfaces (like LTE, LoRa, or others), to install Open vSwitch (OVS) and manage the networking operation of the device via a Software Defined Network (SDN) OpenFlow Controller; the Pi Zero W can handle it.

As exploration on the applications of this tiny yet powerful device continues, it is considered a great tool for prototyping. Give it a try.



Tools to help you prototype: GNU Screen

Continuing with our series to help you boost your prototyping abilities, this time we will take a short glance at GNU Screen.

Screen is an amazing tool that allows you to create a separate Terminal buffer, independent of the current Terminal session. That is, you may want to enter into Screen through the Terminal and execute some code. Later on, you can log into Screen again and review the execution of your script. Is like a background execution on steroids :).

The tool is packed with several special key-strokes combinations to manage Screens, navigate among them, rename them, detach or close unused Screens, and so forth. I have compiled a very useful example for when you need to execute a remote script using ssh + Screen on the remote host.

Also, I encourage you to take a look at Linode’s tutorial so you can get up-and-running very fast.

Do you know any special Screen tricks? Let us know in the comments section.




Tools to help you prototype: traffic generators

Let’s forget about what type of network technology you are using. Now, suppose you want to perform a benchmark for your new network topology, protocol, antenna, or other. Regardless of which of the aforementioned test you want to perform, it should be tested under realistic traffic sources. Also, it might be even better if these sources can be customized to your own needs in terms of: throughput, packet structure, header values, etc.

In these short series I will be reviewing some of my experiences while prototyping proposals and getting relevant (i.e.: publishable) results. So first, let’s talk about tools for creating your own traffic generators.

Realistic traffic?

When we talk about real-world traffic we are usually referring to its characteristics, like packet arrival distributions, intervals between burst, or throughput. For instance, if you plan to test a new MAC protocol that should improve voice quality over a network link, then you should better do performance evaluation of your proposal using source-traffic modelling real voice, and so on.

Some studies are based on real traces, but this can be inconvenient when working with resource-constrained devices (traces often taking large disk space), or use Constant Bit-Rate (CBR) sources employing tools such as iPerf. Nevertheless, these may not accurately represent the source traffic your solution will experience.

If you find yourself in this situation, maybe building your own traffic source is the way to go.


It has been extensively used for many years. iPerf provides a Server and Client options, where you may define the port number and L4 protocol (UDP or TCP) on the server side, and other characteristics, like: throughput, length of test, interval between reports, packet size, and others in the client side.

iPerf is the go-to tool for extracting throughput metrics using CBR sources. It is simple, accepted by the community, and also provides already averaged results.


Scapy is a Python-based library that you can use to create custom packets. Moreover, it provides a very easy syntax for encapsulating different OSI layers in the order you decide. For instance, you may encapsulate an Ethernet frame inside an UDP segment, and then encapsulate that into an IP packet and an additional TCP segment (for whatever reason, the point is that you can).

On top of that, Scapy is very friendly in terms of its documentation, which I invite you to overview before attempting anything. It also works within the Python interpreter, so you can test custom-made packets right away.

As Scapy is mainly a library, you can write Python scripts for controlling the packet generation rate, interval between bursts, source and destination MAC or IP addresses, UDP or TCP ports, and many other features. You may connect it with Wireshark and dissect received packets, or even build your own Client-Server applications.


As Scapy, Libtins is a set of libraries for packet creation, parsing, and sniffing, albeit written in C++. It also provides you with installation guides and a step-by-step tutorial to get you started very quickly.

With Libtins you may write scripts to represent virtually any traffic model, while taking advantage of C++’s speed and portability. I would like to point you to a short tutorial I made on how I used Libtins to a create custom-made applications and simulate high volumes of traffic, a server for it, and a parser for getting every interesting metric I needed.

Did you know any of these tools? What’s your favorite? Care to point us to any other one? Tell us in the comments section.