RPi Node Red: Remotely accessing node-red and VNC

Goal:

Connect to your node-red flows and/or to your Raspbian desktop remotely using a web browser or VNC client.

Resources:

Raspberry pi and another computer on the same network, the other computer could be running Windows, OSX, or a different Raspberry Pi Computer.

Intro:

Node-red hosts itself as a webpage that can be accessed not only on the RPi it’s running on, but also by any other computer connected to the same network. The RPi’s desktop itself can also be accessed over the network using a VNC client that comes preinstalled on the Raspbian image in your T3 kit.

 

Accessing node-red:

You’ll only need two things to access your node-red flows over the network. A computer connected to the same network (WiFi or LAN) that can run google chrome, and the RPI’s IP address.

 

To find the IP address of the pi that’s running node-red, hover the mouse pointer over the applet until the IP address appears as pictured.

Here it says our IP address is 10.71.0.174
Node-red hosts itself on localhost on port 1880 by default. On the computer running node-red it can be accessed via localhost:1880 For anyone else they need to connect explicitly to the device.

Type this into a web browser on another computer on the same network: 10.71.0.174:1800 (your IP address will be different – but keep the :1880)
In google chrome it looks like this.

Any changes we make to our flow here will be reflected on the RPi running node-red. Therefore we have remotely accessed our node-red flow over the network!

 

VNC:

Connecting over VNC allows you to essentially remote-control your RPi over a network, and with the right setup even over the internet.

First go to the main-menu and go into the Configuration menu.

 

In the interfaces tab enable VNC

 

After you push okay the window will disappear, and soon the VNC icon will appear in the top bar. Click on it to open the VNC window.

 

On the other computer you’ll need to install VNC Viewer.

https://www.realvnc.com/en/connect/download/viewer/

 

The same IP address we used to connect to node-red is used to connect to VNC, the VNC Server window also shows your IP address under “connectivity”.

 

 

 

 

RPi: Building a ShakeMeter with Raspberry Shake and Node-Red

Goal:

Build a real-time “Shakemeter” in the Node-Red Dashboard! The Shakemeter will take the real-time seismic data and convert it into a live measurement of the absolute amplitude and velocity at which the ground is shaking! Set it up in your classroom and see how powerfully you can jump, put in next to the court to see how hard a home crowd cheers for your basketball team, or set it up at a school assembly to see which class has the most spirit!

 

Resources:

Introduction:

After following the first tutorial on connecting  Shake to Node-Red, now we can start to use Node-Red to process and visualize the seismic data that is being streamed through the UDP port.

Getting Started:

Before starting this tutorial, make sure you have already completed the “Streaming Raspberry Shake Data to Node-Red” tutorial. Your flow should look like this:

Make sure that there is UDP data being received by checking the debug tab. As you can see, the data coming through the Rshake Parser is still in object form, consisting of multiple types of information. In order to separate the numerical data and to quantify the shaking, another function node is needed to process the data. Below is an example of a node we made to address this.

Using the data:

[{"id":"d5d2efbb.2600e","type":"function","z":"b308f371.c9fa","name":"Absolute Amplitude","func":"acc = 0;\nnum = 0;\nfor(const p of msg.payload.packets)\n{\n    acc += Math.abs(p);\n    num++;\n}\n\nacc /= num;\n\nmsg.payload = acc;\nreturn msg;","outputs":1,"noerr":0,"x":570,"y":360,"wires":[["c8911fad.47f72"]]},{"id":"c8911fad.47f72","type":"smooth","z":"b308f371.c9fa","name":"","property":"payload","action":"mean","count":"25","round":"0","mult":"single","x":780,"y":360,"wires":[["6270e4ac.2138fc","64858a7e.ecae14"]]}]

 

You can copy and paste this code-block to import an ‘Absolute Amplitude’ function-node, it takes the raw data from the rshake parser node and turns it into a more easily usable integer which describes the amount of absolute vibration over the past couple of seconds. After it there is a “smooth” node to take the mean of the first numbers in order for the data to be processed more easily. *Note: photos show “average magnitude” in place of “absolute amplitude”

To import code-blocks like this, use the top right menu and select ‘import -> clipboard’ then a box will pop up allowing you to paste in the flow.

 

Your flow should now look similar to the photo above. The next step is to add the Dashboard “Gauge” Node, and attach it after the smooth node. Then, we have to configure the Gauge node. Make sure to Make the range from zero to at least 50000 (remember not to put a comma in 50000). If you have not yet, you will also have to create a Dashboard group, by pressing the edit button next to the “group” field, and then pressing it again next to the “tab” field.  Then click Update, then Done!

 

Now, we are ready to deploy!

Once deployed, open your local Node-Red Dashboard.  You can access this page by entering http://”yourIPaddress:1880/ui. For example: http://10.18.102.253:1880/ui

Now, bang the table! Jump up and down! How can you apply the ShakeMeter to something relevant in your home, school, or community?

So go get Shakin!

 

RPi: Building a Raspberry Shake seismogram on the Node-Red Dashboard

Goal:

Set up a real time Seismogram on the Node-Red Dashboard.

 

Resources:

Introduction:

After following the first tutorial on connecting  Shake to Node Red, now we can start to use Node-Red to process and visualize the seismic data that is being streamed through the UDP port.

Getting Started:

Before starting this tutorial, make sure you have already completed the “Streaming Raspberry Shake Data to Node-Red” tutorial. Your flow should look like this:

 

Make sure that there is UDP data being received by checking the debug tab. As you can see, the data coming through the Rshake Parser is still in object form, consisting of multiple types of information. For building the siesmogram graph, we just want the numerical data.

First, we have to add a switch node that discriminates the the channel of the data. If we are using a Shake 1D, it will be the channel EHZ. So, we must add a switch node after the parser, and format it to be listening for the property “msg.payload.channel” and underneath we can add the rule as: == “string” EHZ. This separates the data that we want.

The data is still not in a format useable for graphing, so we have to create a custom function node to separate the numerical data. Raspberry shake has created a code just for this purpose.

Go to the menu and choose import>clipboard, and paste this code and import the node.

[{"id":"299110c.a2af7f","type":"function","z":"d328b37.176a45","name":"format plot values","func":"\nvar EVERY_N_PACKET = 20; // max = 24\nvar POINTS_PER_SECOND = 100 / EVERY_N_PACKET;\nvar KEEP_SECONDS = 60;\nvar KEY=\"f2_all_points\";\n\nvar MAX_POINTS = POINTS_PER_SECOND * KEEP_SECONDS;\n\nvar input = msg.payload;\n\nvar data = [{series:[\"P\"],\n    data:[],\n    labels:[\"Points\"]\n}];\n\nvar allPoints = flow.get(KEY);\nif(allPoints == undefined)\n    allPoints = [];\n\n\nfor(var i=0, step=EVERY_N_PACKET; i + step < input.packets.length; i += step) {\n    var o = {x: input.ts + i*10,\n             y: input.packets[i]};\n    allPoints.push(o);\n}\n\nif(allPoints.length > MAX_POINTS)\n    allPoints = allPoints.slice(\n        allPoints.length - MAX_POINTS, \n        allPoints.length\n    );\n\nflow.set(KEY, allPoints);\n\ndata[0].data.push(allPoints);\n\n\nmsg.payload = data;\n\nreturn msg;","outputs":1,"noerr":0,"x":877,"y":171,"wires":[["73bf48a9.3fc398"]]}]

Connect the ‘format plot values” node to the switch node. Now, to finish we connect a Dashboard chart. Your flow should look similar to this:

Then, configure the chart in the way that you would like, and Deploy!

Now, open your local Node-Red Dashboard! You can access this page by entering your Node-Red address /ui. For example: http://10.18.102.253:1880/ui

