LabVIEW NXG Archives | MediaMongrels

Posts

DemocracyBot – Raspberry Pi, LINX Toolkit, WebSockets & NXG WebVIs

January 12, 2020/0 Comments/in Blog, MAKE-ing with LabVIEW /by Sam

DemocracyBot – Why vote every 2-4 years when you can vote every 10 seconds?

For NI Days 2019 I was asked to give a demo of something fun/interesting using a Raspberry Pi and the LINX Toolkit. I was originally thinking of demoing some simple sensors but then I remembered an idea I had a few years ago for a 3D printed two-wheeled robot (I nicknamed it the PuckBot) for STEM/educational use.

At the time I was developing the demo, we were in the throws of figuring out Brexit and the 2019 General Election so I decided to take my PuckBot concept and turn it into a piece of policitical humour instead – DemocracyBot was born!

With the United Kingdom enjoying democracy so much with 4 general elections and the Brexit referendum that I would embrace that spirit of democracy and develop a robot where participants could vote every 10 seconds and instantly see their vote in action. “Why vote every 2-4 years when you can vote every 10 seconds?”

DemocracyBot has a web-based voting interface where participants could cast their vote for which direction they wanted the robot to move in and at the end of each 10 seconds the votes would be added up and the robot would perform the most popular option. There was also score tracking to see who voted with the majority the most times.

DemocracyBot voting interface using LabVIEW NXG.

DemocracyBot Software

All of the code for the project is Open Source and available on the DemocracyBot GitHub repository.

The software consists of a LabVIEW 2019 (or LabVIEW 2020 Community Edition) project for the code running on the Raspberry Pi – the Raspberry Pi runs the LabVIEW code as a deployed RT Executable and listens for incoming player connections (using WebSockets), handles the voting aspect and controls the servos to enact the winning vote.

The player interface is written using a couple of LabVIEW NXG WebVIs – the player interface allows players to connect using their phones/tablets and cast their votes in real-time. There is also an admin interface which is used to enable/disable the servo drive and display the leaderboard.

Raspberry Pi Code (LV2019 / LV 2020 Community Edition)

The LabVIEW current-gen (2019+) code uses the LINX Toolkit to develop code that can run on the Raspberry Pi. The architecture is a Queued-Message-Handler with multiple loops. The code uses our internal QMH library – this is based on the NI Template but with some additional functions and templates.

Vote/Main Message Handler

The main message handler is responsible for handling incoming votes, keeping track of players/votes/scores and sending commands to the servo loop. The tracking of voters is done using the Sets & Maps API added in LabVIEW 2019 – I hadn’t yet had chance to try these out but as someone that quite often uses Variant Attributes for lookup tables/dictionaries they seem like an excellent replacement.

The small timer loop is used to trigger the message handler loop to check the remaining time.

WebSockets Listener

The WebSockets Listener is responsible for listening for incoming WebSockets connections (TCP/IP) and launching instances of the WebSockets Connection Handler VI when there’s a valid connection.

Connection Handler

An instance of the Connection Handler VI is asynchronously launched for each client connection – it listens for incoming WebSockets messages (e.g. a vote) and sends status information back to the clients (e.g. time remaining, vote results). It also converts from LabVIEW data types to JSON and vice-versa.

Servo Control Loop

The Servo Control Loop is responsible for controlling the servos – it receives movement commands from the main message handler and performs. The interface to the PCA9865 Servo Board uses LVOOP to wrap the low-level LINX I2C functions into a more beginner/developer friendly API.

Servo Control Loop

NXG WebVI

The NXG WebVI is based on the QMH template included in NXG 3.1 – it opens a WebSockets connection to the Raspberry Pi and then listens for incoming messages to update the display and front-panel events to trigger sending commands/data to the Raspberry Pi.

WebVI Hosting on the Raspberry Pi

