Raspberry Pi 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!

MAKE-ing with LabVIEW & Raspberry Pi: Part 3 – Raspberry Pi Setup

September 29, 2019/7 Comments/in MAKE-ing with LabVIEW /by Sam

In Part 3 of this series on using the Raspberry Pi with LabVIEW I will be configuring a Pi 3 B and installing the LINX Toolkit on it. I will also cover some handy hints & tips when setting up the Raspberry Pi.

Introduction

This guide is based on the official set up guide from the Raspberry Pi foundation – found here.

We’ll be setting up the Pi with the latest Raspbian OS package downloaded from the official Pi website and then installing the LabVIEW Run-time.

The Raspberry Pi website offers Raspbian and NOOBS – NOOBS is an easy way to download and try out different OSes for it but it takes up more space on your SD card and may prevent things like configuring it to run headlessly (without a display). I also expect that only Raspbian is supported by the LINX Toolkit.

Prerequisites:

For the initial setup, you’re going to need the following:

Equipment required to configure a Raspberry Pi. — Time to gather your tools to harvest the Raspberry Pi!

Raspberry Pi: The LINX Toolkit officially supports the Pi 2/3 but I will provide an update or a separate post on other targets such as the new Pi 4 and the Pi Zero W.
Power Supply: For the Pi 2/3 you need a MicroUSB with an output of at least 2.5A and 3.0A USB-C for the Pi 4.
>=8GB microSD card: You can use a blank/formatted card or you can buy microSD cards with NOOBS (the Raspberry Pi OS launcher) preinstalled. The SD card will be the disk drive of your Raspberry Pi so will contain the OS and all of your programs/files – it’s worth getting a decent Class 10 SD card or above.
SD Card Reader: You’ll need to format & install the OS image using another computer with an SD card reader. You might also need a microSD to SD adapter.
Screen and Keyboard/Mouse: Recommended for the initial setup but read the hints & tips at the bottom of the post to learn how you can set up the Raspberry Pi without these and use SSH and/or VNC to access the Pi remotely.
Ethernet Cable / WiFi Credentials: To install the LINX Toolkit / LabVIEW Runtime to the Raspberry Pi it will need to be connected to the internet (to download the LabVIEW Runtime) and be on the same network as your LabVIEW 2019 installation (to configure/setup the Raspberry Pi and to deploy code to it).

Of course, you’ll also need your laptop/PC with LabVIEW 2019 and the LINX Toolkit installed – as discussed in Part 2.

How to: Set up a Raspberry Pi for LabVIEW

Download the Raspbian OS
Go to the download page for the Raspbian OS and download the latest Desktop edition (at the time of writing that is Raspbian Buster). There are three editions of the OS available:
– Desktop: The main OS installation that includes a GUI desktop. The GUI can be turned off to improve performance later.
– Desktop and recommended software: As per the ‘Desktop’ download but includes additional preinstalled applications (e.g. for education/programming purposes) – find out more about what’s included here.
– Lite: This is a minimal OS installation without any desktop functionality – you have to use the command-line interface. You can install the desktop support later if you want.
Install the OS to the microSD card
The easiest way to prepare the SD card for your Raspberry Pi is to use balenaEtcher – a multi-platform GUI tool that can format and install the Raspbian OS image to the SD card. Alternatively you can use Win32DiskImager. Note that this will format/wipe the SD card.
– Download and install balenaEtcher from here. It will automatically open.
– Select the Raspbian OS image file you downloaded in the previous step (you don’t need to extract the .zip file).
– Select the correct drive for your SD card.
– Click ‘Flash!’ to begin. The process will take around 5-10 minutes.
The instructions for writing the image to the SD card can also be found here.
Connect your Raspberry Pi
Now you have your SD card prepared, you can install it and connect everything up.
– Install your SD card to the underside of the Raspberry Pi
– Connect your mouse/keyboard to the USB ports
– Connect your display(s) to the HDMI port(s)
– (Optional) Connect an ethernet cable from your Raspberry Pi to your network / router
Turn on the Raspberry Pi
Connect the power supply to the Raspberry Pi. You should see a red LED on the Raspberry Pi board and after a few moments you should see raspberries on the display and the Raspberry Pi will boot to the desktop.
Configure the OS
When it has finished booting, a wizard will appear to allow you configure the basic settings on the Raspberry Pi like the language, timezone and WiFi settings (if present).
– Firstly, enter your country, language and timezone.
– On the second screen you can enter a new password for the ‘pi’ user account and make a note of it – you’ll need it.
– Thirdly, if your Pi has onboard WiFi (e.g. a Pi 3, 4 or Zero W) then you can connect to it now
– Lastly you can check for updates to the OS and applications. The wizard will then prompt you to reboot the Pi if required.
Hooray!
If you made it this far – congratulations, you now have fully functioning Raspberry Pi computer!