Now, bang the table! Jump up and down! See what happens to the graph!

 

To continue working with the Shake Data in Node-Red, go to the next Tutorial!

Making a Shakemeter: https://t3alliance.org/rpi-building-a-shakemeter-with-raspberry-shake-and-node-red/

 

 

RPi Node-Red: Advanced Multi-Button Board + RGB LED

Overview

This tutorial will utilize a multi-button board input device to control an RGB LED module. Students will learn about and utilize binary counting to program the multi-button board. This tutorial adds to prior knowledge on the Button + LED tutorial.

Requirements

  • Raspberry Pi 3 Model B
  • Multi-Button Board
  • RGB LED Module
  • F-F Jumper Cables

Getting Started

Setting up the Hardware

Multi-Button Board to Raspberry Pi

  • K1 to #6
  • K2 to #5
  • K3 to #22
  • K4 to #27
  • K5 to #17
  • K6 to #4
  • K7 to #21
  • K8 to #20
  • G to GND

RGB LED to Raspberry Pi

  • R to #13
  • G to #19
  • B to #26
  • GND to GND

Setting up Node-Red

  1. Insert RPi-GPIO-In Nodes
    1. These nodes act as inputs from the multi-button board.
    2. Place 8 nodes, representing the 8 button inputs.
    3. Assign each button (K1, K2…, K8) to their respective GPIO pin on the Raspberry Pi.
    4. Set the Resistor setting to pullup.
    5.  
  2. Insert Change Nodes
    1. These nodes translate the input nodes from the multi-button board into number values from 0 to 7 (numbering starts at 0 due to how computers start counting at 0 instead of 1).
    2. Place 8 nodes, labeling them from 0 to 7.
    3. For each node, change the data type to number and set the values to 0-7 starting with the first node.
  3. Connect an RPi-GPIO-In node to a Change node
    1. Connecting the two node types translates each binary 0 or 1 button input into a different decimal value.
  4. Insert Function Nodes
    1. These nodes act as “decoders” that translates the numbered value into a bit-string.
    2. The RGB values represent three individual switches. By having a bit-string representation, each bit can determine the color’s bit state.
    3. Function for [4] node
      1. // Value retrieved from initial input
        var value = msg.payload;
        
        // subtract_bit determined by bit location
        var subtract_bit = 4;
        
        // If value is greater than the subtract_bit, indicates that the bit state for [4] is 1
        if (value >= subtract_bit) {
            var new_value = {payload: value - subtract_bit};
            var bit_state = {payload: 1};
            return [new_value, bit_state];
        }
        
        // Otherwise, bit state for [4] is 0
        else {
            value = {payload: value};
            var bit_state = {payload: 0};
            return [value, bit_state];
        }
    4. Function for [2] node
      1. // Value retrieved from initial input
        var value = msg.payload;
        
        // subtract_bit determined by bit location
        var subtract_bit = 2;
        
        // If value is greater than the subtract_bit, indicates that the bit state for [2] is 1
        if (value >= subtract_bit) {
            var new_value = {payload: value - subtract_bit};
            var bit_state = {payload: 1};
            return [new_value, bit_state];
        }
        
        // Otherwise, bit state for [2] is 0
        else {
            value = {payload: value};
            var bit_state = {payload: 0};
            return [value, bit_state];
        }
    5. Function for [1] node
      1. var bit_state = {payload: msg.payload};
        return bit_state;
  5. Insert RPi-GPIO-Out Nodes
    1. These nodes act as output nodes for the RGB LED module.
    2. Place three nodes, each representing one of the RGB LEDs and assign to their respective GPIO pin.

Conclusion

If you have successfully followed this tutorial module, you should be able to change the RGB LED module’s color from the multi-button board.

Node-Red Solution

