Our Ninja Foodi Air Fryer became our family’s go-to gadget during the stay-at-home order. When you order takeout, you probably noticed that the food isn’t the same. The plastic containers are nice for containing during transport, but they have a side effect of steaming your food. Pop your sides into an air fryer and they are back to their former glory… and sometimes even better. We also found a bunch a recipes made for the air fryer. This is going to change your whole existence and I never, ever use hyperbole.

A few years ago, I worked on a predictive maintenance project for duct fans. An air flyer is like a normal oven with the addition of a fan. There are fans in almost every major system and when they fail, the system that they are attached to will eventually fail. Fan blades can get bent, dusty, covered in food particles and oils, and damaged over time. The idea behind predictive maintenance is to predict the remaining useful life (RUL) of a machine and perform maintenance and repairs just-in-time. When applied at scale, predictive maintenance strategies provide a substantial return on investment. Studies show that condition-monitoring and predictive maintenance pays for itself and can be developed by anyone using MATLAB and the Predictive Maintenance Toolbox.

Check out my Condition-based Maintenance of a Duct Fan using ThingSpeak over at Hackster for a complete tutorial, video, and the source code. I adapted this project for an air fryer, but you could literally apply this technique to any machine that you want to monitor or to predict its remaining useful life. The idea is that fans and monitors vibrate when they are operational. As they degrade, the vibration changes over time. If you train a model with the data, you can use the model to predict the machine’s state, condition, and remaining lifespan. The predicted information can be used to change the maintenance schedule of the machine and optimize repair timing. It’s better to replace a part when the machine is scheduled to be down versus when the machine is in production.

I am using the Particle Internet Button for this project. The button gives me a nice convenient packaging of a Wi-Fi device for connectivity to ThingSpeak, an accelerometer to measure vibration, and LEDs for status lights.

The system uses ThingSpeak channels to store the vibration data, MATLAB / Predictive Maintenance Toolbox to build our machine learning model, MATLAB to analyze live data, and ThingSpeak to visualize our machine state and predictions.

Here’s an overview of the steps involved:

• Data Collection – Your first challenge is to collect data from the system. Attach the vibration sensor package to the machine, connect it to the network, and send the data to an IoT service like ThingSpeak.
• Data Parsing, Exploration, Feature Extraction, and Training – Now that you have data, you have to figure out what it all means. Use MATLAB, the Predictive Maintenance Toolbox, and the Statistics and Machine Learning Toolbox to parse the data, extract interesting features, and to train a machine learning model.
• Visualize and Report – Present your findings with charts and gauges. Use ThingSpeak Alerts to send automated email messages about the machine’s health.
• Profit.

Here’s what some raw data from air fyer looks like.

Vibration data is hard to interpret, but with machine learning, it’s possible to classify what the vibration data means and understand what the changes mean over time. You may even have noticed the sound of these appliances change over time. This is your brain picking up on the changes and telling you, “IT IS TIME TO CLEAN YOUR NASTY AIR FRYER.” Imagine a machine learning model always monitoring the vibration data and alerting you on the changes. Things will be working when they are supposed to be working.

Run two experiments with your fan and collect the data:

• Experiment 1: Simulating failure due to blocking the airflow (1000 data points) – Collect 1000 data points: 250 – OFF, 250 –ON, and 500 – BLOCKAGE
• Experiment 2: Simulating failure due to rotor imbalance (1000 data points) – Collect 1000 data points: = 250 – OFF, 250 –ON, 500 – IMBALANCED

When we explore the vibration data, you may notice some things:

• The variance of the data in the time domain increases as the fan is turned on and as the failure develops in both experiments.
• In the frequency domain for the experiment 1 data, the peak shifts from 30 Hz to 25 Hz.
• In experiment 2, the peak in the frequency domain remains at the same point but the amplitude at that frequency increases.

Using MATLAB’s built in Classification Leaner App in the Statistics and Machine Learning Toolbox makes it easy to train a machine learning model with your data.

When everything is running in operation, the system will monitor the vibration data, analyze using the MATLAB analytics that we developed in the tutorial, and predict the time to service. As you use appliances and machines they degrade over time. You don’t always need to clean and maintain. The trick is to do it when you need to do it before catastrophic failure… or going to Amazon and buying a new one.

If you are looking to try this out for yourself, check out the Condition-based Maintenance of a Duct Fan project published on on Hackster. We have included the source code for the device as well as the MATLAB code to make the system to work. This can be applied to other systems and the process applies to many applications of predictive maintenance. Now that you know that these techniques exist, you might be able to find some useful ways to apply them.

Apparently, I like connecting appliances to the internet.

The “Slashdot Effect” used to crush our homespun servers and render our projects useless for a period of time. Jason had the idea of moving the “control” part of our projects to the web. If all commands are routed to and from a web server instead of going directly to a device, then we could control which commands went through, secure the connections using SSL, create access lists, and change things on the fly. This idea became our obsession for over a decade with several patents, licenses, open source projects, and customers from all over the world to show for the effort. We still work on large-scale IoT, Internet of Things for short, projects and have helped companies of all sizes reduce costs, predict equipment failures, and bring about connected products that serve a purpose.