If you ran into any issues – check out the official troubleshooting guide or the Raspberry Pi help forums.
Enable SSH
SSH allows you to remotely access a command-line prompt on the Raspberry Pi. This allows you to enter linux commands to access/control the Raspberry Pi. It’s also required by the LINX Toolkit to install the LabVIEW run-time and deploy projects to the Pi.

In newer versions of Raspbian it is disabled by default (to protect against hackers).

Open the Raspberry Pi Configuration utility from the ‘Preferences’ menu, open the ‘Interfaces’ tab, click ‘Enable’ next to SSH and then click OK.
(Optional) Enable GPIO Hardware Peripherals (SPI/I2C/Serial)
The GPIO pins on the Raspberry Pi support a number of protocols/interfaces but they need to be enabled so they can be used from the LINX Toolkit. You can enable these peripherals from the Raspberry Pi Configuration screen as shown above.

If enabling the Serial Port interface, make sure that Serial Console is disabled so that the port is accessible in LabVIEW.

At the time of writing, the LINX Toolkit supports I2C on pins 3&5, Serial on pins 8&10 and SPI on pins 19,21&23. See the pinout here for more information.

Note: All of the GPIO pins are 3.3V – directly connecting any signal >3.3V will likely damage the GPIO functionality of the Raspberry Pi.
Install the LINX Toolkit / LabVIEW Run-time (Method 1: Wizard)
Note: The first beta version of the LINX Toolkit had a number of bugs that mean the installation fails – either apply the fixes at the bottom of the post first and come back here or try the Manual method below.

Update 10/10/2019: NI have updated the LINX Toolkit to Beta 2 which fixes using the Wizard to deploy the LabVIEW Run-time to the Raspberry Pi and adds official support for the Raspberry Pi 4. I have updated the article reflect this.

– Open the Target Configuration Wizard from ‘Tools -> MakerHub -> LINX -> LINX Target Configuration…”

– Enter the hostname/IP, username and password for the Raspberry Pi and click ‘Connect’

– Click the ‘Install Software’ button and then click ‘Install’ – this will perform the required configuration on the Raspberry Pi and install the LabVIEW run-time. This will take a few minutes.

After the installation is complete, the ‘Installed Version’ should show something like 19.X.X (for me at the time of writing it is 19.0.1-2).
Install the LINX Toolkit / LabVIEW Run-time (Method 2: Manual)
The manual installation method is to use a terminal or SSH session on the Raspberry Pi and run the following commands:
echo "deb [trusted=yes] http://feeds.labviewmakerhub.com/debian/ binary/" | sudo tee -a /etc/apt/sources.list sudo apt-get update sudo apt-get install lvrt19-schroot -y

The first line you only need to run once to set up the LINX Toolkit repository on the Raspberry Pi. The 2nd and 3rd lines retrieve the latest package versions from the repository and then install the ‘lvrt19-schroot’ package which has the LabVIEW Run-time.
Run the Example Project
If everything has gone smoothly so far you should now have the LabVIEW Run-Time installed on your Raspberry Pi.

You can test it out by pressing the ‘Launch Example’ button from the Wizard which will generate a example project and configure the IP address of your Pi for you.

If the ‘Launch Example’ button doesn’t work, you can copy the template project from C:\Program Files (x86)\National Instruments\LabVIEW 2019\vi.lib\MakerHub\LINX\Private\Templates\Raspberry Pi 2 B to another folder, open the project and change the IP address to match your Pi and then run it. To do this, right click on the Raspberry Pi target in the project and go to ‘Properties’, then update the IP Address field and click OK.