[{"id":"3fc0ad9f.487e12","type":"change","z":"b8b26cb8.1baef","name":"2","rules":[{"t":"set","p":"payload","pt":"msg","to":"2","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":410,"y":280,"wires":[["5f4cfd28.f4a124"]]},{"id":"cbd11229.36a9","type":"rpi-gpio in","z":"b8b26cb8.1baef","name":"K2","pin":"29","intype":"up","debounce":"25","read":false,"x":290,"y":220,"wires":[["c4e5685f.e3fa88"]]},{"id":"96dd66c6.026928","type":"rpi-gpio in","z":"b8b26cb8.1baef","name":"K4","pin":"13","intype":"up","debounce":"25","read":false,"x":290,"y":340,"wires":[["75069901.3cc9b8"]]},{"id":"d710bb14.62b1f8","type":"rpi-gpio in","z":"b8b26cb8.1baef","name":"K3","pin":"15","intype":"up","debounce":"25","read":false,"x":290,"y":280,"wires":[["3fc0ad9f.487e12"]]},{"id":"2b18a8d6.7f92f8","type":"rpi-gpio in","z":"b8b26cb8.1baef","name":"K6","pin":"7","intype":"up","debounce":"25","read":false,"x":290,"y":460,"wires":[["ac5a8574.e332f8"]]},{"id":"3c93bf81.fb10d","type":"rpi-gpio in","z":"b8b26cb8.1baef","name":"K8","pin":"38","intype":"up","debounce":"25","read":false,"x":290,"y":580,"wires":[["d0ff8cfe.8f2c5"]]},{"id":"aac40b7a.f36bb8","type":"rpi-gpio in","z":"b8b26cb8.1baef","name":"K7","pin":"40","intype":"up","debounce":"25","read":false,"x":290,"y":520,"wires":[["3954b9a.a55c346"]]},{"id":"551dc587.3f572c","type":"rpi-gpio in","z":"b8b26cb8.1baef","name":"K5","pin":"11","intype":"up","debounce":"25","read":false,"x":290,"y":400,"wires":[["631bd1a6.8dd45"]]},{"id":"31bb63ee.bf082c","type":"change","z":"b8b26cb8.1baef","name":"0","rules":[{"t":"set","p":"payload","pt":"msg","to":"0","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":410,"y":160,"wires":[["5f4cfd28.f4a124"]]},{"id":"c4e5685f.e3fa88","type":"change","z":"b8b26cb8.1baef","name":"1","rules":[{"t":"set","p":"payload","pt":"msg","to":"1","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":410,"y":220,"wires":[["5f4cfd28.f4a124"]]},{"id":"75069901.3cc9b8","type":"change","z":"b8b26cb8.1baef","name":"3","rules":[{"t":"set","p":"payload","pt":"msg","to":"3","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":410,"y":340,"wires":[["5f4cfd28.f4a124"]]},{"id":"631bd1a6.8dd45","type":"change","z":"b8b26cb8.1baef","name":"4","rules":[{"t":"set","p":"payload","pt":"msg","to":"4","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":410,"y":400,"wires":[["5f4cfd28.f4a124"]]},{"id":"ac5a8574.e332f8","type":"change","z":"b8b26cb8.1baef","name":"5","rules":[{"t":"set","p":"payload","pt":"msg","to":"5","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":410,"y":460,"wires":[["5f4cfd28.f4a124"]]},{"id":"3954b9a.a55c346","type":"change","z":"b8b26cb8.1baef","name":"6","rules":[{"t":"set","p":"payload","pt":"msg","to":"6","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":410,"y":520,"wires":[["5f4cfd28.f4a124"]]},{"id":"d0ff8cfe.8f2c5","type":"change","z":"b8b26cb8.1baef","name":"7","rules":[{"t":"set","p":"payload","pt":"msg","to":"7","tot":"num"}],"action":"","property":"","from":"","to":"","reg":false,"x":410,"y":580,"wires":[["5f4cfd28.f4a124"]]},{"id":"23c6a01e.0e013","type":"rpi-gpio in","z":"b8b26cb8.1baef","name":"K1","pin":"31","intype":"up","debounce":"25","read":false,"x":290,"y":160,"wires":[["31bb63ee.bf082c"]]},{"id":"5f4cfd28.f4a124","type":"function","z":"b8b26cb8.1baef","name":"[4]","func":"// Value retrieved from initial input\nvar value = msg.payload;\n\n// subtract_bit determined by bit location\nvar subtract_bit = 4;\n\n// If value is greater than the subtract_bit, indicates that the bit state for [4] is 1\nif (value >= subtract_bit) {\n    var new_value = {payload: value - subtract_bit};\n    var bit_state = {payload: 1};\n    return [new_value, bit_state];\n}\n\n// Otherwise, bit state for [4] is 0\nelse {\n    value = {payload: value};\n    var bit_state = {payload: 0};\n    return [value, bit_state];\n}","outputs":2,"noerr":0,"x":590,"y":340,"wires":[["fb4d798f.1edc38"],["a17a86af.bfb648"]]},{"id":"fb4d798f.1edc38","type":"function","z":"b8b26cb8.1baef","name":"[2]","func":"// Value retrieved from initial input\nvar value = msg.payload;\n\n// subtract_bit determined by bit location\nvar subtract_bit = 2;\n\n// If value is greater than the subtract_bit, indicates that the bit state for [2] is 1\nif (value >= subtract_bit) {\n    var new_value = {payload: value - subtract_bit};\n    var bit_state = {payload: 1};\n    return [new_value, bit_state];\n}\n\n// Otherwise, bit state for [2] is 0\nelse {\n    value = {payload: value};\n    var bit_state = {payload: 0};\n    return [value, bit_state];\n}","outputs":2,"noerr":0,"x":730,"y":360,"wires":[["bb73fc3f.28e14"],["74e9a7d8.f4a0e8"]]},{"id":"bb73fc3f.28e14","type":"function","z":"b8b26cb8.1baef","name":"[1]","func":"var bit_state = {payload: msg.payload};\nreturn bit_state;","outputs":1,"noerr":0,"x":870,"y":380,"wires":[["9a25ca9f.d2dca8"]]},{"id":"a17a86af.bfb648","type":"rpi-gpio out","z":"b8b26cb8.1baef","name":"Red","pin":"33","set":"","level":"0","freq":"","out":"out","x":750,"y":280,"wires":[]},{"id":"74e9a7d8.f4a0e8","type":"rpi-gpio out","z":"b8b26cb8.1baef","name":"Green","pin":"35","set":"","level":"0","freq":"","out":"out","x":890,"y":300,"wires":[]},{"id":"9a25ca9f.d2dca8","type":"rpi-gpio out","z":"b8b26cb8.1baef","name":"Blue","pin":"37","set":"","level":"0","freq":"","out":"out","x":1030,"y":320,"wires":[]}]

RPi Node Red: Streaming rpi camera to dashboard

Goal:

Broadcast a live video feed from the RPi camera to a locally and network accessible webpage.

Resources:

RPi and a RPi camera.

Hardware:

Only setup here is connecting the RPi camera to the pi using a ribbon cable.

Installing Streaming Software:

We’ll be following this tutorial here: https://elinux.org/RPi-Cam-Web-Interface

The page there is extremely verbose and scary, but the actual setup is very simple and should only take a few minutes.

First open a terminal, and enter

sudo apt-get update

This will update your repository so the right links are there.

Then pase / type this into the same terminal and press enter.

git clone https://github.com/silvanmelchior/RPi_Cam_Web_Interface.git

This will start downloading the git repo for the web interface; this should only take a few seconds.

cd RPi_Cam_Web_Interface

Enters the directory that we just downloaded.

./install.sh

runs the script to start installing everything, it will prompt you for some settings, press enter to use the defaults.

 

In the article we’re following it mentions

The scripts are

    install.sh main installation as used in step 4 above
    update.sh check for updates and then run main installation
    start.sh starts the software. If already running it restarts.
    stop.sh stops the software
    remove.sh removes the software
    debug.sh is same as start but allows raspimjpeg output to console for debugging

    To run these scripts make sure you are in the RPi_Cam_Web_Interface folder then precede the script with a ./
    E.g. To update an existing installation ./update.sh
    E.g. To start the camera software ./start.sh
    E.g. To stop the camera software ./stop.sh

 

We just ran the ‘install.sh’, which installs everything. Now if we want to start the stream we’ll use ‘start.sh’

 

./start.sh

If we want to start the stream, say after restarting the pi we’ll have to navigate back to this directory and run the start script.

That process just looks like this:

cd RPi_Cam_Web_Interface
./start.sh

 

Viewing the stream:

Now for the fun part, actually viewing the stream.

First we’ll need our ip address; this can be found by hovering the mouse over the WiFi applet like this:

Next, on the same pi or any computer on the same local network we can open the stream via this address.

The url will look like this, except with the ip address switched out for your own.

10.71.0.174/html

Here’s what the default page looks like when we’re streaming.


You can edit all kinds of settings here, that aren’t really necessary for a basic setup.

If your image happens to be upside down you can change the rotation in the “Camera Settings” tab here:

There’s also a more minimal page that only shows the video here:
http://10.71.0.184/html/min.php

Remember that the IP address will be different for you.

 

Embedding the stream into node-red dashboard:

The T3 RPi kit comes with the node-red dashboard nodes installed already, and this is what we’ll use to view the stream in node-red. The advantage to doing that is that you can have buttons, graphs, or other data alongside the video feed.

Here is an example where we have the feed coming from a remote controlled car, with buttons alongside to drive the car around.

In this tutorial we’ll focus on getting the video itself to display.

Here is what the configuration for the template node looks like:

everything is set to default, except we’ve added some html code to the template box.
Here’s the code:

<iframe scrolling=no marginwidth=0 marginheight=0 frameborder=0 height=439 width=553 src="http://10.71.0.200/html/min.php"></iframe>

For it to work on your template node, you’ll have to replace the url here with the one for your pi. So the IP address will be different.

The other change is adding a new ui_group.

If you click the pen here, it’ll open the panel to define the new default group.
You can leave this all at default, but I think it looks better with the video if you raise the width slightly.
Here’s mine with the width raised to 9

Now if you deploy and navigate to http://your_ip:1880/ui you should be able to see your video stream embedded in the node-red dashboard.

You can fine tune the iframe settings like width and height in the template node, and the layout size in the dashboard options.

T3 Rpi WiFi Router Setup TP Link TL-WR902AC

We recommend purchasing this router pre-programmed to provide the rpi wireless network, but it must still be connected to your local school WiFi.

This router allows you to connect to any type of wireless network and re-broadcast it as a local private WiFi network – also one LAN port can be connected to a local networking device such as a Raspberry Shake.

This allows the RPi computers to talk to each other over the LAN and do other local area networking tasks.

Configuration Guide for Pre Programmed Router:

T3 Lesson 8: Project – Make a Whoopee Cushion:

INTRODUCTION

This lesson is an opportunity for students to have fun converting their understanding of the technology into something in the real world.  A whoopee cushion is a glorified button that can be made out of easily available materials.

APPLICATION

This video from the Raspberry Pi Foundation has a very good description of how to make this project work.

The detailed instructions can be found here:

https://projects.raspberrypi.org/en/projects/whoopi-cushion

Our challenge is to make the audio files play using node red.  You can follow the video and install this extra output node that is capable of playing audio files.

https://flows.nodered.org/node/node-red-contrib-play-sound

 

REVIEW

If you found success or didn’t, please post a response in the forum.

T3 Lesson 7: Advanced Node-Red and the camera

INTRODUCTION

Slides

Setting up a camera can be one of the more exciting activities for your students to complete.  It provides immediate feedback that is very gratifying and provides ample opportunity to explore what can be done.

APPLICATION

Here is the basic tutorial for turning on a camera: The default for the image on the pi is for the camera to be enabled.

RPi Node-Red: Camera

Once the camera is taking photos, it wasn’t super difficult to incorporate a button into the sequence or any sort of a trigger that is based on an “if-then” scenario.  If the sonic sensor is an example of an analog device that collects data and can be set to trigger a photo when a certain threshold is reached.

RPi Node-Red: Sonic Sensor (HC-SR04)

 

 

T3 Lesson 6: Node-Red and programming the GPIO pins

Note:  This is divided into two section

INTRODUCTION

Slides

This lesson introduces Node-Red and how it can be used to control the GPIO pins on the Raspberry Pi.   The first part of the lesson is seeing how Node-Red is a programing language that follows the basic concepts identified earlier.  The second part is in understanding the GPIO pins and how they function with and without Node-Red. A challenge activity that students build such as push button timer or stop lights will be available soon.

APPLICATION

Here are three tutorials that you can explore with your students that all go over basic Node Red GPIO pin functions.

RPi Node-Red: RGB LED

 

RPi Node-Red: Push Button

RPi Node-Red: Buzzer

REVIEW

Post your reflection in the forum, if you are comfortable sharing.  We’d like to hear how it went and what we can do to improve this process.

 

T3 Lesson 5: Scratch and Basic Programming

INTRODUCTION

This lesson teaches about some basic programming constructs using one of the simplest programming languages.  Many students will have been exposed to it, so if it’s not for your crew, skip it. There are enough advanced options that a student can make a very complicated program.  I think of it like legos – it’s a good space to play around and get familiar with the basic programming concepts.

APPLICATION

Here are slides that can be helpful in introducing this topic.

Here is a link to my explanation of the Astronaut reaction time game.  The tutorial suggests that you use the older version of Scratch on your Pi, version 1.4.  It can be done with that or else you can use the slightly slower version 2.0.  Version 2.0 is identical to what you find when you use scratch in a basic computer browser.  It is Flash-based and it runs a little slower than version 1.4.

 

T3 Lesson 4: Computers, Raspberry Pi and the internet of things

 

INTRODUCTION

This lesson is a presentation that is meant to open students eyes to the power of the Raspberry Pi.  We focus on the basics of a computer, input, and output, and share examples of cool projects that are done in a number of industries.  Biomedical, home security, seismology, environmental science are a few that can be shared. A discussion about the Internet of things (IoT) and how computer programs function will be valuable here.

Slides

APPLICATION

In the slides, there is a link to the Code.org video – What makes a computer a computer – Its an excellent introduction to the idea of a computer and the way that it takes in and puts out information.

 

After going through the video here and sharing some of the photos of cool projects I try to get a discussion going in which the students have a chance to share what problems or issues might have been addressed with the technology.    If there is someone in your community willing to share their Raspberry Pi’s project in some capacity – this is a wonderful time.  The idea here is to build excitement for what is possible and then to get them ready for the challenging work ahead.

REVIEW

Post your reflection in the forum, if you are comfortable sharing.  We’d like to hear how it went and what we can do to improve this process.

 

T3 Lesson 15: Air Quality Sensors

INTRODUCTION

Air quality is one of those topics that connects all of us.  It’s not difficult to find someone in your community who is sensitive to variations in air quality and is willing to share their story as a seed for an air quality monitoring project.   As I describe above,  our project with air quality sensors came out of the problem that our community in Hawaii faced during the 2018 volcanic eruption.

Slides

Setting up for this day depends on the resources that you have available to you.   In the story presented about Hawaii, we had students split up into teams of 3 to build air quality sensors for various areas around our region.   If you just have one, then you will want to emphasize more about the data that is collected and what it means than the building process.   Building the kit is pretty straightforward if you follow the tutorials below.

The connection with what the data means is the exciting part.  I would find someone in your community who is interested in talking with your students about Air Quality.  Once the students know how to manipulate the LCD screen, this can turn into a way for the Air Quality information (and other info) to be displayed.

APPLICATION

Here are the building steps:
https://t3alliance.org/rpi-airquality-station-indepth-assembly/
Here are the programming steps:
Here are the steps associated with programming the LCD screen:
https://t3alliance.org/rpi-airquality-station-creating-an-animated-nyancat-wallpaper/

REVIEW

You will know this is working on the specific level if students or you can notice changes in air quality after tweaking the environment slightly.  An open or closed door, any sort of dust and you should be able to detect changes.  On the larger level, if students feel comfortable applying this technology to a community issue then you have opened a huge door.  There are 3 sensors connected, nothing is stopping a student from identifying and setting this device up with more sensors that can send information to the cloud.   This basic sensor is like the gateway project to more remote monitoring projects.

 

T3 Lesson 3: Building the Box & Raspberry Pi Kits

INTRODUCTION

Now that students are pumped up with the sense of efficacy that comes from building a brushbot, its time to switch to building a computer in components.  This is an example of an opportunity to hold space for the students to “figure it out” and continue on their growth mindset pathway.  Building the boxes can be done without much instruction given that the culture of growth mindset has been set.  Students figure out how to assemble the boxes in about 40 minutes.   If you have an hour, expect that students will spend the final part of class exploring the Pi and getting to know its features.

APPLICATION

Preparing the space – Make sure that each student has sufficient space to assemble their kit.  If you have students that are working together, make sure they have sufficient space to spread out and that they have access to power nearby.   You can share the slideshow showing a guide and a quick video of the assembly process but try to refrain from giving too much directive.  It’s a puzzle and the pieces only fit one way.

Slides

It helps to have at least two people doing it at the same time, so they can compare and help each other with the process.  We purposely did not give step-by-step instructions because the challenge is figuring it out, using your growth mindset to not give up or get too frustrated.

Here’s a video of the process.

Once the box is together, the next step is to plug in the power, monitor and raspberry pi.  This will create a functioning computer loaded with the basics of a web browser and a few games.

I recommend checking that the box is assembled and that the screws are tight before handing the students the bag of electronic equipment.

Once the bag of equipment is handed out introduce the idea of physical inputs and outputs.

Share the short video about the anatomy of a Raspberry Pi.

 

REVIEW

Allow students to explore around on the pi and recognize that this is a fully functioning computer.  Students often become interested in Minecraft.  If there is a student that you identify as “minecrafter” you can ask them to take a moment to share their skills.

Celebrate the success that just occurred!  You’ve just assembled a working computer!!  Reflect on what you did well, and what things you could improve on for your next challenge(s).

Post your reflection in the forum, if you are comfortable sharing.  We’d like to hear how it went and what we can do to improve this process.

 

RPi Airquality Station: Creating an Animated Nyancat Wallpaper

 

Goal:

Use the RPi Airquality station hardware, combined with node-red to create an animated nyancat wallpaper

 

What you will learn:

Combining the basic LED Matrix nodes, with more advanced javascript nodes to create fancier output.

 

What you will need to know:

Getting started with node-red

 

Parts List:

  • Full RPi Airquality kit

Getting Started:

First step is to familiarize yourself with the ‘image’ node.

Drag one in from the ‘LED Matrix’ section of the palette and setup config node, if you haven’t got one ready to re-use

All of the display settings can be left at their default, but because we want the wallpaper to update quickly you can bump the ‘Refresh Delay Milliseconds’ down to 100.
By default the Matrix will only redraw all the objects on the screen 2 times a second, but with this setting changed it’s a more attractive 10 times a second.

Next we’ll inject an image in the matrix.

This is the animated NyanCat we’ll be using: https://t3alliance.org/wp-content/uploads/2019/01/nyanCat.gif
It’s a tiny image, about 20 pixels high; but that’s a good thing for us because it means it’ll actually fit on the display. If you wish to use your own gifs and images with this tutorials, be mindful that the LED Matrix that comes with the airquality kit is only 128×64 pixels, so you’ll have to manually resize most images you want to use with it.

Setup an inject node with the nyanCat url as the string, and connect it to the image node.Once you deploy, and inject the node you should see the image appear as pictured.

Notice that the nyanCat is not animated. The way the Image Node handles gifs, is that it increments the frame when injected multiple times. So if you press the inject node button again, you should see the next frame in the sequence appear. You can continue clicking all the way through until the image resets back to frame one.

Of course the Node-Red inject node comes with repeating functionality already, so all you really have to do is setup the inject node like this to see your nyanCat beautifully animated in the top corner.

 

Manually Moving NyanCat:

Next is the more complicated step of actually moving the image around; I’ll lay out the function nodes so you can copy and paste them if you get stuck.

The basis for all our functions will be this info that comes with the image node. By default you can inject a plain string that gets matched with the settings in the node, or you can send a fully featured object that contains data for where the image should be drawn, as well as what file it’ll be.

To start we’ll try send just the image itself, in a static location.

//create the message we'll output
var output = {}

//insert our properties into the payload
output.payload = 
{
    data: "https://t3alliance.org/wp-content/uploads/2019/01/nyanCat.gif",
    x: 10, 
    y: 10,
}

//send out to the next node
return output

Here’s what the function node looks like with the code inside:

On line 2 we setup an empty object that we’ll fill with our properties later.
Then on line 5 – 10 we setup our data, the url of the image, and the location.
Then finally we return the object we created at the start, which will output it from the node-output.

Hooked up to the Image node with a generic inject node, you can draw the nyanCat again, except this time it’ll be offset from the top corner by 10 pixels.
Play around with the values for X and Y to move it around the screen manually.

 

Autonomous Nyancat:

The next step is getting the X and Y to update automatically.

Luckily for us nyanCat only flies in a straight line, so the Y coordinate can remain static, only changing the X coordinate interests us.
Here is the new code:

//create the message we'll output
var output = {}

//setup our varaible for X
var location = flow.get("x") || 0

//check to see if we've went off the edge
if(location > 128) location = 0

flow.set("x", location + 1)


//insert our properties into the payload
output.payload = 
{
    data: "https://t3alliance.org/wp-content/uploads/2019/01/nyanCat.gif",
    x: location,
    y: 20,
}

//send out to the next node
return output

On lines 5 – 10 we work with a ‘flow’ variable, this named variable ‘x’ sticks around with the flow and allows the function node to ‘remember’ a value between injections.
First we save the current value into the ‘location’ variable. Then we check to see if ‘location’ is greater than 128; if it is we reset it to zero.
Finally we save the new location back into the ‘flow variable’. The rest of the function node is pretty much the same as the last one.

Now with this code setup, your nyanCat should fly from one side of the screen over and over again. Remember to setup the inject node to repeatedly inject instead of just when you press the button.

Here is an export of the flow so far, so you can catch up if you’re lost:

[{"id":"7a5afae4.690634","type":"image-to-matrix","z":"93c88281.18b06","name":"","file":"","xOffset":0,"yOffset":0,"matrix":"9b09c013.e6c5b","zLevel":"","x":900,"y":360,"wires":[]},{"id":"b4672224.50062","type":"function","z":"93c88281.18b06","name":"NyanCat Function","func":"//create the message we'll output\nvar output = {}\n\n//setup our varaible for X\nvar location = flow.get(\"x\") || 0\n\n//check to see if we've went off the edge\nif(location > 128) location = 0\n\nflow.set(\"x\", location + 1)\n\n\n//insert our properties into the payload\noutput.payload = \n{\n    data: \"https://t3alliance.org/wp-content/uploads/2019/01/nyanCat.gif\",\n    x: location,\n    y: 20,\n}\n\n//send out to the next node\nreturn output","outputs":1,"noerr":0,"x":680,"y":360,"wires":[["7a5afae4.690634"]]},{"id":"56d87a3a.4542c4","type":"inject","z":"93c88281.18b06","name":"","topic":"","payload":"","payloadType":"date","repeat":"0.1","crontab":"","once":true,"onceDelay":0.1,"x":440,"y":360,"wires":[["b4672224.50062"]]},{"id":"9b09c013.e6c5b","type":"led-matrix","z":"","height":"64","width":"64","chained":"2","parallel":"1","brightness":"50","refreshDelay":"100","mapping":"adafruit-hat-pwm","autoRefresh":true}]

Animated Bubbles:

As a finishing touch we’ll be adding some animated bubbles to the mix. These will just be circles with random position, size, and color.
Just like with the image node, we’ll be using the object definitions from the circle node.

Here is the code for generating a static circle, that just sits in the middle of the screen looking pretty.

var output = {}

output.payload = 
{
    radius: 10, 
    rgb: "255,0,0",
    x: 64, 
    y: 34
}

return output;

Note that it looks almost identical to the original, if you inject this straight into a circle node it’ll plant a big red circle in the middle of the screen. If you setup the nyanCat properly it should be flying past it a couple of times a minute.

Next we can setup the random location and color, both pretty complicated functions so don’t be scared to just copy and paste them.

//generate a random number between 0 to max
function randInt (max)
{
    return Math.floor(Math.random() * Math.floor(max));
}

//generate a random rgb color, using the randInt function
function randColor()
{
    return randInt(256) + ',' + randInt(256) + ',' + randInt(256);
}



var output = {}

output.payload = 
{
    radius: randInt(10), 
    rgb: randColor(),
    x: randInt(128), 
    y: randInt(64)
}

return output;

The most important concept to grasp here, is the calling of user made functions between lines 19 – 22.
Other than that not much has changed.

For the best style I copy and paste this node a few times, into their own seperate circle nodes.
That way nyanCat can fly through 3 bubbles instead of just 1

And here is the exported flow, to catch you up to the final project:

[{"id":"7a5afae4.690634","type":"image-to-matrix","z":"93c88281.18b06","name":"","file":"","xOffset":0,"yOffset":0,"matrix":"9b09c013.e6c5b","zLevel":"","x":900,"y":360,"wires":[]},{"id":"b4672224.50062","type":"function","z":"93c88281.18b06","name":"NyanCat Function","func":"//create the message we'll output\nvar output = {}\n\n//setup our varaible for X\nvar location = flow.get(\"x\") || 0\n\n//check to see if we've went off the edge\nif(location > 128) location = 0\n\nflow.set(\"x\", location + 1)\n\n\n//insert our properties into the payload\noutput.payload = \n{\n    data: \"https://t3alliance.org/wp-content/uploads/2019/01/nyanCat.gif\",\n    x: location,\n    y: 20,\n}\n\n//send out to the next node\nreturn output","outputs":1,"noerr":0,"x":680,"y":360,"wires":[["7a5afae4.690634"]]},{"id":"56d87a3a.4542c4","type":"inject","z":"93c88281.18b06","name":"","topic":"","payload":"","payloadType":"date","repeat":"0.1","crontab":"","once":true,"onceDelay":0.1,"x":440,"y":360,"wires":[["b4672224.50062","e5b23895.437f38","9f3dc778.1d1e98","202d83ef.c75e8c"]]},{"id":"50105316.5a64dc","type":"circle","z":"93c88281.18b06","name":"","xPos":0,"yPos":0,"radius":0,"rgb":"0,255,41","matrix":"9b09c013.e6c5b","zLevel":"","x":890,"y":300,"wires":[]},{"id":"e5b23895.437f38","type":"function","z":"93c88281.18b06","name":"Circle Function","func":"//generate a random number between 0 to max\nfunction randInt (max)\n{\n    return Math.floor(Math.random() * Math.floor(max));\n}\n\n//generate a random rgb color, using the randInt function\nfunction randColor()\n{\n    return randInt(256) + ',' + randInt(256) + ',' + randInt(256);\n}\n\n\n\nvar output = {}\n\noutput.payload = \n{\n    radius: randInt(10), \n    rgb: randColor(),\n    x: randInt(128), \n    y: randInt(64)\n}\n\nreturn output;","outputs":1,"noerr":0,"x":660,"y":300,"wires":[["50105316.5a64dc"]]},{"id":"4313edf2.721a04","type":"circle","z":"93c88281.18b06","name":"","xPos":0,"yPos":0,"radius":0,"rgb":"0,255,41","matrix":"9b09c013.e6c5b","zLevel":"","x":890,"y":260,"wires":[]},{"id":"9f3dc778.1d1e98","type":"function","z":"93c88281.18b06","name":"Circle Function","func":"//generate a random number between 0 to max\nfunction randInt (max)\n{\n    return Math.floor(Math.random() * Math.floor(max));\n}\n\n//generate a random rgb color, using the randInt function\nfunction randColor()\n{\n    return randInt(256) + ',' + randInt(256) + ',' + randInt(256);\n}\n\n\n\nvar output = {}\n\noutput.payload = \n{\n    radius: randInt(10), \n    rgb: randColor(),\n    x: randInt(128), \n    y: randInt(64)\n}\n\nreturn output;","outputs":1,"noerr":0,"x":660,"y":260,"wires":[["4313edf2.721a04"]]},{"id":"4863e929.52f748","type":"circle","z":"93c88281.18b06","name":"","xPos":0,"yPos":0,"radius":0,"rgb":"0,255,41","matrix":"9b09c013.e6c5b","zLevel":"","x":890,"y":220,"wires":[]},{"id":"202d83ef.c75e8c","type":"function","z":"93c88281.18b06","name":"Circle Function","func":"//generate a random number between 0 to max\nfunction randInt (max)\n{\n    return Math.floor(Math.random() * Math.floor(max));\n}\n\n//generate a random rgb color, using the randInt function\nfunction randColor()\n{\n    return randInt(256) + ',' + randInt(256) + ',' + randInt(256);\n}\n\n\n\nvar output = {}\n\noutput.payload = \n{\n    radius: randInt(10), \n    rgb: randColor(),\n    x: randInt(128), \n    y: randInt(64)\n}\n\nreturn output;","outputs":1,"noerr":0,"x":660,"y":220,"wires":[["4863e929.52f748"]]},{"id":"9b09c013.e6c5b","type":"led-matrix","z":"","height":"64","width":"64","chained":"2","parallel":"1","brightness":"50","refreshDelay":"100","mapping":"adafruit-hat-pwm","autoRefresh":true}]

To import, copy it into your clipboard; and come up to the ‘import’  menu here:

 

More Ideas:

As long as the file is the right dimensions you can use any animated gif for the display, here is another file you can link into the project in this tutorial.
https://t3alliance.org/wp-content/uploads/2019/01/original.gif

 

Another good resource is pixilart.com

Here you can create your own pixel art, set the exact size in pixels (useful for making sure everything fits on the display) and even export animated gifs.
To create a gif, use the layer tools on the right. This button duplicates your current layer which is useful for making slight changes on the next frame.Then use the ‘Download/Save’ tool to export your file as an animated gif.

RPi Node-Red: Uploading pictures to Google Photos

This tutorial is being worked on – the google photos node may not be working at this time due to changes in the underlying repositories. 

Goal:

Upload pictures from a node-red flow into a Google Photos folder.

What you will learn:

How to install and configure the easybotics-gphoto-upload node, and use it in your flow.

What you need to know:

Getting started with node-red

Parts List:

  • A raspberry pi setup with node-red
  • Raspberry pi camera

Getting Started:

  • First connect your camera to your raspberry pi while the power is off.
  • Power on your raspberry pi and make sure the camera is enabled in the configuration menu.
  • If it is not already installed you need to install the gphoto-upload node, because of some peculiarities with dependencies this node has to be installed manually, the procedure follows:

Copy and paste, or type these lines into a terminal window. If typing press enter after each line, if pasting in the whole block you should only need to press enter once.

cd ~/.node-red
sudo node-red-stop
sudo npm i node-red-contrib-easybotics-gphoto-upload
sudo npm i axios@^0.16.2

Then once that install is done(1-5min) copy and paste/type this line and press enter

sudo npm i axios@^0.16.2

Wait for this install to finish(1-5min)

Restart Node Red – you could type Start Node-Red into the terminal or click on the node red program link

Open a web browser and view 127.0.0.1:1880 – If you already had the web browser open refresh the node red page.

Node usage:

Drag the upload-photo node in from the palette, and enter the setup menu by double clicking on it.

It’s definitely a good idea to setup an entirely separate google account for use with node-red, rather than pasting your actual username and password into nodes; no matter how trusted.

To allow node-red to login to gphotos without two factor authentication, you must setup unsecured access here: https://support.google.com/accounts/answer/6010255

 

In the settings page, the filename and album can be set. Usually you would inject a filename, but if you inject an empty message it takes the defaults set here.

 

To setup the camera node, just make sure it’s set to output the filename.
And that the Image Resolution is set to anything other than the maximum.

Notes:

If you take pictures at the rate of once every 2 minutes here are the days you can expect before the 8GB of free space on the SD card is filled up:

Quality = 80

  • 2592×1944 – 2.7MB per photo = 3.5 days
  • 1920×1080 – 1.2MB per photo = 7 days
  • 1024×768 – 546KB per photo = 17 days
  • 320×240 – 96KB per photo = 98 days

If you need more space to keep the SD card from filling up quickly a larger 64, 128, or even 256GB card will store many more photos before filling up – do some math to figure out how many photos each can hold.

RPi Airquality Station: Logging Airquality-Data to Grafana

Goal:

Log data to an online grafana database, and then view the resulting graphs and maps.

What you will learn:

  • Configuring easybotics air-quality sensors,
  • setting up the grafana logging node
  • viewing the logged data.

 

What you need to know:

Parts List:

  • Full easybotics air-quality station kit
  • Raspberry pi
  • Internet Connection

 

 

Setting up node-red:

Start Node-Red and navigate to 127.0.0.1:1880  using the web browser. Drag in all the air-quality nodes, and the BME node from the palette.
Select the C02 node, from the drop down menu select ‘Add new sensor manager’; the only configuration here is to switch the ‘Automatic C02 calibration’ to ‘Manual’.

By default the C02 Sensor will zero itself to the lowest C02 level it detects in a 24 hour period, pinning that value to 400ppm which is the atmospheric baseline. If your air-quality station is indoors, or in a crowded place this might lead to inaccurate data so you can change it here to manual.

Next select the PM concentration node, and Particulate node and select the Sensor Manager you made from the dropdown.

With this the config is far enough too start printing data to the led-matrix (if you have one); with the setup looking like this.

 

For the next steps you’ll need the influxdb username and password that should have been provided to you.
Select the ‘Publish to Influxdb’ node and enter your username and password here.
For the GeoHash field you’ll need to use a tool like this one: http://geohash.gofreerange.com Drag the map around, and click to generate different scale geohashes. Remember that the more digits you use the more specific of a location you’ll be providing to the T3 database.

Now you can link all the sensor nodes into the publish node like so:
The URL status below the node is where you can find your logged data, sadly you can’t copy and paste out of the status bar thing.  The node pushes the url out as a message, so using a debug node you can retrieve the URL and view your graphs.

 

RPi Node-Red: BME280 Temperature Pressure Humidity

Parts List:

BME280

Getting Started:

Setting up the Hardware

Setting up Node-Red

1) Start Node-Red and navigate to 127.0.0.1:1880.

If your Raspberry Pi does not have the node-red-contrib-bme280 palette, follow the instructions located here.

2) After installing the BME280 palette, place the Bme280 node onto the workflow.

3) What the Bme280 node does is read sensor data from the Bme280, and delivers that data as a payload.

msg = {
  _msgid: <node-red msg_id>,
  topic: <defined topic>,
  payload: {
    model: "BME280"  or  "BMP280",
    temperature_C: <float in celsius>,
    humidity: <float in %>, // Only present if model == "BME280"
    pressure_hPa: <float in hPa>
  }
}

 

As you can see, the payload contains attributes we will graph, including temperature, humidity, etc.

4) After seeing what the BME280 sensor sends to the Raspberry Pi, we are going to format it as a graph using Node-Red and Dashboard. Start by placing a change node from the functions section onto the workflow. The change node specifies the data field from the Bme280 node, in this case it is the temperature field.

5) Double-click on the change node to open the node configuration menu. Under Rules, you will see a field for payload and under that, another blank field. Click on the drop down button and select msg.

6) Now that we have specified the type to msg., we want to type in “payload.temperature_C”. If you look at the BME280 payload again, you can see that the field we typed in refers to that payload. Click Done once completed.

7) Drag and drop the chart node from the dashboard section onto the workflow.

8) Double click the chart node to edit the node. On the group field, click on the pencil button.

8.1) On the Tab field, click on the pencil button again.

8.2) From there, click on the Update button to return to the previous menu, then again to return to the original menu. This is to confirm the dashboard view settings. On the original menu, we can adjust the graph’s design, color, label, etc. Let’s proceed with labeling our chart “Temperature in C”. Click Done once completed.

9) To have the BME280 send data at an interval, place an inject node from the input tab onto the workflow.

9.1) Set the payload to number and enter 1 (means ‘on’ for the computer) in the field. Set Repeat to interval and set the interval time to any desired time (good to start at 5 seconds). Click Done once completed.

10) With all the nodes configured, connect all the nodes and hit Deploy.

11) Navigate to the Dashboard page to view your graph(s): 127.0.0.1:1880/ui/#/0