When I first heard about Twitter back in 2006, I thought this is a perfect idea for things. Why would a human want to post short statues? Devices have a lot to say. “The HVAC system just turned on.” “The conveyor is drawing 3.1 amps.” “SYSTEM FAILURE: Code 87643.” If a web application could capture these messages, then the messages could be used for analysis. Jason and I started ioBridge in July of 2008 and built a scalable out-of-the-box solution plus a hardware dev kit. The only issue is that we only knew 30 people that were interested in the aquarium project. We sent an email to all 30 people and one person named Pete purchased a dev kit. He built a monitoring system for large aquariums in the Baltimore area. The next wave of users and customers didn’t come until Stephen Myers created an interactive pet treat dispenser for his dog. Stephen didn’t have an aquarium, but he did have a dog. Everything is a remix. Stephen blogged about his project on December 3, 2008, and his project got picked up by “The Unofficial Apple Weblog” since he used the iPhone as the controller.

To demonstrate the idea for a “Twitter for Things” to investors, I created @MyToaster – a Tweeting Toaster that used our system to send status updates about whether or not it was toasting. I followed Stephen’s idea and blogged about the toaster with my article, “Social Networking for My Toaster” on December 8, 2008, and described in detail how to build your own connected appliance. A few days later, Priya Ganapati picked up the story of MyToaster and wrote an article for Wired Magazine. This project and our company… took off.

The toaster allowed me to start conversations with product manufacturers and designers that had ideas for new products. I worked on a number of consumer products and industrial systems that all use the same technology that Jason and I created. The Amazon Echo wouldn’t be possible if the Echo device had to understand all aspects of speech and user intents locally. The web allows Echo to tap into a huge data set that enhances its functionality. ThingSpeak is still going strong. You can still sign up today for a free, non-commercial account and join a community of over 350,000 developers around the world that are all learning about IoT and building new IoT applications.

Fast forward 10 years, and we are still working on the same thing, but the things are now factories, agricultural systems, windmills, and space probes. I was really happy when Katie Blackley from Pittsburgh’s NPR News Station asked me for an interview and an update regarding the MyToaster that started my journey. It has been 10 years and the toaster still works. It is now outfitted with a Particle Photon and uses the ThingSpeak web service to update its thousands of followers. I am glad she reached out to me as it caused me to reflect a bit about the journey and prompted me to share my history of the Internet of Things.

Appendix: MyToaster

MyToaster has been popular on its own for a long time. I have gotten requests to talk about the toaster on news stations, interviews for magazines, and to have the toaster brought to IoT conferences. Every trade show we did had MyToaster on display. The “touring toaster” was a stand-in and took a lot of abuse over the years.

Another significant event for MyToaster is when the Washington Post posted an infographic on “The Marriage of Appliance and Internet“.

They listed that MyToaster from 2008 was a significant event that shaped “Connected Appliances” and “Consumer Internet of Things Products”.

2008 – @mytoaster joins Twitter. It’s a toaster that Tweets. Hans Scharler rigged up his toaster to his Twitter so the appliance Tweets one of two things: Toasting or Done Toasting.

A man in Pittsburgh, Pennsylvania has rigged his toaster to tweet “Toasting” or “Done Toasting” with each use, and — despite the account’s lack of variety — has gained more than 2,000 followers.

In order to further connect us with our possessions, Scharler and his friend Jason Winters created a platform for developers called ThingSpeak— a sort of Twitter for things — that lets objects send messages, broadcast their location, graph their temperature, and more.

–Jacob Davidson / Time

“Tweeting appliances speaks to this whole ‘internet of things’ idea,” says Hans Scharler, a tech consultant who also writes comedy material. “If your appliances were outputting information, it can always go to a database. But we love to share information. So why not find a way to do that?” Scharler found online fame for his twittering toaster, whose tweets alternate between “toasting” and “toast is done.” @mytoaster has about 200 twitter followers.

–Priya Ganapati / Wired

CheerLights Introduction

Here’s a quick introduction to the CheerLights project for those who are new to the project. Imagine 1000’s of multicolored lights all around the world synchronized to one color. When one of the lights turns red, they all turn red. To control CheerLights, send a tweet to @cheerlights or include “cheerlights” somewhere in your message with the name of a color. This will cause a chain reaction and all of the CheerLights displays and apps will change their color to red.

ThingSpeak MQTT Service

CheersLights is powered by ThingSpeak IoT. And, this year, I am happy to introduce real-time CheerLights updates using ThingSpeak’s new MQTT service. Using the MQTT service by ThingSpeak, your CheerLights change instantly. ThingSpeak has posted an example that gets a Particle Photon connected to CheerLights using MQTT. The Subscribe to Channel Updates Using Particle Photon Client example shows you how to use a Particle Photon Wi-Fi board to subscribe to channel updates from the CheerLights channel. The program displays the color read from the channel on the built-in LED on the Photon board. You can subscribe to the channel feed or directly to the color field on the CheerLights channel.