You can then ‘Run’ the VI, the code will be deployed to the Raspberry Pi and if you have an LED to hand you should be able to toggle it by connecting it to the correct GPIO pin.
Congratulations!
That’s it! You’ve now configured a new/blank Raspberry Pi with the latest Raspbian OS image, configured it for remote access, installed the LINX LabVIEW Run-time and run the sample/template project.

Hints & Tips

Remote Access – VNC

Once you have done the initial setup of the Pi and it is connected to your network, you might not want to keep a display/mouse/keyboard attached to it. The solution is to enable VNC – it’s the Raspberry Pi equivalent to remote desktop and allows you to view and control the Raspberry Pi remotely.

The first step is to enable the VNC server on the Raspberry Pi using the configuration tool (or via sudo raspi-config). You will then need to install the VNC Viewer which you can download from here.

Once installed, you can enter the hostname/IP address of your Raspberry Pi and then connect using the same username/password as SSH.

Accessing the Raspberry Pi via VNC

Headless Raspberry Pi (no display)

If you don’t have a mouse/keyboard/screen available for the initial setup, you can still setup and configure your Pi over the network.

You can do this by modifying the contents of the ‘boot’ partition of the SD Card on your computer after you have written the Raspbian OS image to it.

WiFi

If you need to use the Pi over WiFi, you can confgure the WiFi credentials by creating a file called wpa_supplicant.conf in the ‘boot’ partition of the SD card. Its contents will then be copied over to the Raspberry Pi when it boots up.

The file needs to look like this:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=«your_ISO-3166-1_two-letter_country_code»

network={
    ssid="«your_SSID»"
    psk="«your_PSK»"
    key_mgmt=WPA-PSK
}

You will need to fill in the country code, SSID and pre-shared key. Ensure that the file has Linux line endings (LF or ‘\n’ instead of CRLF ‘\r\n’).

SSH

Create/copy a file called ‘ssh.txt’ (case-sensitive) onto the ‘boot’ partition of the SSD card. The contents of the file doesn’t matter.

Enabling SSH on the Raspberry Pi via the SD Card — Enabling SSH via the SD card boot partition

Other Configuration Options

After setting up the WiFi and enabling SSH, you should be able to boot up and then SSH into the Pi. You can try connecting to the default hostname ‘raspberrypi’ or check your router/network settings to find its IP address.

Once you have connected via SSH, you can run sudo raspi-config to access a terminal-based configuration editor which allows you to change all of the settings of the Pi as per the initial setup etc.

Raspberry Pi terminal configuration utility. — Raspberry Pi Configuration from the terminal (looks pretty oldschool!)

Controlling the LabVIEW Run-time

The LabVIEW Run-time runs as a service on the Pi, to start/stop/restart it you can use the following terminal commands:

sudo systemctl [stop|start|restart] labview.service

This can be useful in case you want to ‘reboot’ LabVIEW without restarting the Pi. Note that this will abort any currently running LabVIEW VIs that are running on the target.

Fixing the LINX Toolkit Beta

Update 10/10/2019: The LINX Toolkit has now been updated to Beta 2 on the NI Software Technology Preview – the fixes below are no longer necessary to install the LabVIEW Run-time to the Raspberry Pi. This update potentially breaks the ability to create Real-Time Applications (rtexe) in LabVIEW 2019 – performing a repair on LabVIEW Real-Time from NI Package Manager fixed this for me.

~~At the time of writing the LINX Toolkit Beta is just a copy of the 2014 version of the Toolkit. It has not been updated or fixed to work with LabVIEW 2019 and newer Pi Targets.~~

Fortunately I have been able to resolve most of the issues to get the Wizard working to install the Toolkit and launch the examples. This requires changes to some of the VIs to update it for the new LabVIEW Run-time for the Pi.

~~Most of the VIs are located in C:\Program Files (x86)\National Instruments\LabVIEW 2019\vi.lib\MakerHub\LINX\~~