Node-RED Palette Installation (node-red-contrib-bme280)

1) Click on the menu icon in the top-right corner of the window and select Manage palette.

2) Navigate to the Install tab.

3) In the search modules bar, type in node-red-contrib-bme280 and click install.

4) An installation window will pop-up. Click install.

 

Next Steps:

 

RPi Raspberry Shake: Setting up a raspberry shake NOOBS image

Goal:

Create a  raspberry shake SD card used to setup a raspberry-shake for the first time

Resources:

SD card, SD card reader, Raspberry Shake NOOBS zip: https://gitlab.com/raspberryShake-public/raspShake-SD-img/raw/master/raspishake-release.zip?inline=false

Introduction:

The raspberry shake is mostly a hands-off piece of hardware, it just needs to be assembled, plugged in and left alone. Though you might need to setup an SD card if your kit didn’t come with one, or you need a replacement. Once the card is written, the raspberry shake will install and configure itself as soon as it’s plugged in.

Preparing the SD card:

The raspberry shake installer needs the SD card to be formatted with a specific type of file system called FAT32, usually if you buy a blank SD card it comes pre-formatted like this; but if you’ve already used it for something its not a sure thing.

We’ll use a piece of software called gparted to format the SD card, so the first step is to install gparted with the following command:

sudo apt-get install gparted

