Using Raspberry PI to control Märklin model railway – Part 2

Sebastian Haas

At this point, the CAN interface has to be initialized manually after every reboot. Therefore, if the Pi is used as a permanent controller, it might be preferable to have these initialization steps been carried out during startup.

In order to achieve that, can2upd is going to be registered as a service and started right after the can0 interface has been initialized. Raspbian is using systemd as service manager, so this post will describe how to create systemd units for the tasks described above. Information about how systemd works and how to create unit configuration files can be found in the systemd(1) Linux manual page or in Justin Ellingwood’s excellent article on DigitalOcean .

The CAN interface initialization service

Create a new unit configuration file using sudo vim /lib/systemd/system/socketcan-interface.service with the following contents.

The can0 interface should be initialized as soon as networking is available, which should be the case on runlevel 3 that translates to multi-user.target for systemd. Since all commands used in this unit will exit after completion, the type has to be set to oneshot along with the RemainAfterExit= option set to yes. Multiple commands have to be separated with ;. Executing

will set permissions and enable the unit.

The can2udp service

After the can0 interface has been setup, can2udp has to be started. Since it is desirable to collect as much information as possible about the system’s state, can2udp will be run in foreground mode, allowing the verbose option to be activated. The output can be retrieved later using journalctl, see the troubleshooting section for more information. Create a new unit configuration file using sudo vim /lib/systemd/system/can2udp.service with the following contents.

Putting socketcan-interface.service in both the After= and Requires= section will make this service run after socketcan-interface.service has been started and will attempt to start it in case it’s not running. Executing

will set permissions and enable the unit.

Conclusion

After both systemd units have been created and enabled, the Raspberry PI has to be rebooted. From this point, whenever the PI starts, the can0 interface will be up and running with a proper baudrate and can2udp will be started waiting for incoming UDP connections on its default port.

Troubleshooting

An overview of all running systemd units can be found using sudo systemctl list-units. Both the socketcan-interface.service and the can2udp.service unit should be listed as loaded and active. Since the socketcan-interface is of type oneshot, it will be marked as exited while can2udp should be indicated as running.

Log output of the respective units can be viewed using sudo journalctl -u can2udp or sudo journalctl -u socketcan-interface. Linux will buffer the output written by can2udp and not write it to /var/log/ per line. Because of that, no output of can2udp might appear in the logs at first. Sending a few commands will cause the logging buffer to flush and the logs to appear in the journalctl output.

References

Using Raspberry PI to control Märklin model railway – Part 1

Sebastian Haas

For my latest project, the Mariannenbahn, I needed to find a way to control a Märklin model railway from different rooms. While this is obviously possible using multiple Märklin Central or Mobile Stations, it was not an option at the time as the project already hit its budgetary ceiling.

This solution is intended as a temporary replacement for an additional Märklin control device and research was done out of curiosity. Go and buy their stuff.

Thanks to an outstanding blog post on http://www.ifoedit.com as well as Stefan Krauß’ homepage , a solid groundwork was already present.

Overview

The Märklin Digital Connector Box is a device containing a signal processor that generates the digital signal on the rails. It communicates with controllers, such as the Mobile Station , via CAN bus using a protocol defined and thankfully published by Märklin. It is therefore possible to use any device capable of transmitting data over CAN to control the model railway. Using a Raspberry PI together with a ready-made CAN extension module seemed like a good and safe solution, as various people already proved that this setup usually works.
Since it is usually common to use the Raspberry PI via SSH instead of a display connected, a piece of software taking commands via Ethernet and hand them over to the CAN bus is required. That way, it is possible to install the PI somewhere close to the Märklin Digital Connector Box and the railway layout. Connected to the LAN, it will take commands from any Ethernet-capable device such as personal computers or even smartphones. Gerhard Bertelsmann has written a wonderful C program called can2udp for exactly that purpose. It will hand over commands between Ethernet/UDP and the CAN bus.
As a final step, software to produce the actual commands to be transmitted to the Digital Connector Box is required. The most obvious solution available for this task is Rocrail.