Remove LabVIEW 2014 Prompt

Open LMH-Linx.lvlib:System Check.vi and change the string in the case structure from “2014” to “2019”. This will remove the dialog that appears when opening the dialog that you’re using the wrong version of LabVIEW.

Remove LabVIEW 2014 check from LINX Toolkit — Remove LabVIEW 2014 prompt from LINX Toolkit in System Check.vi

Update for 2019 LabVIEW Run-time

~~Open~~ LMH-LINX.lvlib:Install LV Support.vi ~~and change the package name to ‘lvrt19-schroot’:~~

Updates to the Install LV Support VI. — Update the ‘Install LV Support’ VI

~~Open~~ LMH-LINX.lvlib:Add MakerHub Feed.vi ~~and modify as follows:~~

Updates to the Add MakerHub Feed VI. — Update the ‘Add MakerHub Feed’ VI

~~Open LMH-LINX.lvlib:Check Target LV Package Version.vi and change the package name to ‘lvrt19-schroot’:~~

Modifications to the Check Target LV p
Package Version VI. — Update the ‘Check Target LV Package Version’ VI

~~Note:~~ ~~It will still show the latest version as the LV2014 version but it doesn’t affect the installation~~

Add Raspberry Pi 3 (& 4?) Support

T~~he library detects the target type according to the CPU name retrieved from the~~ cat /proc/cpuinfo ~~command. This is different for the Raspberry Pi 3 (and also the Pi 4 and maybe the Pi Zero etc.).~~

~~To add support in the Wizard for new targets we need to do the following:~~

~~Determine the CPU type on the Raspberry Pi by running~~ cat /proc/cpuinfo ~~in a terminal or via SSH. At the end of the output it will show a line saying something like~~ Hardware: BCM2835~~. This is the CPU type used by the LINX Toolkit wizard.~~
~~Open~~ LMH-LINX.lvlib:Get Device Type.vi ~~and add a new entry for the Raspberry Pi you are using (e.g. 3/4):~~
~~To fix the ‘Launch Example’ button in the Wizard, we also need to modify it to use the Raspberry Pi 2 B example files. Open~~ LMH-LINX.lvlib:Script Example Project.vi ~~and modify as follows:~~

If you want to look into the LINX Target Configuration VI, you can open it from the Tools menu and then press ‘Ctrl+.’ to abort the VI. You can then look through its block diagram. Be aware that any changes you make might be overwritten by a new version of the Toolkit. Feel free to leave a comment if you’ve made any other useful changes!

Conclusion

This has been quite a long post, but we’ve now covered everything required to setup a Pi for use with LabVIEW. I’ve also provided fixes for the current Beta version of the LINX Toolkit so you can use the Wizard to install the LabVIEW Run-time and provided some hints & tips for remotely accessing the Raspberry Pi and for setting up the Pi without a mouse/keyboard/screen attached.

In the next post, I’ll go into some details about some of the on-board communications methods on the Raspberry Pi. I will cover network communications and serial ports. Tune in next time!

MAKE-ing with LabVIEW & Raspberry Pi: Part 2 – Installing the LINX Toolkit

September 26, 2019/0 Comments/in Blog, MAKE-ing with LabVIEW /by Sam

In Part 2 of this series on using the Raspberry Pi with LabVIEW, I’ll be looking at installing the latest beta of the LINX Toolkit with LabVIEW 2019. In Part 1 I introduced the series, some of the reasons why you might want to use a Raspberry Pi with LabVIEW and I introduced the Storm Monitor project I’m going to be working towards over the course of the series.

Prerequisites:

For the majority of this series I will be using a Raspberry Pi 3 Model B+. I’ll also be using LabVIEW 2019 so you’ll need to have that installed. You’ll either need to have purchased LabVIEW, be using an evaluation version or wait for the free LabVIEW Community Edition. I’ll be using the latest beta version of the LINX Toolkit (as of 26/09/2019).

LINX Toolkit for LabVIEW

The LINX Toolkit is a free LabVIEW Addon (made by NI’s MakerHub) that allows you to write LabVIEW code on the Raspberry Pi. It also allows you to use an Arduino as an IO device with LabVIEW. You can’t write LabVIEW code that runs directly on the Arduino (take a look at the TSXperts Arduino Compiler).