next, from the same terminal run gparted as root:

sudo gparted


When gparted is open go to the top right of the window, and select your SD card from the drop down; a good hint is to look at the size in GiB. I know my SD card is 8GIb so its probably the one labeled ‘7.4Gib’ not the 16 Gib one.
Make sure to never edit /dev/mmblk0/ because this is probably the card your raspbian is running on.

One you have the sd card open, right click on all the partitions listed below, and select ‘delete’. Gparted only applies operations in a separate step, so even though we deleted the partitions here it won’t actually do anything until we hit apply later.

 

 

 

 

 

After deleting the old partitions its time to make a new one, right click in the area we deleted the old partitions from, and select new. All the settings can be left at their defaults except for changing the file system to ‘FAT32’ as pictured.

Next the last step is to hit ‘Apply’ which is the green trick button in the bar next to where we selected the SD card. When it asks you if you’re sure click ‘Apply’.

Formatting the SD card will take a few seconds, after its done you can close gparted and remove and insert your SD card so rasbpian can re-detect it.

 

 

 

 

 

 

Setting up NOOBS:

For this step you need to download this zipfile: https://gitlab.com/raspberryShake-public/raspShake-SD-img/raw/master/raspishake-release.zip?inline=false

When your SD card is re-detected, open it in the file manager from the pop-up window.
Here I have the SD card open in the right window, and the raspberry shake zip open in the left