CAN controller

After some research, I decided to get a PiCAN2 board form SK Pang Electronics . Getting it running is quite straightforward. On the downside, I found it inevitable to solder a 2-way header pin as jumper bridge to the board myself to be able to use the 120Ω terminator already present on the board.

Hardware installation

Activating the terminator resistance is described in the manual. Mounting the board is easy, it only fits one direction. It is possible to either use the DB9 Connector or the screw terminal on the PiCAN2 to connect it to the Märklin Connector Box. The pin assignment on the Märklin Connector Box is described by Stefan Krauß.

Software installation

I was using a Raspberry PI 2 running the latest Raspbian. I wasn’t able to get the PiCAN2 running with the latest (4.4.16) firmware though. I used rpi-update to go back to 4.1.21 which worked for me some time ago. I did not do any investigation on which exact version introduces the breaking changes. If you find out, please let me know. To install a working firmware, rpi-update can be used with the version’s commit hash:

Following the manual, the following three lines have to be appended to /boot/config.txt:

After a reboot, the CAN interface can be brought up.

See the troubleshooting section on information about how to verify the interface is up and running properly.

can2udp

can2udp is a beautiful C program that hands over messages from Ethernet/UDP to CAN and back. The usage is:

Given the default setup, it is sufficient to call ./can2udp -f -v, which will bring up can2udp in foreground with verbose output. It will send a certain initialization package to the Märklin Digital Connector Box on startup.

Client software

Almost any literature on the topic is using Rocrail as client software. Due to the lack of any real alternative, it is what I am using too at the moment.

I do not really like Rocrail. It was supposed to be open source software licensed under GNUv2 until the owner apparently stared spamming ®s all over http://www.rocrail.net and shutting down their public GitHub repository, even admonishing others to remove their forks of the GNUv2 licensed code. To make matters worse, an annoying pop up dialog tries to lure users into buying a support key.

The setup described in this post simulates the use of a Märklin Mobile Station 2, so the setup for Rocrail is identically to that scenario and can be found on their webpage or on http://www.ifoedit.com.

Where to buy

I was able to get a Märklin Digital Connector Box (60113) together with the required Märklin 36VA Switched Mode Power Pack (66361) from a local retailer. Märklin appears not to be selling the Digital Connector Box anymore, but still its quite easy to get one on eBay or Amazon.

Troubleshooting

If the CAN interface is set up correctly, it will be listed in the output of ifconfig as can0. Both the bcm2835 and the mcp251x controllers must be listed in the output of lsmod. Errors in the initialization process will also show up in the output of dmesg. It might be wise to grep for bcm2835 there.

References

LoopBack + AngularJS authentication solution

Sebastian Haas

In this article I’m going to describe the way I use LoopBack’s authentication service in connection with an AngularJS app on client side. While primarily based on the LoopBack getting started intermediate  tutorial, I tried to merge in John Papa’s style guidelines as well as a few other blog posts on the matter.

Server side

LoopBack offers a flexible system to build an authentication system that suits the demands of your application. The documentation on Users, Roles, RoleMappings, ACLs etc. is quite comprehensive , so I don’t feel like there is a lot to add on this side. AngularJS will use the automatically generated services in lbServices.js to communicate via the REST API.

Client side

Of course, everything we are going to do here is providing a nice user experience by hiding routes and endpoints the current user has no access on. Since all code can possibly be altered by the client, essential security measures are to be taken on server side.

Status broadcasts

As LoopBack already offers a solid groundwork, the only real addition is a broadcasting system offering authentication status changes so that all parts of the application can adapt to new situations accordingly. I picked up a lot of ideas from a wonderful article by Gert Hengeveld in which he introduces a broadcasting system based on constants for the respective authentication states. Angular’s broadcast system is a controversy topic and according to the widely recognized Angular Style Guide by John Papa , we should avoid using it at all. However, while I see the risks of event-spamming if we talk about inter-controller communication, an authentication state broadcasting system is probably the only case where I opt for Angular events.