With the LINX Toolkit you can add the Raspberry Pi as an additional target in a LabVIEW project. You can then download/deploy that code to the Raspberry Pi.

Until recently, the toolkit was only supported on LabVIEW 2014 but part of the LabVIEW Community Edition announcement was that NI would be updating the toolkit to work with LabVIEW 2019 onwards. A beta of the new version for LabVIEW 2019 is through the NI Software Technology Preview.

Note: Since this is beta software, it may be unstable (it is definitely buggy since it’s just a re-packaged version of the library for LabVIEW 2014) and may cause crashes. I don’t recommend installing it on your main development PC – you have been warned!

How to Install the LINX Toolkit

Apply to the NI Software Technology Preview
Apply here. It may take some time for your application to be approved but once you have been accepted, you will have access to the NI Software Technology Preview Community which gives you access to pre-release versions of NI Software, including the LINX Toolkit.
Find and Download the Toolkit
Once you have access, go to the LINX Toolkit Discussion (link) on the Software Technology Preview Community and download it from the ‘LabVIEW 2019 LINX Toolkit Beta Download’ thread.
Install it!
The download is a .iso disk image file which you can mount in a virtual CD-drive by right clicking on the file and selecting ‘Mount’ or by double-clicking on it. You can then install the toolkit by opening the ‘LVLINX2019’ drive and double clicking ‘Install’. This will install the toolkit using the NI Package Manager. Follow the instructions in NI Package Manager to install the toolkit – it should only take a few minutes.
That’s it!
After NI Package Manager does its thing, you’ll then be able to launch LabVIEW and access the LINX Toolkit from the LabVIEW Tools Menu:

Conclusion

In this short post (because I cannot add multiple how-to’s) I have covered how you can setup and install the beta of LINX Toolkit for LabVIEW 2019 using NI Package Manager (NIPM). I will update the post as new updates to the LINX Toolkit are released by National Instruments.

In the next post I’ll be setting up/configuring the Raspberry Pi for use with LabVIEW and offering some hints & tips for using it.

MAKE-ing with LabVIEW & Raspberry Pi: Part 1 – Introduction

September 20, 2019/1 Comment/in MAKE-ing with LabVIEW /by Sam

This is the first part in a series about using the Raspberry Pi with LabVIEW and the LINX Toolkit. It follows the announcement of the release of the free LabVIEW Community Edition from National Instruments.

Introduction

I recently posted about the big news from National Instruments that they would be releasing a free LabVIEW Community Edition in 2020 with a beta/preview version available later this year.

Of course, as an NI Alliance partner I use LabVIEW professionally on a daily basis so LabVIEW being free for non-commercial use doesn’t really affect me but the updates to the LINX Toolkit are very interesting – namely that it can now be used in commercial applications. Of course, making LabVIEW free will help to grow its adoption as a language which is definitely a good thing.

To celebrate this announcement, over the coming weeks and months (as I find the time) I am going to be posting a series of articles about using the LINX Toolkit with the Raspberry Pi in LabVIEW.

Over the years I have built up a pretty extensive collection of Raspberry Pis and various bits of useful hardware to that allow a Raspberry Pi to interact with the outside world as you might using LabVIEW and DAQmx/cRIO etc. The goal of these articles is to help you get started with the Raspberry Pi and LabVIEW and to show you some of the things you can do with it.

Raspberry Pi 4 Promo — The Raspberry Pi 4 was launched in June 2019.