Open Action -> Extract, and copy the path for the SD card into the field here:
This extract step might take a while, after its done you can eject the SD card and you have a finished raspberry shake install image!

 

The next steps are actually setting up and connecting to the raspberry-shake, the indepth manual and tutorials for this process can be found here: https://manual.raspberryshake.org

RPi Node-Red: Minimal Selfie Station Tutorial

Goal:

setup the RPi’s software and hardware to create a minimal selfie station. Utilizing node-red, and a few components like the RPi camera and the led ring.

What you will learn:

Advanced node-red usage, using hardware with node-red, how to use the camera node.

 

What you will need:

RPi with node-red, RPi camera, button, and LED ring.

 

Introduction:

We will create a node-red flow to take selfies and display them right on the raspberry-pi desktop, using the LED-ring as a flash. To achieve this we will need to go through several steps: activate the LED-ring, take a picture, and open it on the desktop. But first we need to wire up the hardware.

 

Wiring:

Use jumper wires to hook up the LED ring to ground, 5v, and pin #18.
And the button hooks up to ground, 3v, and pin #12.

Setting up Node-Red:

start node-red, and navigate to 127.0.0.1:1880. Drag in a rpi gpio pin and hook it up to a debug node.

To configure the GPIO node, set the pin to GPIO: 12, resistor to pulldown.
You can also name the node ‘button’ to remind you later.