Once you learn how to use the MQTT service from ThingSpeak, you can easily adapt it to your IoT project. This is a great way to have real-time control of a device or real-time monitoring of sensors.

If you want to follow the project and see what others are building, visit CheerLights.com or follow on Twitter.

I found a Robot Nightlight on Amazon and purchased it. This little robot is a great night-light and you can change the color using the included infrared remote control. To connect this light to CheerLights, I built an IR controller that is internet-connected using the Particle Photon. The Photon subscribes to the latest CheerLights color on ThingSpeak and transmits the IR code as if the button was pressed on the remote control.

To build your own CheerLights Robot, visit Nursery Hacks for the parts and code.

Features of IoT Debugger

• ThingSpeak Data Logger
• Particle.io Webhooks Manager
• Settings are saved in LocalStorage
• Built using HTML5, Bootstrap, and jQuery
• Open Source!

Demo and download the source code for IoT Debugger on GitHub.

Particle creates really powerful devices that are cloud-connected to Particle.io. They have the Photon and the Electron and the same code works with both. In my project, I use the Wi-Fi powered Photon, but the same steps would work with the Electron that uses 3G cellular data. I will be connecting the Particle devices to ThingSpeak – a data collection services with built in analytics and visualizations tools using MATLAB. The connection will happen securely from cloud-to-cloud.

Requirements

• Wi-Fi connected Particle Photon (or activated Particle Electron)
• Particle.io Build Account
• ThingSpeak User Account

Credentials

We need to gather some credential information before we can build out the rest of the project.

ThingSpeak

Go to ThingSpeak.com and Sign In. Select Channels and then My Channels. Create a new channel. Click on API Keys and note the Write API Key and Channel ID.

Particle

Go to Particle.io and Sign into Build. Click the gear icon in the bottom left corner of the IDE. This will open the Settings panel. Make a note of the Access Token. This will be used to create the webhook in a later step.

Setup the Webhook on Particle.io

In order to connect Particle and ThingSpeak together, we need to setup a webhook on Particle. This will make a secure connection from Particle.io to ThingSpeak so that data can be passed back and forth.

You have two options for settings up the webhook. You can use the Particle CLI Tools or IoT Debugger. I will document the steps for the IoT Debugger.

IoT Debugger

• Download a copy of IoT Debugger
• Open the index.html file in a web browser tab
• Select Particle
• Enter your Particle Access Token into the Access Token field
• Click on “Create Webhook”

In the Content (JSON) field, enter the following file:

{
    "event": "thingSpeakWrite_",
    "url": "https://api.thingspeak.com/update",
    "requestType": "POST",
    "form": {
        "api_key": "{{k}}",
        "field1": "{{1}}",
        "field2": "{{2}}",
        "field3": "{{3}}",
        "field4": "{{4}}",
        "field5": "{{5}}",
        "field6": "{{6}}",
        "field7": "{{7}}",
        "field8": "{{8}}",
        "lat": "{{a}}",
        "long": "{{o}}",
        "elevation": "{{e}}",
        "status": "{{s}}"
    },
    "mydevices": true,
    "noDefaults": true
}

Click “Save” to upload the webhook to your Particle account.

Program Particle Photon

Go back to Particle.io and select the device that you want to program. This example will send the value of the analog pin (A0) to ThingSpeak every 16 seconds.

#define publish_delay 16000
unsigned int lastPublish = 0;

void setup() {
}

void loop() {
    unsigned long now = millis();
    if ((now - lastPublish) < publish_delay) {
        return;
    }

    int value = analogRead(A0);
    Particle.publish("thingSpeakWrite_A0", "{ \"1\": \"" + String(value) + "\", \"k\": \"XXXXXXXXXXXXXXXX\" }", 60, PRIVATE);
    lastPublish = now;
}

Verify Connections

Go over to the new ThingSpeak channel that you created and see if data is being collected and displayed on one of your charts. You should see a new data point being added every 16 seconds.

MATLAB Visualization

Now that your data is on ThingSpeak you can see this data on ThingSpeak using the MATLAB Visualizations app. On ThingSpeak, select Apps and then MATLAB Visualizations. Click “New”, select “Custom (no starter code), and click “Create”.

Enter the following MATLAB code and click Run and Save:

readChannelID = 93156;
fieldID1 = 1;

readAPIKey = 'MCI6XM81ZFOY8UCE';

%% Read Data %%
[data, time] = thingSpeakRead(readChannelID, 'Field', fieldID1, 'NumPoints', 10, 'ReadKey', readAPIKey);

%% Visualize Data %%
thingSpeakPlot(time, data);

Make sure to customize the MATLAB code with your readChannelID and readAPIKey.