An extra bonus to this is the recent launch of the Raspberry Pi 4 – the latest Raspberry Pi board with a more powerful processor (1.5GHz quad core, 1/2/4GB of RAM, USB 3, onboard Wifi/Bluetooth and Gigabit Ethernet. Although not officially supported by the LINX Toolkit yet, I’ll be having a go at getting it up and running with LabVIEW.

MAKE-ing with LabVIEW & Raspberry Pi – Series Topics

I haven’t fully planned out each article but over the course of the series I’d like to cover the following:

Getting Started with the LINX Toolkit, Raspberry Pi and LabVIEW
- Installation & Configuring the Raspberry Pi
- Building and deploying your first application
- Raspberry Pi 4
On-board communications
- Networking (TCP/IP over Ethernet/WiFi)
- Serial / RS-232
Data Acquisition / Interacting with the real world
- Analog I/O
- Digital I/O
- Other Sensors
User Interface / Display Options
- Nextion Touch Screen
- LabVIEW NXG Web Module (which will also be available for free with the Community Edition)
- Configuring the Raspberry Pi to run a web-page in Kiosk mode

Raspberry Pi hardware and sensors. — Some of the Raspberry Pi hardware we’ll be using over this series of articles

That covers the basics (and there’s a lot there already!) but some other topics I could cover include GSM/GPS. the Pi Zero, using an Arduino as an additional I/O device, Bluetooth communications etc. – please leave a comment if there’s something you’d like me to cover and I’ll try to include it in a future article.

Prerequisite LabVIEW Knowledge?

For this series I’m going to be assuming that you are already fairly familiar with LabVIEW but that are maybe new to the LINX Toolkit and using it with a Raspberry Pi. If you’re new to LabVIEW (maybe you’re checking out the free Community Edition – great, welcome!) then I would suggest starting here or here to learn some of the basics first.

Why use a Raspberry Pi?

The main reason for using a Raspberry Pi is that it is a low-cost and small form-factor computer with plenty of GPIO pins increasing its hardware capability. As an open-source platform, there are 100s of sensors, hats (addon boards), cases and display options available.

Some commercial applications that might be suited to a Raspberry Pi could be:

Low-cost low-channel count data acquisition system (e.g. monitoring a handful of analog inputs where timing/accuracy aren’t critical)
Headless monitoring system (to monitor a system and report data to the cloud)
Low-cost HMI / display module (instead of using a PC alongside a CompactRIO, for example)

Of course, while a Raspberry Pi can be a neat low-cost solution for a headless data acquisition system, it definitely doesn’t replace NI’s other platforms like the sbRIO/CompactRIO or PXI. These systems still have their place as they offer things like:

Deterministic control applications with LabVIEW Real-Time and high-speed control/processing with LabVIEW FPGA
CompactRIO C-Series modules and PXI cards offer a much wider range of input/output options and much higher measurement specifications (e.g. ranges, resolution, accuracy, channel counts etc.)
CompactRIO is a robust/rugged platform that can operate in industrial environments

For this series of articles, I’m going to be exploring the Raspberry Pi’s capabilities through my own hobby project – a storm/weather monitoring station.

Application: Raspberry Pi Storm Station

Most of the time when I’m learning new technologies, I like to have an application in mind as it gives me something to work towards. For this Series, I’m going to be looking at building a Storm Watcher / Weather Station. This is very much a hobby project but it will demonstrate a number of capabilities

Here’s a rough idea of what I want it to be able to do:

Temperature, Pressure & Humidity Measurements
Lightning Detection (using one of these)
On-board display of measurements
The ability to push measurement data to the cloud
Retrieve current/forecast weather information

An exploded view of a Raspberry Pi with a touchscreen display case. — Raspberry Pi case with a 3.5″ Touchscreen

Why? My mum is a keen weather watcher and often uses websites like this one to see where there are storms etc. – I thought it would be a nice little project so she can start detecting her own storms. The Raspberry Pi is ideal for this as it’s a low-cost piece of hardware with built-in WiFi and there are lots of options for small displays etc.

Up Next: Part 2

Stay tuned for Part 2 where we’ll get started with installing and configuring the necessary software on our PCs. For this we’ll be using LabVIEW 2019 and the latest beta version of the LINX Toolkit.

Free LabVIEW™ for everyone – LabVIEW Community Edition coming soon!

September 17, 2019/1 Comment/in Blog, News /by Sam

One of the most newsworthy aspects of GDevCon#2 was a very special announcement from National Instruments that they would be releasing the LabVIEW Community Edition – a free version of LabVIEW™ Professional for non-commercial use.

Yes, that’s right…

You will be able to download and use LabVIEW™ for FREE!