Now that we have the button configured, we can test it out. If you deploy the current flow you should be able to see output in the debug tab whenever you press the button.
Next we want to setup the flash ring, the led-ring is controlled by a neopixels node, so drag one of those in.
The only Setting that needs to set for this is the number of led in string, usually this should be 12.
You can rename this node to led-ring in the same menu.

Reading the led-ring help dialog, we find that it doesn’t  just take a generic ‘injection’ to turn it on; but a more complicated command that it reads.
For example: ‘1,12,0,255,0’ sets the entire ring red.
Broken down, this command means: ‘set leds #1 to #12 to the color ‘0,255,0’.  This color can further be broken down into ‘Red: 0, Green: 255, Blue: 0′

So if you use a generic ‘inject’ node into the led-ring node, you can light it up red with this string.

For the actual flash a flashing, multicolored timer, followed by a white flash is ideal, to do this we use timing nodes combined with change nodes.
The change nodes we will use look like this, they take an input; change the payload and then send it out.

For the flashing effect the nodes will have to be chained like this, with a delay node.

You can copy and paste the change node from earlier, and then go in and change the color code it sends.
This chain can be continued down the line; don’t forget that the color code for white is: 255,255,255.

One annoying quirk of the GPIO node, is that it sends a message when you press the button down and when released; so you could trigger this entire flow twice if you held the button down for a noticeable amount of time. The easiest way to solve this is to stick a rate-limit node after the GPIO node, like this.
A good default is 1 message per 5 seconds.
To do this, setup a ‘delay’ node with these settings, hooked just after the GPIO node.
Make sure to select ‘drop intermediate messages’

 

