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.

 

image_pdfGenerate PDFimage_printPrint

Rpi Airquality Station: Indepth Assembly

Goal:

Assemble an RPi Airquality Station from the parts kit, and turn it on for the first time.

What you will learn:

Special considerations for connecting sensors to the airquality hat, and how each part in the kit goes together.

What you will need:

Full RPi Airquality Station kit.

Getting Started:

Here are the sensors, circuit board, raspberry pi, led panels, and the piece of wood they all attach onto.

First we’ll line up the led panels. The led matrix’s we use have a chained model, which means data enters one end, and is transmitted down a connected line of led panels until every pixel has been set. The arrows printed on the panels and the wood indicate the direction for data flow. Data originates in the raspberry pi, enters the airquality HAT, and goes from right to left through the led panels.

Seeing as we’re putting the panels upside down for assembly the arrows will be slightly different though.

But once they’re flipped vertically the arrows will match up with the ones printed on the wood panel.

Seeing as data flows from one panel to another we need to connect the two using the ribbon cables.

The cable on the right will eventually be plugged into the airquality hat, but it’s less awkward if you wait until later.

 

Next we’ll attach all the sensors to the airquality hat. Here is what they look like laid out before being plugged in.

The PMS sensor is oriented with the intake fan south, as pictured, make sure the screw holes are facing the wood.

It’s vital to keep cable orientation in mind when plugging these in, the cables and connectors are not polarized so if you aren’t very careful you could easily fry your entire airquality kit by plugging something in backwards.

First we’ll plug in the PMS-5003 air particulate sensor.

For this sensor the wire needs to make ONE twist, meaning the connector is oriented backwards on the board compared to on the PMS. Double check the way the sensor box is oriented and the cable while connecting these.

 

Next we’ll connect the BME-280 sensor which is the simplest

For this sensor, the cable should be lying flat against the wood without any twists, and plug straight into the airquality hat. This is the only one of the three sensors where the cable doesn’t need to be twisted.

 

Next is the MHZ C02 sensor which can be the most confusing

First check the orientation of the sensor and the hat board like in this picture. This cable has to make exactly ONE twist between the sensor and the board. You can tell if the cable is oriented correctly when the colors are flipped vertically on one side from the other. Even though it is hard to spot the twist in the above picture, you can still tell that RED is on-top on the left, and BLACK is on-top on the right; indicating that the cable has indeed made ONE twist.

 

Finally double check all the sensors and their connections.

Attaching sensor hat to led matrix:

Then the power cables need to be attached from the sensor-hat to the led panels.

Next the power cables need to be attached from the sensor-hat to the led panels.

Pay close attention to the polarity, the ‘GND’ text should line up with the black wires.

Screwing Everything Together:

Now that the tricky part is done we’ll start screwing everything together.

To attach the display’s to the wood you’ll need these parts here:

First attach the standoffs to the panel like this.

Although in your case they’ll be all kinds of ribbon cables in the way and the two panels are plugged into each-other.

Then use the screws though the backside of the wood to attach them like this.

Make sure to tuck the wires neatly how you want them, because the only way to adjust this later will be to take the entire thing apart again.

The final ribbon cable from earlier, coming out of the side of the led matrix needs to be plugged into the airquality hat as shown.

 

The ribbon cables do have a correct polarity, but this is made obvious by the latch on the connector itself.

Next we’ll attach the board and the raspberry pi to the back-plate.

Here are the parts you’ll need.

The pins in the raspberry pi will naturally line up with the socket on the airquality hat as long as the screws line up.

Here is the order that the screws and standoffs go together

This animated gif shows the assembly order.
If it’s not animated you can click on it to open it.

First screw the mini standoffs through the backplate, then the raspberry pi nestles on-top. Next the longer standoffs screw on-top of the mini-standoffs. And finally screw the sensor hat on-top of everything else.

 

Mounting the Sensors:

Next we’ll mount the sensors to the backplate.

First is the PMS which is the only one of the three sensors that uses screws. Here is a picture of how the screws go into the sensor box.