For this project, I decided to host the WebVIs using an Apache Web Server running on the Raspberry Pi. The NI Web Server for deploying LabVIEW Web Services (as demonstrated in my last post) has been a bit buggy and doesn’t allow you to serve your files from the ‘root’ of the Raspberry Pi (e.g. http://<Pi IP address>).

The build specification includes the NXG WebVI build files and installs them to /home/lvuser/natinst/bin/webroot (where the rtexe is deployed to) on the Raspberry Pi. For the Apache Web Server to show them when we visit our Raspberry Pi’s IP address, we need to install Apache and then configure it to use that folder as the document root.

To install/configure the Apache Web Server on the Pi:

SSH into the Raspberry Pi (e.g. using PuTTy)
Run ‘sudo apt update’ and ‘sudo apt install apache2 -y’ to install the Apache Web Server
Modify (e.g. ‘sudo nano’) the ‘DocumentRoot’ parameter in ‘/etc/apache2/sites-available/000-default.conf’ to ‘/home/lvuser/natinst/bin/webroot’
Modify the ‘/etc/apache2/apache2.conf’ file and change the Directory section to point to your application webroot i.e. ‘/home/lvuser/natinst/bin/webroot’
Restart apache using ‘sudo service apache2 restart’

Deployment

The first step in deployment is to build the NXG WebVIs – this generates a folder of HTML/CSS/JavaScript that we can host using a web-browser on the Raspberry Pi.

The LabVIEW 2019 project has two auto-populating folders (one for the player & admin interface) that points to the build output folder of the NXG WebVIs – this is then included in the LabVIEW 2019 build specification for the Raspberry Pi real-time executable so that the files are automatically copied over to the Pi when we deploy our code to the Raspberry Pi.

You can then right-click on the RT Executable Build Specification to ‘Build’, ‘Deploy’ and ‘Run as Startup’ on the Raspberry Pi.

DemocacyBot Hardware

Parts List

DemocracyBot is made up of a 3D printed chassis (STL file available in the GitHub Repo) and the rest are off-the-shelf parts that are easily available online (e.g. Amazon).

Here is the full parts list:

3D Printed Chassis: The STL file is in the GitHub repo for you to print yourself or order from a 3D printing service. We can also print and send you one – please get in touch if you’d like to order one.
Raspberry Pi 3/4: The brains of the operation – runs the LabVIEW code and provides connectivity over Wi-Fi. Raspberry Pi 3 board only – £36 from Amazon UK. Raspberry Pi 4 Starter Kit – £89.99.
GeeekPi Mini UPS Power Supply Hat: Allows DemocracyBot to run without a wire on batteries – takes two 18650 rechargeable cells and provides charging capability. £19.99 from Amazon UK.
18650 Rechargeable 3.7V Batteries: Due to shipping regulations, it can be difficult to order these online but you can get 4 batteries plus a torch for £16.99 from Amazon UK.
PCA9865 16 Channel 12-bit PWM Servo Driver: The Raspberry Pi doesn’t have onboard hardware-timed PWM so I’m using an external PWM chip for driving the servo wheels – this board provides 16 channels but we only really need two of them. £9.99 from Amazon UK.
FT90R Microservos + Wheels: The FT90R are a continuous rotation digital micro servo and you can get a pack of 4 + rubber wheels. £17.99 from Amazon UK.
Breadboard Jumper Cables + PCB Standoffs: You might already have some jumper cables & PCB standoffs but you can easily order them – used to mount the Raspberry Pi to the chassis and connect the Pi’s I2C pins and power to the Servo Driver board. £5.95 for 120pc breadboard jumper cable set and £14.99 for 80pc standoff + nuts + screws kit from Amazon UK.
(Optional!) Union Jack Flags: These fit nicely over the PCB standoffs or over the GPIO pins of the Raspberry Pi. £2.99 for 10 from eBay.

Prices correct as of 12/01/2020.

This makes the total cost of the robot excluding the chassis under around £100/€100 – even cheaper if you already have the Raspberry Pi.

Assembly Instructions

3D Print the Chassis
I won’t go into the details of the print settings used as this will vary from printer to printer – just be aware that it will stick pretty well to the bed due to the large flat bottom surface.
Attach the Servos and Servo Driver Board
Using the screws provided with the board/servos, mount the servo driver board and the servos so that the wires pass through the cutout and connect to the first two channels of the servo board PCB. The orange wire of the servo is the PWM signal wire.
Mount the UPS/Battery Board
Screw 4 long PCB standoffs into the mounting holes on the top of the chassis. You may need to drill the holes slightly larger if they don’t screw in easily. Avoid using too much force as the standoffs are fairly fragile – I had the thread break off on a couple of them. The standoffs need to be long enough so that the batteries will fit underneath.
Take two of the 18650 batteries and insert them into the UPS board – ensuring you insert them the right way round.
Position the UPS Board onto the chassis and secure using the smaller standoffs provided.
Mount the Raspberry Pi
You can now mount the Raspberry Pi onto the UPS board using PCB standoff screws – the two springed power pins on the UPS board should line up with and push against the underside of the Raspberry Pi power pins.
Connect the Servo Board
Connect the power (5V & GND) and I2C from the Raspberry Pi GPIO to the PWM Servo Board. You will need to connect power for both the Servos and the PWM chip, as well as the I2C SDA/SCL lines.
That’s it!
You should now be able to charge up the batteries by connecting a MicroUSB cable to the UPS/Battery board and see the charging status on the LEDs. You can turn on the Raspberry Pi by pressing the push button and a long-press to turn it off.

Completed DemocracyBot

Summary

I really enjoyed working on DemocracyBot – it’s a nice way to demonstrate LabVIEW or the free LabVIEW Community Edition running on the Raspberry Pi. The demo itself went pretty well (some WiFi connection issues aside) and I gave a walkthrough of the code at CSLUG in December 2019 as well.

MAKE-ing with LabVIEW & Raspberry Pi: Part 4 – User Interfaces with LabVIEW NXG WebVIs

November 7, 2019/11 Comments/in Blog, MAKE-ing with LabVIEW /by Sam

In this post in the series, I am going to be how you can use a LabVIEW NXG WebVI as a user interface to a LabVIEW Application running on your Raspberry Pi. I’ll be using the MediaMongrels Ltd WebSockets API to communicate between the WebVI and the LabVIEW application.

But first, a quick note…NI Days Europe 2019

Apologies that there hasn’t been a post in a few weeks – things have been pretty busy for me in my day job (in a good way!) and also personally at home so I haven’t had a lot of time for writing articles.

I have been invited by National Instruments to present at NI Days Europe in Munich in a few weeks during one of their sessions on the LabVIEW Community Edition and the LINX Toolkit. In the background I have been spending quite a lot of time putting together a fun & bespoke demo for them using the Raspberry Pi which has interrupted my ability to work on the blog series.

Here’s a sneak peek of what I’m going to be demoing:

If you want to see my demo, come along to the ‘Introduction to the LabVIEW Community Edition’ session at 14:15 on Thursday of NI Days Europe (Agenda link).

I will also have some Raspberry Pi / LINX related demos stuff on the LabVIEW Community Booth in the Exhibition Hall:

LabVIEW Community booth @ NI Days Europe 2019

Finally – I have a hunch that National Instruments are going to release the beta for the LabVIEW Community Edition during NI Days Europe – so hopefully only a couple weeks to go until you can get your hands on some Free LabVIEW!

Introduction

In this post, I wanted to share one method for adding a user interface to your Raspberry Pi project.

During the course of this post, we’ll be combining LabVIEW 2019, LabVIEW NXG WebVIs, WebSockets and the LINX Toolkit to create a simple web-based user interface for a Raspberry Pi application.

Since LabVIEW applications running on the Raspberry Pi run in a similar way to a service (or a LabVIEW real-time application), we can’t simply show the front panel of a VI and have it displayed on the Pi. If we want to display data from our RPi application and/or allow someone to control it – we need to take a different approach.

I’ll hopefully talk in more detail about other possible methods in another post but for now we’re going to look at having a web-based user interface to our Raspberry Pi – and we’re going to do it with WebSockets and LabVIEW NXG WebVIs.

What is a LabVIEW NXG WebVI?

WebVIs allow us to write LabVIEW code in LabVIEW NXG that runs in a browser and it can talk to our Raspberry Pi using LabVIEW Web Services or WebSockets. You can see lots of examples and find out more on their demo/examples site here.

The good news is, National Instruments have announced that LabVIEW NXG and the NXG Web Module (used to create WebVIs) will also be available for free with the Community Edition coming in May 2020!

The Example – NXG WebVIs + WebSockets

In this example, we’re going to write a simple Raspberry Pi application that can display the current date & time on a web-based user interface:

Displaying data from a Raspberry Pi in a web-page using NXG WebVIs

While it’s quite a trivial/simple looking example, there’s quite a few steps involved so I’m going to keep the example itself quite straightforward.

To do this we will need to:

Write our Raspberry Pi application in LabVIEW 2019
Create our WebVI in the LabVIEW NXG Web Module
Deploy our application and WebVI to the Raspberry Pi

I have chosen to use my LabVIEW WebSockets API to communicate between the Pi and the WebVI. WebSockets allows for low-latency asynchronous communication between the Raspberry Pi and the WebVI. LabVIEW NXG 3.1 added native WebSockets client support to the NXG Web Module which makes it really easy to communicate between LabVIEW and a WebVI using WebSockets.

You can use the link above to install the WebSockets API used in this demo/example using VI Package Manager.

Demo/Example Code – Available on GitHub

In the spirit of the LabVIEW Community Edition being free and available for everyone to use, I am going to putting all of my Raspberry Pi / LINX demo code onto a public BitBucket repository – you’ll be able to clone or download all of the demo code used in this series.

Access the public GitHub project using the button below:

MediaMongrels Ltd on GitHub

Git Repo

Repo link for this demo: https://github.com/MediaMongrels-Ltd/Simple-Pi-WebVI-WebSockets

Requires installation of my WebSockets API from the NI Tools Network. Also requires LabVIEW NXG and the NXG Web Module.

Raspberry Pi Application – LabVIEW 2019

Our Raspberry Pi application in LabVIEW 2019 is quite simple – all it needs to do is listen for an incoming WebSockets connection and then periodically send the current date/time to the WebVI.

I’m using a simple state machine for this example – the Main VI loop starts by opening a TCP listener on the port we’re going to use for our WebSocket connection, listens for an incoming connection and if it’s a WebSocket Client connection, start sending the date/time as a string to the client.

The following screenshot shows the code for sending the WebSocket message to the WebVI:

We’ll come back to LabVIEW 2019 again once we’ve created our WebVI as we’ll use the LabVIEW Build Specification to deploy our LabVIEW application and WebVI to the Pi.

Creating our LabVIEW NXG WebVI

The next step is to create our WebVI which will connect to the Raspberry Pi and display the date & time. For this we need to fire up LabVIEW NXG.

I have used a simple state machine again here for the NXG WebVI which will attempt to connect to the LabVIEW VI using WebSockets and then listen for incoming messages and display them.

NXG WebVI for reading & displaying WebSockets messages

The ‘GetHostname’ SubVI on the left-hand side uses the JavaScript Interface Node (JSLI) to call a custom JavaScript function to automatically get the IP address of the Raspberry Pi. You can read more about the JSLI here – it allows you to wrap custom JavaScript (e.g. 3rd party libraries or your own custom JavaScript code) into VIs you can call in a WebVI.

Once you’ve created your WebVI, you then need to ‘build’ it to generate the web (HTML/JavaScript/CSS) files that we can then transfer onto the Pi.

To do this, open the WebApp.gcomp and then click the ‘build application’ button:

Building a WebVI to generate our web files for deployment to the Pi

Once the build is complete, we can then find our WebVI page and its components in the builds folder.

Deploying to the Raspberry Pi

Now that we have our LabVIEW 2019 application and we have built our WebVI, we can now deploy both of these onto the Raspberry Pi.

The reason for deploying the WebVI to the Pi is so that we can access it remotely through a web browser and it would also allow us to access the WebVI from the Pi itself if we have a display attached (in another post, I will show some hints & tips on how we can set the browser to run in kiosk mode and open our web-page automatically on boot).

Deployment Options

There are two options for deploying the WebVI to the Pi along with our LabVIEW application:

Using LabVIEW Web Services
Installing and using the Apache Web Server on the Pi

For this example, I’m going to use LabVIEW Web Services as it is the simplest option – the downside is that the URL for getting to our WebVI is slightly longer (e.g. http://<pi hostname or IP>:<web service port>/<web service name> as opposed to http://<pi hostname or IP> . I’ll add some instructions for using the Apache Web Server in another post.

Creating a LabVIEW Web Service

The first step in deploying our web-page using LabVIEW Web Services is to add a web-service to the LabVIEW project and create a public content folder and point it at the files generated when we built our WebVI in LabVIEW NXG:

Add a Web Service to the Raspberry Pi in the LabVIEW Project

Adding a public content folder to our Web Service.

This will create an auto-populating folder in the web service. The files in this folder will be publicly accessible from the Web Service URL.

NXG WebVI in our Web Service Public Content folder.

Creating our Build Specification for the Pi

Next we need to create a deployment/RTexe of our LabVIEW 2019 application and add our Web Service to it. To do this, right click on ‘Build Specifications’ under the Raspberry Pi target and then select New -> Real-Time Application.

Add your Main VI as the Startup VI under ‘Source Files’ and under Web Services tick the checkbox next to the name of your Web Service so that it gets included in the build and deployed to the Pi. Make a note of the Web service name and HTTP port as you’ll need this to access the web-page hosted by the NI web-server.

Setting the Startup VI in the build specification

Including the Web Service in the build specification

Once you have done that, you can ‘Build’ the real-time application and then right-click on it in the project and select ‘Run as startup’ to deploy it to the Raspberry Pi and set it to run automatically when the Pi boots up. This means we don’t need to launch/run it from the LabVIEW project each time.

Setting the LabVIEW Application to run on boot

After the Pi has rebooted, we should be able to access our WebVI by going to https://<IP Address>:<HTTP port>/<Web Service name> – in the case of my demo project the URL was: http://192.168.1.16:8002/rpi/

We can also open up the page on the Raspberry Pi itself with the built-in browser:

Accessing our WebVI from the Raspberry Pi’s built-in web browser.

Note: Our LabVIEW application is only set up for a single WebSockets connection, so you can only have one page connected to the LabVIEW application at a time.

Summary

This fairly simple example demonstrates one method for adding a user interface to our Raspberry Pi using WebSockets and NXG WebVIs.

In a real application, we’d probably want to take this further to allow multiple simultaneous client connections and also add the ability to send data from the WebVI back to the Raspberry Pi.

I’ll be taking this concept a lot further for my demo at NI Days Europe. I’ll be sure to post something about it when I get back from Munich. If you’re going along – please come and find me and say hello!