Next we need to setup the camera node, make sure the camera is plugged into the camera port on the raspi.
[image here]

You can setup the camera node like this:
The input wire activates the camera, and the output wire sends the filename when its done taking a picture.
Seeing as the camera sends a message when its finished taking a picture, we can use this to turn off the flash at exactly the right time.
When you copy and paste another change-node, set the color to ‘0,0,0’ to turn the led-ring off.

You can use a debug node to check the filename the camera is outputting too.

The final, and most arcane step is to open the image in a image-viewer. This is done with an ‘exec’ node you can drag in.
You can copy all these settings in, and hook it up to the ‘take photo node’

 

Leaving you with a hopefully functional flow that looks like this.

If you are a teacher and need a working demo of this project, you can download the image here: https://t3alliance.org/wp-content/uploads/2018/11/selfieImage.zip

Shortcuts:

if you get stuck in this tutorial, feel free to import the entire flow from here:

[{"id":"549d128c.d1e48c","type":"tab","label":"Flow 2","disabled":false,"info":""},{"id":"7a6088da.6f3e38","type":"camerapi-takephoto","z":"549d128c.d1e48c","filemode":"2","filename":"","filedefpath":"1","filepath":"","fileformat":"jpeg","resolution":"9","rotation":"0","fliph":"0","flipv":"0","brightness":"50","contrast":"0","sharpness":"0","quality":"80","imageeffect":"none","exposuremode":"auto","iso":"0","agcwait":"1.0","led":"0","awb":"auto","name":"","x":670,"y":520,"wires":[["226fa57f.d594ca","65312393.72d7ec"]]},{"id":"65312393.72d7ec","type":"exec","z":"549d128c.d1e48c","command":"DISPLAY=:0.0 gpicview","addpay":true,"append":"&","useSpawn":"false","timer":"","oldrc":false,"name":"Open image file","x":910,"y":600,"wires":[[],[],[]]},{"id":"226fa57f.d594ca","type":"change","z":"549d128c.d1e48c","name":"turn off LED ring","rules":[{"t":"set","p":"payload","pt":"msg","to":"0,12,0,0,0","tot":"str"}],"action":"","property":"","from":"","to":"","reg":false,"x":910,"y":520,"wires":[["e70bf46d.3df5b8"]]},{"id":"e01059e8.526678","type":"delay","z":"549d128c.d1e48c","name":"","pauseType":"delay","timeout":".5","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"x":720,"y":340,"wires":[["2b05a1af.2d162e","4a634559.5bed0c"]]},{"id":"1c398bbd.6ff2c4","type":"change","z":"549d128c.d1e48c","name":"Set LED ring = Red","rules":[{"t":"set","p":"payload","pt":"msg","to":"1,12,0,255,0","tot":"str"}],"action":"","property":"","from":"","to":"","reg":false,"x":920,"y":280,"wires":[["e70bf46d.3df5b8"]]},{"id":"2b05a1af.2d162e","type":"change","z":"549d128c.d1e48c","name":"Set LED ring = Green","rules":[{"t":"set","p":"payload","pt":"msg","to":"0,12,255,0,0","tot":"str"}],"action":"","property":"","from":"","to":"","reg":false,"x":930,"y":340,"wires":[["e70bf46d.3df5b8"]]},{"id":"cd35bff4.45e72","type":"change","z":"549d128c.d1e48c","name":"Set LED ring = Blue","rules":[{"t":"set","p":"payload","pt":"msg","to":"0,12,0,0,255","tot":"str"}],"action":"","property":"","from":"","to":"","reg":false,"x":920,"y":400,"wires":[["e70bf46d.3df5b8"]]},{"id":"4a634559.5bed0c","type":"delay","z":"549d128c.d1e48c","name":"","pauseType":"delay","timeout":".5","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"x":720,"y":400,"wires":[["cd35bff4.45e72","d6b433a.088ced"]]},{"id":"db82b2b9.cc94a","type":"change","z":"549d128c.d1e48c","name":"Set LED ring = White","rules":[{"t":"set","p":"payload","pt":"msg","to":"0,12,255,255,255","tot":"str"}],"action":"","property":"","from":"","to":"","reg":false,"x":930,"y":460,"wires":[["e70bf46d.3df5b8"]]},{"id":"d6b433a.088ced","type":"delay","z":"549d128c.d1e48c","name":"","pauseType":"delay","timeout":".5","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"x":720,"y":460,"wires":[["db82b2b9.cc94a","7a6088da.6f3e38"]]},{"id":"8c366b7d.3c3f18","type":"rpi-gpio in","z":"549d128c.d1e48c","name":"","pin":"32","intype":"down","debounce":"25","read":false,"x":400,"y":280,"wires":[["655eb18c.06cca"]]},{"id":"e70bf46d.3df5b8","type":"rpi-neopixels","z":"549d128c.d1e48c","name":"","pixels":"12","bgnd":"","fgnd":"","wipe":"40","mode":"pcent","rgb":"rgb","brightness":"100","gamma":true,"x":1180,"y":280,"wires":[]},{"id":"655eb18c.06cca","type":"delay","z":"549d128c.d1e48c","name":"","pauseType":"rate","timeout":"5","timeoutUnits":"seconds","rate":"1","nbRateUnits":"5","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":true,"x":600,"y":280,"wires":[["e01059e8.526678","1c398bbd.6ff2c4","4c17564c.dcd4c8"]]},{"id":"4c17564c.dcd4c8","type":"debug","z":"549d128c.d1e48c","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"false","x":920,"y":200,"wires":[]}]

 

RPi-NodeRed OLED IP Address Display

Please copy and paste the entire code block below into the node-red clipboard import window.

[{"id":"a1ae5e26.b300a","type":"String","z":"e0e44734.95d078","name":"OLED","display":"4fe1da30.5141a4","x":690,"y":220,"wires":[]},{"id":"60037f1d.3914b","type":"function","z":"e0e44734.95d078","name":"Format Message","func":"msg.payload={\nx:1,  \ny:50,\ntext:\"IP \"+msg.payload+\":1880\"\n}\n\nreturn msg;","outputs":1,"noerr":0,"x":520,"y":220,"wires":[["a1ae5e26.b300a"]]},{"id":"8971c892.2fa0f8","type":"change","z":"e0e44734.95d078","name":"IP","rules":[{"t":"set","p":"payload","pt":"msg","to":"payload[0].address","tot":"msg"}],"action":"","property":"","from":"","to":"","reg":false,"x":350,"y":220,"wires":[["60037f1d.3914b"]]},{"id":"974cfafc.e526d8","type":"inject","z":"e0e44734.95d078","name":"","topic":"","payload":"10","payloadType":"num","repeat":"60","crontab":"","once":true,"onceDelay":0.1,"x":90,"y":220,"wires":[["8c7a8725.02fa58"]]},{"id":"8c7a8725.02fa58","type":"hostip","z":"e0e44734.95d078","name":"Host IP","x":220,"y":220,"wires":[["8971c892.2fa0f8"]]},{"id":"8f95bb29.b800d8","type":"comment","z":"e0e44734.95d078","name":"Display IP address on the mini OLED display","info":"","x":300,"y":180,"wires":[]},{"id":"4fe1da30.5141a4","type":"oled-config","z":"","name":"","width":"128","height":"64","address":"3c"}]