There are pre-aligned holes and an outline where it should go.

The other two sensors are simply stuck onto the board with sticky strips.

Here’s how everything looks screwed and glued down.

First Power On:

Before powering on it’s important to double check all the connector polarities against this guide.

Now it’s time for the first time node-red and grafana setup!: https://t3alliance.org/rpi-airquality-station-setting-up-the-default-flow/

 

image_pdfGenerate PDFimage_printPrint

T3 Lesson 2: Growth Mindset

 

Very soon after introducing T³Alliance it’s time to set the tone for the entire program with the introductory lesson on growth and fixed mindsets.   As outlined in the video above, this fits into three components:  1.  Teaching about growth mindset; 2 Set the tone with an ice breaker; and 3. Build a robot with a brushbot.

Here is the link to the presentation  referenced above. The easiest way to get students on the same page is to share the Carol Dweck RSA Animate video.  The video will introduce the importance of how we speak to each other about our work.

You may want to look for some materials for an ice breaker.  These can be short pieces of rope that can be used to start off the program in the Infinite Loop Handcuff Solution: https://youtu.be/aiNl-EL6vfk.

Ready yourself for the brush bots with a plan for how you intend to allow for a competition to move forward.  It may be that you have some rulers that you tape down to the table in a format for tracks.  Here is a link to a resource that can be used with instructions for a brush bot competition

APPLICATION

Do a challenging activity together where students will be outside what they are comfortable doing.  Can they, under stress, manage their emotions and practice good feedback to themselves and others?  Do they give up?  After the activity, have them rate themselves with the attached EffortRubric

We believe in allowing curiosity, exploration and PLAY to happen.  It means kids have to feel safe to explore and have fun, even in the midst of failures.

 

ADDITIONAL INFORMATION

The term we now use is “neuroplasticity” to change the way our brains think.  

 

Imagine your brain is like a forest. You could potentially make a walk­ing path anywhere, but ahead of you is the road most often followed. The ground on this path is smooth and compacted, the brush has been cleared.

It’s easy to walk on, especially since you’ve walked it hundreds of thousands of times before. You walk on it automatically, unconscious of the decision to move in its direction rather than go, or be, another way.

If you want to change a belief or a habit or a physical sensation or negative self-talk, you must create a new path. You need to take a road less traveled.

You’ll need a machete to clear away the brush and branches. You’ll probably get scratched by spiky plants and twigs along the way. It will be hard.

You may ask yourself “Why bother? There’s a perfectly good path just over there.”

It’s easy to slip back into old ways of being.

That’s why most of all, it’s absolutely necessary to walk on this new path over and over and over again until the ground is smooth and compacted, until the old path has for grown over and the forest has reclaimed that space with a density of plants. Now the easy path is the one you created, consciously and with a healing intent.

Here’s a 5-minute video about Growth Mindset vs. Fixed Mindset.

Remind students that it’s only through failure that we gain our greatest knowledge.

 

REVIEW

Congratulations on taking the first step towards your students learning all they can and not limiting themselves or others.  Changing from a “fixed” to a “growth” mindset is not easy.  We often revert back to what we know when under stress.  Encourage your students to keep this in mind as you continue to reinforce positive feedback.

 

Other tools you may want to tap into are from Carol Dweck’s site:  https://www.mindsetkit.org/

 

 

 

image_pdfGenerate PDFimage_printPrint

T3 Lesson 1: Overview of your Program

Its the first day that you meet up with your students and they want to know what T³ Alliance is all about!  Specifically, what will this year, or summer, or semester look like for them?   To put this lesson together, you will need to plan a program based on what your individual situation looks like in your community and school.   This post will help you assess your situation and come up with a plan that you can share with students.

INTRODUCTION

The first day of a T³ Alliance class is exciting.  The students sitting before you may have applied, or they may have been selected to be there, but the hopeful look of expectation will be the same.   In teacher speak, this day is sometimes called the “honeymoon” period where students are well behaved and listen to what you have to share.  You make a first impression today that helps send the message that you are both excited and that you mean business!

This first lesson will likely take from 30 – 45 minutes and will meet these objectives.