Overview

The basic idea is that whenever a call to authService is made, we make sure to publish all relevant state changes using Angular broadcasts. These are, among others you might find useful in your application, LOGIN_SUCCESS , LOGIN_FAILED and LOGOUT_SUCCESS .
The following diagram is showing dependencies between the components in the discussed authentication-state broadcasting system. The dashed lines are injects.
Diagram that shows dependencies between components in the introduced authentication system.
Next, I tried to model a basic procedure where a user submits the login form and gets redirected to the application’s main page. Since the user is authenticated after that, the menu bar has to show differing items and maybe include the user name in the upper right corner. The diagram below shows all that.Sequence diagram of a basic login procedure.

Implementation

References

Cloud-hosted continuous integration solutions 2015

Sebastian Haas

For a new project at work, we needed to setup a continuous integration routine. As we don’t really have the capacity to host it on our own, I decided to make a brief market analysis of the available solutions in late 2015.

While my research was done with a certain project configuration in mind (a web platform running Node.js with Angular), I’m sure it can be useful for other types of projects as well.

Travis CI

Extremely popular as a lot of open-source projects hosted on Github use their free plan. The documentation is comprehensive and clean [1] plus there are tons of related posts on stackoverflow. I also found a dedicated section on browser testing. They even offer to run your script on Mac hardware [2] allowing to test on the most recent versions of Safari. The downside however is the price. Their plans start from 129$ excl. VAT per month for 2 concurrent build jobs. [3] Also, your sources must be hosted on GitHub as there is no support for any other type of repository.

Codeship

Codeship is definitely worth a look for small companies as they offer a free plan with 100 builds per month, as well as an unlimited personal plan for 49$ per month. However, this does not allow to reflect organizational hierarchies in terms of account management. The organizational plan is 99$ per month. [4] Codeship supports both Github and Bitbucket, however there is no way to use any other type of repository. [5] They also do not offer builds on Mac hardware. I skimmed over their documentation and it looked clearly arranged and pretty extensive. [6]

Circle CI

Circle CI offers the most generous free plan of all solutions. You get unlimited builds for one repository for free. Any additional container is 50$ [7]. Their documentation looks good with lots of real-world examples and technology-specific tutorials. I discovered a section on iOS builds on Mac hardware. [8] While this feature seems to be experimental at the moment, it might indicate that Circle CI is planning to offer Mac hardware for regular build jobs in the near future. As for SCM, only Github is supported. [9]

Jenkins CI on AWS

This section is hard to evaluate since I don’t have any experience how much resources Jenkins will actually use. However it is possible to answer a few obvious questions. You will have to spend a lot of time setting up and configuring Jenkins, even more so if you plan to use its EC2 features allowing it to scale by launching additional instances on demand. There is clearly no way to use Mac hardware and although there is no actual limit on build jobs, make sure you have set AWS billing alerts.

Conclusion

Since pricing policy differs from company to company, I decided to compare the first plans that offer unlimited builds on 2 concurrent jobs.

Price and feature comparison
Travis CI Codeship Circle CI Jenkins CI on EC2
Github yes yes yes yes
Bitbucket no yes no yes
Private SCM no no no yes
Mac Hardware yes no iOS no
Concurrent Jobs 2 1(2)* 2 ultd.
Ultd. Plans from 129$ 49$(99$**) 50$ ?
Setup easy easy easy hard
SSH Debugging no*** yes yes yes

* Only one concurrent job but 2 parallel test pipelines
** Organization plans including account management from 99$
*** Various blog posts indicate that they will launch a VM for you to debug your scripts

References

[1] http://docs.travis-ci.com
[2] http://docs.travis-ci.com/user/workers/os-x-infrastructure
[3] https://travis-ci.com/plans
[4] https://codeship.com/pricing
[5] https://codeship.com/documentation/faq/other-scm
[6] https://codeship.com/documentation
[7] https://codeship.com/pricing
[8] https://circleci.com/docs/ios
[9] https://circleci.com/docs/faq#do-you-support-bitbucket-or-gitlab-

Vagrant – Provisioning

Sebastian Haas

In the first part of this tutorial series, we set up a fully working vagrant environment with Ubuntu running on our guest machine.

As we used an existing box from Vagrant Cloud, we now going to figure out possibilities how to adapt this default machine according to our needs. In this post, how to install additional software using the Ubuntu package manager.

The most easy way to adapt our virtual machine according to our needs, is to simply run commands from the Ubuntu shell. In this post, we want to install the GNU Compiler Collection which can be done by  $ sudo apt-get install build-essential . We could now just ssh into our guest and install the package by hand, but that would require us to repeat this step every time we choose to destroy our virtual machine using $ vagrant destroy or move on to another host. Luckily, there is a way to have Vagrant doing this for us when initializing a new virtual environment. By adding the following lines to our existing Vagrantfile, we tell Vagrant to use a basic shell for provisioning. We can even specify a relative path to a bash script.

The file provisioning.sh , located right next to our Vagrantfile, is now being used to provision our guest machine. Now we create that file with the following content:

This will make sure that our development environment always has this package installed.

Vagrant – First steps

Sebastian Haas

For my latest work with the tesseract-ocr engine, I needed to set up a C++ development environment. Working with the GNU CC under Linux is not as painful and complex as it can be under Windows which I am currently running as my main OS. Additionally, I needed to be able to work on multiple machines. If you are looking for a way to synchronize development environments across different machines and workplaces, Vagrant is definitely worth a look. It runs under Linux, Mac OS X and Windows.

This post covers the set up of a development machine running Ubuntu with the basic GNU Compiler Collection installed.

Vagrant does not provide its own virtualization technology, instead it runs on top of the most common providers such as VirtualBox, VMWare or even AWS. Vagrant handles the process of downloading and installing an operating system, installing and configuring the required software on that machine and also simplifies the way that machine can be shared with collaborators e.g. via a SCM.

Installation

At first, we need to download a virtualizing software. I already got Oracles’s VirtualBox installed, which is why I chose it as my Vagrant virtualization provider. It is freely available as OpenSource software for both personal and enterprise use and can be easily installed from here.

Once we got our virtualization stack running, we can download Vagrant from vagrantup.com and run the installer.

Configuration and first launch

To initialze Vagrant, we create a new directory for our project (note that this is most likely going to be the root directory for our repository). Open a terminal, navigate into that directory and run the command

to create an initial Vagrantfile. The Vagrantfile tells Vagrant what kind of environment needs to be set up. As we don’t want to download and install an operating system for our development environment on the guest machine, we are going to use some kind of base image called box in Vagrant. Vagrant Cloud offers a large variety of boxes from different vendors, and with different operating systems and software stacks installed. As mentioned above, we are going to have a basic Ubuntu installation which is why we choose ubuntu/trusty64 . To tell Vagrant which box to use, we have to open the Vagrantfile and modify the following line:

Note: We could have achieved this by running $ vagrant init ubuntu/trusty64 instead in the first place.

To boot and ssh into our virtual development machine, run the following two commands:

After a successful ssh connection, we end up in the Ubuntu shell in the home directory of the user vagrant . Vagrant automatically synchronizes directories between your host and the guest machine. By default, only the directory containing our Vagrantfile will be kept in sync. It is mounted under /vagrant in Ubuntu. Run the following commands on the guest to create an empty file in the synchronized folder:

This should list the newly created file, but also our Vagrantfile. The file testfile.txt should be present also in our hosts filesystem.

Shutdown

Run logout to close our ssh connection with the guest OS, and shut down the guest machine gracefully using

or

depending on whether we want to just suspend it into RAM, shut the VM down or completely destroy the VM including it’s disk and all of its contents. For more information about this topic, you might want to have a look at the corresponding Vagrant documentation article.

At this point, we got a fully working guest machine running Ubuntu Server 14.04 LTS (Trusty Tahr) with file system synchronization.

You might want to move on to Vagrant – Provisioning and take a look on provisioning a virtual machine using Vagrant.