Objectives for the student on this first day:
1. Be able to describe the goals of the T3 Alliance program.
2. Learn about some projects that have been done by other T3 Alliance programs and what might be done by your program.
3. Understand what the expectations will be for a member of this class or club.

If these are the objectives for the students, then you as an instructor need to feel comfortable in answering these questions.  Let’s start by unpacking each of these objectives.

  1. Goals of T³Alliance.

This is a presentation that can help you understand program goals.

  1. Projects that have been done by other T³ Alliance sites, and what might be done by your site.

This is a presentation that describes some projects that were done by T³ Alliance programs and some questions that you may want to consider as you outline possible community projects.

  1. Understand what the expectations will be for a member of this class or club.

For you to share expectations, you will need to consider the reality or context of your program within the UB program at your University and understand the expectations for the program on a national or programmatic level.

Here are some questions to consider with your director:  What will the teaching space or classroom space be like? What existing resources does your UB program have? What sort of student-teacher ratio can you expect?  What are some “shovel ready” community engagement projects?

Things that are not negotiable for being in the program are:  Having a growth mindset culture.  Being accountable to each other, the community members they work with, to you (the instructor) and T3 Alliance.

There will be times when you meet, expectations for students in the program, and a vision that you will share with them for how this program will open opportunities.  A general T³ Alliance presentation will be available that you can share.

APPLICATION

Teaching this!

Here are some resources that you will have at your disposal:

  1. Google slide presentations about T³ Alliance goals and example projects.  With a student focus!  You are welcome to copy and edit as necessary.
  2. Evaluation tools and expectations.
  3. List of questions to go over with the director.

Edit this:  Edit these to meet the needs of your program:

Prepare your presentation and practice what you are going to share.  As you think about teaching this, imagine having some time for students to brainstorm and talk about what they are excited to work with.   If possible, try to have your first T³ Alliance meeting in a room that has access to computers. The initial survey takes about 20 minutes.

REVIEW

As you finish the first day of presentation, consider sharing what you are going to presenting on the first day in the forum.

 

 

image_pdfGenerate PDFimage_printPrint

Lesson Sequence

Here is a guide to how you may choose to unpack your program in the first summer of working with T3 Alliance.  The same sequence could be used during an academic year, however, it may be more difficult to have students involved in community projects on a tight schedule.   If you are seeing this post as part of the community forum, please feel free to contribute with your suggestions.  Links will be added to this post for the various lessons referenced. 

Setup:  It would be ideal if you have a dedicated area where you can have your T3 Alliance program.  For many programs, this simply isn’t a possibility. Here is a sample flowchart of some of the questions you should consider.

Order of lessons:

  1.  Overview of your Program:

There will be times when you meet, expectations for students in the program, and a vision that you will share with them for how this program will open opportunities.  A general T3 Alliance presentation will be available that you can share.

  1. Lesson on Growth and Fixed Mindset:  

This lesson works well in three parts:  In the first part teach them about growth and fixed mindsets and then set the culture that this classroom is a safe learning environment where we use phrases that praise effort.  In the second part, we practice growth mindset with an icebreaker that causes students to reflect on how they think about hard situations. In the third part we build brush bots and let students compete.  

  1.  Build the raspberry Pi Kits:

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. Check that screws have been tightened.

  1. Computers, Raspberry Pi and the internet of things:

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… A discussion about the Internet of things (IoT) and how computer programs function will be valuable here.

  1. Scratch and basic programming:

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.

  1.  Node-Red and programming the GPIO pins:

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.

     7. Advanced Node-Red and the camera:  

This lesson will introduce more advanced features of Node-Red programming along with the installation of the camera.

  1.  Project – Make a Whoopee Cushion:

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.

  1.  Control your device from a distance – remoting and networking through a LAN:

This lesson introduces students to the idea that they do not need to be physically connected to a screen to “talk” to their Raspberry Pi.  

  1.  Setting up Node-Red to send to google photos:

This lesson will explore how to set up a flow to send photos to a google photos account using different triggers.

   11. The Design Thinking Process:

This Lesson will introduce the design thinking process and delve into the various communication skills that are within it.  The process will be introduced in relation to the IoT context that students have been exploring. The format of the mini-grant and the idea of deliverables will be discussed and modeled in role play scenarios.

  1. Basic videography:  

We assume for this lesson that students have some access to cameras, either the ones on their cell phones or ones that can be used within your UB program.  This lesson will focus on taking still photos and short videos that can be useful as part of a documentation video.

  1. Project – Build a selfie station:

For this project to be most impactful for the students, find someone from the community who would have a use for the project. Have them come in and share their problem with the class, and let the students interview them and follow the design thinking process.  I would put them in teams of 3 – 4 students, but it can also be done as one class project. Have them submit the grant, build and install it, and then have them be accountable for their work.   This project may take several days. To make it really impactful, have the community member present during the installation and provide positive feedback.

  1.  Sending data to a cloud service and building an analog scale with a servo:

This lesson introduces students to Thingspeak and other cloud services that collect information from a sensor.   Exploring the temperature, pressure, and humidity sensor can be a fun way to engage students in some hands on science experiments.  Blowing gently across the sensor can change the temperature and the pressure. This is connected with a lesson on the servo motor in order to set it up as scale so that it can become a dial.

  1.  Air quality sensors:

This can be turned into a project that meets a community need or it can be taught as a lesson on air quality.   A lesson on air quality and the ways that it is measured precedes the assembly of the air quality kit. A series of experiments that test various levels of air quality can be done as a class.  Ideally, students can work on this project in groups of 4 -5.

    16.  Controlling the LED Screen:

This lesson introduces students to a large matrix LED screen that often comes as part of the air quality kit.  A group of students can remote into the pi and edit the images and information displayed. The screen can become an important output device used in a variety of community projects.

  1.  Seismology and the Raspberry Shake:

This lesson introduces seismology,  the Raspberry Shake seismogram, and the cloud-based monitoring system that it connects with.   After learning about the physics of the seismogram, one will be set up in a classroom or a UB office and some experiments can be done to measure its sensitivity and how seismic waves travel.   The data from this shake is sent to a database where seismic events can be monitored in real time.

  1.  Communication norms and field trip:

This lesson introduces students to communication norms that are expected in your community and helps students see where technology is already being applied or could be applied.   Set up a field trip to a location where students can learn about some aspect of your community that’s worth them knowing about. This is an opportunity to teach students that they are good listeners and that they have the capacity to give back.

  1.  Design Challenge introduction:

This lesson introduces students to the T3 Alliance Design Challenge:  This is a commitment that involves your UB program supervising and overseeing their involvement in the project.  In general, a group of students is looking to tackle a problem with their technology skills and a small five hundred dollar materials budget from your program.  They need to follow the design thinking process, involve their community, and produce a one minute video describing the project.  A panel of judges will evaluate the submissions and T3 Alliance will recognize them in some capacity.

  1.  Local, regional, or national projects

Ideally, your students are working on a local project that has evolved and has brought on new challenges.  Introducing students to the T3 Alliance community forum will open new opportunities for collaboration on projects that either share data or share techniques for addressing issues.  

 

image_pdfGenerate PDFimage_printPrint

RPi Airquality Station: setting up the default flow

Goal:

Connect to the airquality station’s node-red instance, and configure the Grafana node.

What you will learn:

How to connect to the airquality station’s node-red, and detailed info on the Grafana node configuration.

 

What you will need:

An airquality kit connected to the internet, as per this tutorial: https://t3alliance.org/rpi-airquality-station-setup-and-access/

 

Connecting to Node-Red:

After you have connected your pi to the internet (https://t3alliance.org/rpi-airquality-station-setup-and-access/) you’re ready to setup the default flow to log data properly to Grafana.

If you’re using the pi locally (with a keyboard and display plugged into the air-quality station) you can just open the browser and click the Node-RED bookmark in the bar.  If you’re on a different computer, first find the IP address to use from the mini-oled on the airquality station, and then on your own computer enter as the URL. IP_ADDRESS:1880. Our airquality station was assigned the IP address of ‘10.71.0.196’, so to access our Node-RED flow I use ‘10.71.0.196:1880’.

Configuring the flow:

The default flow is pretty big, but not that complicated.
The part we are interested in is at the very bottom and looks like this.

 

 

 

 

 

 

 

All the sensor-nodes are being injected into a Grafana node, and then the Grafana node is being injected into a text node to print the url onto the display.
If you double click the Grafana node you’ll get a settings page like this.

The default settings do work, and do log your data onto a webpage where you can view graphs etc. However the default location is somewhere in the Arctic Circle, and you get a random jumble of numbers and letters for your Grafana url.

So the only two settings that need changing from the default are ‘Geohash’ and ‘Location Name’.
For the Geohash you can click the link in the settings page, or here: http://geohash.gofreerange.com/

Scroll around on the map, and zoom in to find your location, be mindful of how many digits you use. The geohash data will be public on the world-map. You can tell from how specific the location is from the size of the squares.
Looking at this shot of east Hawaii, ‘8e98’ is pretty good at showing where I kind of am on the island. ‘8e98n’ Shows what half of hilo-town I’m in. And then ‘8e98ny’ shows the exact area of streets I might be on. I wouldn’t recommend going further than ‘8e98’, or even ‘8e9’.

The second option is the location-name, this will allow you to use that name in the aqeasy url instead of the serial number that resides there right now. You can’t just use anything you’d like though. Location Names are not reserved, or restricted; so if you use something obvious like ‘School’, or ‘Outdoors’ you might find your data being overwritten by someone else in the future.
One other caveat is that data always sticks to the name it was uploaded with, so if you change your location name any data you recorded with the previous name won’t be on the graph with it.
So whatever name you chose now, the data on your graph will be from this moment on.

You can leave Location Name blank, the only downside is you have to use the serial-number url to look at your data.
I’m using easyboticsHilo, so now my data is visible here: g.aqeasy.com/easyboticsHilo

Remember to hit ‘deploy’ in the top right corner after you’ve finished making changes.

The data on Grafana won’t update visibly for a few minutes after you’ve set this up.

 

Viewing your data:

Once you have set your geohash in the flow and deployed, your data will start being updated onto the public world airquality map.

http://map.aqeasy.com

Your own data is viewable at the URL displayed by the default flow. If you change the flow so that it’s not displayed anymore remember that it’s being constantly outputted from the grafana node.

Here is what my data looks like at http://g.aqeasy.com/0e1c6c307

image_pdfGenerate PDFimage_printPrint

RPi Airquality Station: setup and access

Goal:

Connect your airquality kit to the internet to enable online data-logging. Either through WiFi or a wired LAN network.

What you will lean:

The best method of configuring your airquality kit depending on what hardware is available.

Parts List:

easybotics airquality kit

 

Introduction

The easybotics airquality has a default configuration that even logs your data to the grafana map, and gives you a url to access your graphs. The problem is you can’t change the node-red flow, update your geohash from the default (in the arctic circle), or create a custom-url for accessing your data. This tutorial will try and guide you through various ways to start using your airquality station to its full potential.

 

Option One: I have a puzzlePi kit

Congratulations, this is the easiest possible way to connect to your airquality kit.
First hook up your display, keyboard, and mouse to the airquality kit as pictured:

First you’ll need to setup your wifi country and timezone, the tool for doing this opens by default so it should be right there.

The most vital step of setup is getting the airquality kit onto your WiFi network. This can be accomplished with the wifi applet, here:

Next restart the pi or power cycle, when the flow starts up you should see an IP address on the mini oled display.
Now you can move on to the next tutorial: https://t3alliance.org/rpi-airquality-station-setting-up-the-default-flow/, you can even complete this tutorial using just the pi build into the device.

 

Option Two: I have a HDMI display and a keyboard/mouse

this option is actually identical to Option One, except instead of  using the puzzlePi’s display and keyboard you can use your own, scroll up and read Option One.

Option Three: I have a LAN network (simple)

If you have a LAN network that you’re PC is always connected to you can easily hook up your pi to that.
First just connect the LAN cable here:

Power cycle the airquality kit, and hopefully it should be assigned an IP that appears on the mini-oled.
Now you’re already to move-on to the next step. https://t3alliance.org/rpi-airquality-station-setting-up-the-default-flow/

 

Option Four: Use LAN to setup the WiFi

VNC server is enabled by default on the airquality station, so once you have a LAN connection as established in Option Three you can use this to setup the wifi.
Follow these instructions https://www.raspberrypi.org/documentation/remote-access/vnc/ to setup VNC client on your machine.
Remember that VNC is already enabled on the airquality station, so you can skip down to the ‘Connecting to your Raspberry Pi with VNC viewer’
VNC viewer can be downloaded for your personal computer here: https://www.realvnc.com/en/connect/download/viewer/

Remember that the IP address is listed on the oled display.

Once you have the desktop, you can use the same steps from option One to setup your wifi and move onto the next tutorial!
https://t3alliance.org/rpi-airquality-station-setting-up-the-default-flow/

image_pdfGenerate PDFimage_printPrint

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.

image_pdfGenerate PDFimage_printPrint

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.

image_pdfGenerate PDFimage_printPrint

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.

 

image_pdfGenerate PDFimage_printPrint

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:

 

image_pdfGenerate PDFimage_printPrint

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

image_pdfGenerate PDFimage_printPrint

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":[]}]

 

image_pdfGenerate PDFimage_printPrint

Traveling with the Raspberry Pi Box

If you are traveling with the raspberry pi box the most important thing you have to do is to take the screwdriver out of the box. Although if you check your box that doesn’t matter. Even if you take your screwdriver out you should expect some stops at the TSA because carrying a box around with a whole bunch of electronics is a little suspicious. The only other thing is that you should be pretty careful with your box but other than that you should be fine.    Safe Travels

 

image_pdfGenerate PDFimage_printPrint

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"}]

image_pdfGenerate PDFimage_printPrint

RPi Node-Red: Buzzer

Parts List:

Piezoelectric Buzzer

What is a Piezoelectric Buzzer?

A piezoelectric buzzer is a buzzer that is activated with an oscillating electric signal.  This means to produce a tone the buzzer must be turned on and off many times per second. The faster the the buzzer is turned on and off the higher the pitch is produced.  We can achieve this using a pulse width modulated signal (PWM). With a PWM signal we can specify the frequency in hertz (cycles per second).

Getting Started:

Setting up the Hardware

Using jumper wires connect the I/O pin of the buzzer to GPIO16, the GND pin to GND (ground), and the VCC pin to VCC.

Setting up Node-Red

Start Node-Red and navigate to 127.0.0.1:1880.  Drag two inject nodes and a Raspberry Pi output node into the flow area.

Double click on the Raspberry Pi output node to open its configuration menu.  Set the Pin to GPIO16.  Set Type to PWM output.  Set Frequency to 100 Hz.  You can Name the node anything, I chose “buzzer”.

Double click one of the inject nodes.  Use the dropdown menu to change the Payload data type number, type a 1 in the textbox.  Name the inject node “on”.

Double click the unmodified inject node.  Use the drop down menu to change the Payload data type to number, type a 0 in the text box.  Name this node “off”.

1 and 0 correspond for to values of a binary digit(bit) true and false, high and low, on and off respectively.  These are called Boolean values and are a fundamental data type in Computer Science.

Connect the inject nodes to the output node and then deploy the flow.

If everything has worked correctly pressing the “on” button should cause a sound to come from the buzzer and the “off” button should stop that sound.

image_pdfGenerate PDFimage_printPrint

Leveling The Nozzle

 

If you find one of your nozzles is at a different level than the other the easiest way to fix this problem is to either file or sand down the nozzle to the same level as the other

The best way to do this is to use sandpaper and level the build plate like normal except using sandpaper as the leveling paper but if you don’t have any sandpaper around then you can use a file

image_pdfGenerate PDFimage_printPrint