Installing and running ejabberd on a AWS EC2 instance

Sebastian Haas

This post describes the configuration of an ejabberd XMPP server running on an Amazon AWS EC2 instance as a first step to building a cluster later on.

  1. Launch an EC2 instance in the desired configuration. In order to stay within my Free Tier, I chose the smallest available configuration using EBS and running Amazon’s custom Linux image.
  2. Configure the security groups for the newly created instance. We need to allow SSH-access as well as open the ports used by XMPP/ejabberd. In default configuration, ejabberd is using TCP ports 5266, 5280 and 5269.
  3. Connect to your instance using SSH.
  4. To download and run the ejabberd installer enter the following commands. You can find the URL to the latest ejabberd release on their commercial website http://www.process-one.net. Make sure to check whether your instance is running a 64- or 32-bit OS and choose the corresponding installer.
  5. Choose the language you prefer and read and accept the license agreement.
  6. Confirm the default directory /opt/ejabberd-13.12 .
  7. As ejabberd server domain, enter the public DNS of your instance e.g. ec2-###-###-###-###.eu-west-1.compute.amazonaws.com.
  8. Select whether this instance will become a node of a cluster. As building a cluster will be covered in another blog post I will not go into detail here and select no for this step.
  9. Finish the setup.

Now we can start the server and check if it’s running using sudo /opt/ejabberd-13.12/bin/ejabberdctl start  and sudo /opt/ejabberd-13.12/bin/ejabberdctl status . This should give the following output:

Use  sudo /opt/ejabberd-13.12/bin/ejabberdctl register username host password  to create new users.

Users can connect to the server using any XMPP compliant client now. Please note that I only tried a few popular clients like Pidgin on Linux and Windows and iChat on OSX. As your server doesn’t have a valid certificate, the client will most probably show a warning and requests the user to confirm a security exception. I noticed that Thunderbird Chat will deny any connection to a ejabberd server running in a default configuration like this due to improper security configurations.

To shut down the server again, use sudo /opt/ejabberd-13.12/bin/ejabberdctl stop .

 

OpenGL frame timer with Qt

Sebastian Haas

To compare impacts of different optimizations in terms of rendering duration, it can be useful to implement a frame timer.  A frame timer counts the amount of time that elapsed during a paint() call. Since version 3.3 OpenGL provides the  GL_TIME_ELAPSED  query which returns the time between to calls in nanoseconds. The code below shows a very basic example in plain C/OpenGL.

Since the availability of those queries depends on the underlying platform, hardware and OpenGL version, Qt provides QOpenGLTimerQuery as a wrapper class for that functionality. The same code for the use within a QGLWidget can be seen in the following snippet.

 

This post is part of a series documenting the progress of the development of a OpenGL/Qt/C++ based application for my fast realistic rendering course at the Universitat Politècnica de Catalunya. The complete source code can be found on github.

References

Calculating a bounding box

Sebastian Haas

In order to implement some visibility algorithms later on, it is useful to calculate a more simple representation of the meshes. The most basic way  to do this, is to define a box with the size of the actual mesh’s maximum dimensions. Also, for a first try, the bounding box will be axis-aligned which makes it easier to compute.

Iterating over all vertices of the mesh allows to retrieve the minimum and maximum dimensions on all three axes. In the following code snippet the vertices are stored in a QVector<QVector3D>. The x, y and z components can be accessed via the corresponding methods x(), y() and z().

The retrieved dimensions can be used to calculate a bounding box for various visibility algorithms. To render the bounding box over the object in the actual scene, the glBegin(GL_LINES) command comes in handy. The next code snippet shows how to render the four lines in the front (z+).

In the end, the result will look something like this when applied on a capsule-shaped mesh:

Axis-aligned bounding box of a capsule
Axis-aligned bounding box of a capsule

This post is part of a series documenting the progress of the development of a OpenGL/Qt/C++ based application for my fast realistic rendering course at the Universitat Politècnica de Catalunya. The complete source code can be found on github.