How do you use ThingSpeak?

Some people use ThingSpeak for monitoring machine processes. This allows them to share the data with potential customers and ensure the process is within control. There are over a million ThingSpeak channels representing a vast assortment of projects.  Some projects measure the temperature and humidity in one room, some projects include a global network of air quality monitors. You can send data to ThingSpeak from your devices, create instant visualization of live data, and send alerts.

What type of data is accepted by ThingSpeak?

ThingSpeak accepts strings, integers, decimal degrees, and any encoded data. ThingSpeak stores data as strings of up to 255 characters per field. ThingSpeak organizes data by channels, where a channel represents data from a given device or process. Each channel contains eight data fields, three fields for location: latitude, longitude, and elevation, and one extra field for a status report.  If you write a number into a field (integer or float), ThingSpeak will display the numbers in field charts on your channel view.

Is ThingSpeak free?

Yes, for non-commercial use. ThingSpeak has different license types for different intended uses. The free license has some restrictions. Purchasing a paid license allows a faster update rate and the creation of additional channels.  For more info, see How to Buy and the ThingSpeak FAQ.

How do you collect data from ThingSpeak?

Once your data is stored in ThingSpeak, you can retrieve your data from ThingSpeak from MATLAB, a REST API, or MQTT API.

Many devices can take advantage of the ThingSpeak library for Arduino and Particle devices. You can use the address bar in your web browser to test updating a channel via the REST API.

Use this format to update your field.

https://api.thingspeak.com/update?api_key=<YOUR_API KEY>&field1=<YOUR_VALUE>

If you have any questions for Christopher, myself, or the rest of the community, ask them at the ThingSpeak Community site.

Thanks to all of our users who keep collecting data, adding devices, and analyzing data on ThingSpeak! This is a huge milestone for all of us and you are making an impact on IoT all around the world.

To commemorate one million channels, Christopher saved the number of channels at the beginning of each year to an array and used MATLAB to fit a power function to the data. You can do this using a MATLAB Visualization in ThingSpeak. The fit parameters are a = 1693 and b=2.277 for the model shown here.

According to a Business insider article, there will be 25 billion IoT devices by 2025. If the present rate continues, at least .1% of those devices can be on ThingSpeak by 2024 when we reach 2.5 million channels!

Here’s some MATLAB code to generate this plot and estimate the number of the ThingSpeak channels in the future.

% Gather data
dates=2015:2020;
absYears=dates-2014;
numChan=[22155,75957,208835,394780,666479,1000000];

% Plot the data
plot(dates,numChan,'r*-','linewidth',3);
xlabel('time');ylabel('Number of Channels');title('1 Million Channels!');
[xData, yData] = prepareCurveData( absYears, numChan );

% Set up fittype and options
ft = fittype( 'power1' );
opts = fitoptions( 'Method', 'NonlinearLeastSquares' );
opts.Display = 'Off';

% Fit model to data
[fitresult, gof] = fit( xData, yData, ft, opts );
hold;
extendRange = 2015:2025;
plot(extendRange,fitresult(extendRange-2014),'r--');
yline(2.5e6,'b','LineWidth',3);

We wanted to thank you again. We look forward to the next million channels and supporting your IoT journey. Let us know in the comments what you are doing or planning to do with ThingSpeak and what functionality that will help you along the way.

The ThingSpeak team has created a new example that shows you how to leverage The Things Network and build an agricultural data application using ThingSpeak. The sensors send data to The Things Network, which is then forwarded to ThingSpeak for collection, analysis, and visualization. Here’s what the project view on ThingSpeak looks like.

To build a soil moisture sensor device for The Things Network, you need use an Adafruit Feather M0 RFM95 LoRa Radio (900MHz), an Adafruit Ultimate GPS FeatherWing, a SparkFun Soil Moisture Sensor, and a DHT22 temperature and humidity sensor. Once you have the device put together and programmed, you can use this device to measure soil moisture, temperature, humidity, and its location.

Check out the full Collect Agricultural Data over The Things Network example at the MathWorks Documentation site.

What is “healthy” air quality?

Good or moderate air quality is when the Air Quality Index (AQI) is 100 or less. AQI is a relative measurement of five common air pollutants: ground-level ozone, particle pollution, carbon monoxide, sulfur dioxide, and nitrogen dioxide. A high AQI indicates a higher level of pollution and is considered unhealthy over 100.

Air Quality Sensors

We have installed a PurpleAir sensor at the MathWorks Apple Hill campus in Natick, MA. PurpleAir sensors use laser particle counters that provide an accurate and low-cost way to measure smoke, dust, and other particulate in the air. The data from our air quality sensor is available on a public ThingSpeak channel.

PurpleAir produces an interactive map using the air quality data from their sensors deployed around the world. Among other applications, the data is used by researchers to understand the effects of forest fires on air quality.

Air Quality Analysis using MATLAB

On File Exchange, we have posted our MATLAB functions used to analyze the air quality data collected by ThingSpeak. The MATLAB code helps preprocess the sensor data, provides functions to classify the data, and provides functions for visualizing the processed air quality data. The MATLAB visualizations are added to a ThingSpeak channel dashboard so you can see the current air quality near you. The MATLAB analysis code calculates the AQI using the definitions from the United States Environmental Protection Agency (EPA).

You can build a data analysis dashboard on ThingSpeak using publicly available data and MATLAB. This project it makes it easy to explore IoT data analysis using MATLAB to preprocess and visualize data without having IoT hardware.

Download the code from File Exchange and follow along with our video tutorial.

Setting up the Sensor

This project uses the ESP-based NodeMCU as an IoT gateway to forward sensor data to ThingSpeak. The NodeMCU is essentially a microcontroller and a Wi-Fi device that costs less than $10 US. The humidity sensor that is used in this project is the DHT11. This a very common sensor used to monitor temperature and humidity. The sensor either comes in a 4 pin or 3 pin package. The NodeMCU is programmed with the Arduino IDE using the code in Douglas’ tutorial or GitHub.

Using ThingSpeak Metadata

Douglas uses the metadata setting within a ThingSpeak channel to store condition ranges. This allows you to adjust settings in your online analytics code without redeploying new code. Each ThingSpeak channel has a metadata setting. You can store arbitrary text data that can be used in your MATLAB Analysis code. To load your channel’s metadata into MATLAB, use the webread function and add metadata=true to the ThingSpeak API Read Data request.

indoorChannelData = webread(strcat('https://api.thingspeak.com/channels/', ...
                                    num2str(indoorChannelID), ...
                                    '/feeds.json?metadata=true&api_key=', ...
                                    indoorChannelReadKey));

Using MATLAB for Condition Monitoring

Douglas uses MATLAB on ThingSpeak to determine the proper condition. This is a common requirement in complex IoT systems. This example could be a good starting point for building a condition monitoring system for industrial maintenance applications. You use MATLAB to determine the target humidity using a polynomial fit over the lookup data.

lookupFit = polyfit(humidityLookup(:, 1), humidityLookup(:, 2), length(humidityLookup) - 1);
optimalHumidity = polyval(lookupFit, curTempOut);

humidityDiff = curHumidity - optimalHumidity;

Using IFTTT for Alerts

Often you want to get notifications when a certain condition is met. Douglas shows you how to use IFTTT to send push notification directly to your phone. In this project, MATLAB is determining the condition and then interfaces with the IFTTT API to send the push notification. To send push notifications via IFTTT, use the webwrite function in MATLAB.

webwrite(strcat('https://maker.ifttt.com/trigger/', makerEvent, ...
                '/with/key/', makerKey), ...
                'value1', stateMsg, ...
                'value2', char(timeSinceChange, 'hh:mm'));

All of the MATLAB code can be deployed on ThingSpeak and scheduled to be executed periodically without having this on your desktop computer. The complete Smart Humidity Sensor project tutorial is available on Hackster.io. Feel free to discuss on the MATLAB Maker Community.

A storm undergoes bombogenesis when its central low pressure drops at least 24 millibars in 24 hours, according to the National Oceanic and Atmospheric Administration (NOAA).

At the MathWorks headquarters in Natick, MA we have a weather station sending data to ThingSpeak for the past several years. Here’s what the weather station looks like on a better day.

Not many interesting events emerge from the data, but with something called a bomb cyclone, Rob Purser decided to take a closer look using MATLAB. Our weather station on ThingSpeak channel 12397 collects temperature, humidity, and pressure data. By taking a look at this MATLAB plot of the pressure analyzed over 24 hours, you will see the pressure drops at least 24 millibars in 24 hours and in fact over 40 millibars. This storm definitely fits its name of explosive cyclogenesis.

Have a look at the raw data from ThingSpeak and see if you can determine the bomb cyclone event. In MATLAB, use thingSpeakRead via the ThingSpeak Support Toolbox. We documented the process of analyzing the weather station data using MATLAB on Hackster.io. Just follow the steps using MATLAB or MATLAB Online, to discover some interesting results.

Stay warm.

Marcelo has put together a great tutorial that uses ThingSpeak in the middle to collect data from sensors and then display the sensor readings on a custom Android app running on a mobile phone. He uses the MIT App Inventor to create a custom Android app to see the sensor data and status of the system. This project uses easily accessible hardware to build a proof-of-concept IoT system to monitor air temperature, humidity, soil temperature, soil humidity, and luminosity. Other people could modify this project with different sensors or actuators and build something for their own purposes or build a prototype for your next meeting at work.

Check out the full project tutorial on Arduino Project Hub and Instructables. Marcelo provides all of the parts, code, and instructions to make your own prototype IoT system monitored and controlled by a mobile app.

Naman uses an Arduino for processing the heartbeat data and turns the data into heartbeats per minute. Then, periodically, the device sends the data to ThingSpeak for data storage and data analysis using MATLAB. The heart rate monitor is connected to the internet using DFROBOT’s ESP8266 Wi-Fi Bee. The Wi-Fi Bee turns serial data-to-Wi-Fi.

This heart rate monitor sensor is a pulse sensor which is developed based on PPG techniques. This is a simple and low-cost optical technique that can be used to detect blood volume changing in the microvascular bed of tissues. It is relatively easy to detect the pulsatile component of the cardiac cycle according to this theory.

To build your own, check out Naman’s tutorial on either Hackaday or Hackster.

The tide height is calculated using an ultrasonic level sensor. This measurement is taken periodically and then sent to ThingSpeak, an IoT analytics cloud platform by MathWorks, using a cellular modem. The system can easily be adapted to collect data about any environmental system such as greenhouses or oyster farms.

Once you have the data in a ThingSpeak channel, you use MATLAB to preprocess and clean up the data. The raw data some times has extraneous values caused by environmental factors such as lighting, cabling, and electrical interference. Sometimes, you have missing data caused by connectivity issues. It is important to clean up the data before you use the data in your analysis.

To predict future tide levels and send alerts when the tide is rising or falling, we use the MATLAB Analysis app on ThingSpeak. With MATLAB, we can use historical data to make a prediction about the future tide levels. This predicted tide level can be used to help schedule a boating trip or plan for a water surge after a storm.

Tide Alerts

Remembering to check the tide level when fishing or lazing on the beach is not particularly convenient. A much more useful approach is to have the system send a message when the time has come to pack up and start heading back to the dock. The timing of the alert depends on how much water depth is needed by a particular boat. Larger boats need higher water levels in order to move without getting stuck in the mud. One way to send alerts is to use ThingSpeak and MATLAB to detect changes in tidal height and send alerts.

Conclusion

Developing a tide monitoring system provided accurate tide level measurement and tide level prediction, with the added ability to send alerts. Robert has been able to avoid being stuck in the bay by providing enough time to get back to his dock using this system. This project also serves as a useful approach to solving many data-driven puzzles by having a reliable way to collect, analyze, and act on data. Using MATLAB, the accuracy of the tide levels improved by understanding the proper tide levels at a specific location and when the tide levels will change. If you used the general tide forecast, you would have to account for several inches of tide height difference.

Resources

• Developing an IoT Analytics System with MATLAB, Machine Learning, and ThingSpeak – MathWorks Technical Article by Robert Mawrey
• Measure and Analyze Tide Levels with ThingSpeak and MATLAB – Hackster tutorial
• TideAlerts.com – Robert’s website dedicated to the exploration of tides

The ThingSpeak team at MathWorks is excited to announce Bulk-Update! This new ThingSpeak feature is targeted at IoT devices trying to optimize battery use by allowing the device to update a lot of data at once. To help you get started with bulk-update, we have written examples for Arduino, ESP8266, Particle Photon, and the Raspberry Pi 3.

Once your data is on ThingSpeak, it is easy to analyze using the MATLAB Analysis and Visualization apps within ThingSpeak, MATLAB Online, or Desktop MATLAB. To read data from ThingSpeak into MATLAB, use the ThingSpeak Support Toolbox and the thingSpeakRead command. We have released documentation and examples to help you get started with bulk-update on ThingSpeak.

Resources for Bulk-Update

• ThingSpeak Documentation for Bulk-Update
• Continuously Collect Data and Bulk-Update a ThingSpeak Channel Using an Arduino MKR1000 Board or an ESP8266 Board
• Continuously Collect Data and Bulk-Update a ThingSpeak Channel Using a Particle Photon Board
• Continuously Collect Data and Bulk-Update a ThingSpeak Channel Using a Raspberry Pi Board
• MATLAB thingSpeakRead Documentation
• ThingSpeak Support Toolbox for MATLAB
• MATLAB Online

My process of smoking meat, cheese, or even ice cream is to monitor only the meat temperature and the internal temperature of the smoker. When I finish a cook, I go back and try to learn from the data. I do not attempt to control the smoker using the Internet of Things, I use IoT to collect the data with ThingSpeak, analyze the data with MATLAB, and apply the insights to the next cook. The best advice that I have been given is to not change too many variables. Stick with simple rubs, the same charcoal, the same wood, the same cuts of meat, etc. Only change one variable for one cook. It takes years of trial and error before you get great at BBQ.

With the help of ThingSpeak and MATLAB, I can help you understand one of the more frustrating parts of smoking meats… the stall! The stall is a period of time where what you are cooking does not seem to be increasing in internal temperature. I used to panic during the stall and mess with the temperature by adding more charcoal or turning the vents. Overtime, I realized this is normal. No reason to panic.

Cooking is taking something cold and getting its internal temperature up to a safe level. Everything that you cook has a different target internal temperature, but generally the sweet spot is 190-205F. Smoking is about low and slow cooking. This means that you are trying to raise that internal temperature slowly with a low temperature. I use a cook temperature of 230-250F. This means that smoking takes a lot of time to properly cook. In some cases, this is two hours per pound. Things don’t change much minute to minute in a BBQ pit, so you can collect data every few minutes and still have an accurate picture of what’s happening.

Collecting Data

First, I set up a ThingSpeak channel to store my temperature data. One field is for the smoker’s temperature and field two is for the internal temperature of what I am cooking. To get the data, you have many options. I did a quick search around the internet and discovered hundreds of Arduino and ThingSpeak projects to get data from a smoker. In general you need two temperature probes that can take the heat of the smoker, connectors, an Arduino with Wi-Fi like the MKR1000.

Analyzing the Temperature Data

The first step is to read in the temperature data using MATLAB that was collected by ThingSpeak. Data on ThingSpeak is stored in a channel and identified by a channelID. If you have a private channel, you will need to supply a Read API Key to get access to the data.

smokerTT = thingSpeakRead(279400,'ReadKey','9AYZQDT1XFDM98FW','OutputFormat','timetable','NumPoints',115);

Sometimes the data from your temperature probe is noisey. This means the value that the temperature probe reports is sometimes higher or lower than the actual temperature. If you take a few samples and take a median, you get a consistent result. In MATLAB, I use smoothdata to take a moving median of my time-series sensor data.

smoothSmoker = smoothdata(smokerTT);

After I clean up the data, I want to visualize it and to see what happened. This is a good time to learn how long things actually take, so on your next cook you budget the right amount of time and don’t rush any phases.

plot(smoothSmoker.Timestamps, smoothSmoker.Variables);

I can use this data to determine how long the total cook will last and even set alerts using ThingSpeak. I tend to watch the smoker and tend the fire.

Results

After a lot of research, I discovered what the stall is doing and why it is important to keep your patience and push forward. This is starting to sound like a metaphor for life. According to Prof. Greg Blonder, “The stall is evaporative cooling”. Prof. Greg is a physicist, entrepreneur, former Chief Technical Advisor at AT&T’s legendary Bell Labs, and regularly contributes to AmazingRibs.com. He likes to bust myths about barbequing and help us understand the thermodynamics of cooking. You are heating the meat slowly, but the moisuture in the meat is evapotaring at the same rate. This effect causes a stall in the temperature rise. The temperature of the meat will go up when the moisture is depleted. The stall is important to the cooking process and leads to something called the bark. This is an outer layer of the meat that is slightly thicker and less tender than the rest of the meat, but traps in lots of flavor and adds to its complexity. So, don’t rush during the stall. Keep the smoker temperature constant – avoid the temptation to turn the heat up to get through faster. And in the end, enjoy some well made BBQ with friends and family over the summer weekends and holidays.

Anders was determined to measure sound from over 20 demo stations at the same time and figure out who the the winner is. This turns out to be a complicated challenge and he used our tools such as MATLAB, Simulink, and ThingSpeak, to produce some interesting results. Here’s what the raw data looks like from just five sound sensor nodes at the demo stations.

The sensor nodes uses the Arduino Nano devices because they’re small, low-cost, and Simulink has an Arduino support package. Arduino Nano’s both low cost and energy efficient which is great, but it doesn’t have Wi-Fi. They connect the sensor nodes to an Internet-connected Raspberry Pi using an RF mesh network with the nRF24l01+ radio. The RF24 solution is both very cheap and energy efficient, which is valuable if you’re running them with battery power. Simulink Coder has a Raspberry Pi Support Package which simplified the workflow.

When you follow the tutorial, you are going to learn many things and experience their analytic workflow as they decide how to develop an algorithm to normalize sound levels, determine which data to send to ThingSpeak, and build visualizations to see the results of the project.

Anders also shared a library on File Exchange that allows users to communicate with RF24 chips on Raspberry Pi and Arduino boards. The library relies on the RF24Mesh library, and has S-functions that interact with the classes there. The File Exchange submission includes an example for the Arduino to read sensor data from a temperature sensor and sends it to the gateway Raspberry Pi and then sends the data to ThingSpeak. In order to download the File Exchange, you need to sign in with your MathWorks account. This would be the same account that you use on ThingSpeak.com.

Visit ThingSpeak Tutorials, to see the complete tutorial for Building a Dynamic and Self-organizing Network of Devices.

Statistics and Machine Learning Toolbox

Signal Processing Toolbox

When you are logged into ThingSpeak using your MathWorks Account, you can use functions from the following toolboxes if you are licensed to use them:

With multiple sensors around my house or office, I want to be able to send data to multiple ThingSpeak channels. But, when I want to perform data analysis, I have a hard time working with data from multiple channels. The channels do not have the same time stamps and are out-of-sync with each other.

With R2016b of MATLAB^®, I am able to use the new timetable data container. Once the data is a stored as a timetable, I can perform powerful operations such as retime, synchronize, and rmmissing.

In this example, I have two sensors outside of my office here in Natick, MA. One sensor is a temperature sensor that is sending data to ThingSpeak channel 163540. My other sensor is writing humidity data to channel 163545. Both channels are public. My goal is to plot temperature versus humidity over one time series. To accomplish this, I will use timetable and synchronize inside of a new MATLAB Visualization on ThingSpeak.

% Read from the temperature channel
temperatureTT = thingSpeakRead(163540,'Fields',1,'NumPoints',100,'outputFormat','timetable');

% Read from the humidity channel
humidityTT = thingSpeakRead(163545,'Fields',1,'NumPoints',100,'outputFormat','timetable');

% Synchronize two timestables and fill in missing data using linear interpolation
TT = synchronize(temperatureTT,humidityTT,'union','linear')

% Plot Temperature and Humidity over time
plotyy(TT.Timestamps,TT.Temperature,...
       TT.Timestamps,TT.Humidity);
        
title('Temperature and Humidity Synchronized From Two Channels')
xlabel('Temperature and Humidity in Natick, MA')
legend('Temperature','Humidity')

The first part of the script reads in ThingSpeak data from two different channels and stores the data in two timetables. Once the data is stored in a timetable, I am able to take advantage of synchronize. With synchronize, I can combine both timetables with one time series and fill in missing data using linear interpolation. This results in a plot that shows my data over time without any missing data. To create the plot, I signed into ThingSpeak, selected Apps, and created a new MATLAB Visualization with my MATLAB code.

All ThingSpeak users are able to try this example or explore the other new MATLAB features directly on ThingSpeak. I will leave my temperature (163540) and humidity (163545) channels public, so you can try out timetable example without having to connect devices to ThingSpeak.

Chris’ home solar water heating system is an example of an IoT application that uses multiple sensors to collect data about a physical system.  Chris’s water heater measures ambient temperature, stored water temperature, collector temperature, and pump speed. All of this data gets collect by ThingSpeak and stored in Channel 29633.

On days when the stored water temperature exceeds 50°C (122°F), there’s no need to use other methods to heat the store of water to a useful working temperature.  The pump should turn on only when the collector temperature is greater than the temperature of the stored water tank. If the pump turns itself on when the collector is cooler than the stored water temperature, valuable heat is lost from the stored water tank. Chris wants to be alerted of this condition, so that he can adjust the controller settings and increase the efficiency of the system.

IoT systems like Chris’ solar water heating system, typically gather large amounts of data but often the real interest is in events that occur infrequently. The ability to take action when these infrequent events occur is important and requires a mechanism to detect such an event and launch an action. We are going to use the data collected by the solar water heating system stored in the ThingSpeak Channel 29633 and use the MATLAB Analysis app to detect a condition and alert him using Twitter.

MATLAB Event Detection

To detect an erroneous pump behavior event, create a new MATLAB Analysis on ThingSpeak with the following code:

% Read data from fields 1, 2, and 3 from channel 26633.
% Field 1 represents the stored water temperature
% Field 2 represents the collector temperature
% Field 3 represents the state of the pump - on or off
[data, time] = thingSpeakRead(29633, 'Fields', [1, 2, 3]);

% Assign measurements to individual variables
storeTemp = data(1);
collectorTemp = data(2);
pumpState = data(3);

% Check if collectorTemp is less than storeTemp
isCollectorCooler = collectorTemp < storeTemp;

% Identify if pump is on while the collector is cooler.
% We apply a logical AND operation to detect an event only when collector
% is cooler than store temperature and the pump is on.
eventDetected = isCollectorCooler & pumpState

Press the ‘Run & Save’ button to save the MATLAB Analysis App. The code above sets eventDetected to 1 every time the collector temperature is cooler than stored temperature and if the pump is on. Now that we can detect the event, we need to set the MATLAB App to be run on a schedule. To do this, we will setup a TimeControl to run our MATLAB code every 5 minutes.

Sending Alerts using MATLAB Analysis

So far, we’ve created a MATLAB Analysis to detect events in the data being collected in the solar water heater data channel. We associated our MATLAB Analysis code with a TimeControl to have it run every 5 mins to check for our event of interest. To receive a notification via Twitter when the pump is on incorrectly, we can use MATLAB Analysis to send a Tweet.

First, you need to link your Twitter account to your ThingSpeak account. Then, add the following lines of code at the end of your MATLAB Analysis code to send a Tweet when an event is detected:

If eventDetected
webwrite('http://api.thingspeak.com/apps/thingtweet/1/statuses/update',
'api_key', '<ThingTweet_APIKey>', 'status', 'Alert! Solar pump error!')
end

Be sure to replace <ThingTweet_APIKey> with your ThingTweet API Key.

If the solar water heater pump turns on at the wrong times, you will get a Tweet to let you know!

Next Steps

This example shows you the power of some of the ThingSpeak apps that we make available to you to experiment with. The MATLAB Analysis app is really powerful and can be used to detect events in your data and send alerts. MATLAB Analysis can be used for all sorts of calculations and orchestrations of different web services. We could have also used MATLAB to control the pump.

Feel free to try this example and take it further…

• Reading data from fields in different channels
• Combining data from fields in a channel and data read from a website such as a weather station or weather forecast.

What will you MATLAB?

You only need a few things to build a light and temperature sensor that writes data to ThingSpeak:

• Arduino Zero or Uno Board
• Arduino Wifi Sheild 101
• Photocell
• Temperature Sensor (This example uses a TMP36)
• 10K Ohm Resistor

Once you have the circuit built, you create a ThingSpeak channel, connect the Arduino WiFi 1010 to your Wi-Fi network, and install the source code from the tutorial on the Arduino.

Data is now being sent to your ThingSpeak Channel. Go to your channel to see two charts of the light and temperature data. To take the project a step further, go to ThingSpeak Apps and use MATLAB to analyze and visualize and trigger actions from the data.

[via Arduino.cc]

We write the temperature and humidity values from the weather station to a ThingSpeak channel. At some point in the project, we started to wonder about dew point calculations. We wrote some MATLAB code that combined the temperature and humidity to calculate dew point. I did this using the ThingSpeak app, “MATLAB Analysis”. You can try this out with ThingSpeak now by signing in, selecting Apps, MATLAB Analysis, New, selecting “Calculate Dew point”, and clicking “Create”. This happens to be one of our built-in examples using our weather station’s public data.

It is great that it was easy to calculate dew point with MATLAB, but I want to see this analyzed data over time just like any other sensor data. The solution is a powerful combination of MATLAB Analysis and TimeControl. We use MATLAB Analysis to do the analysis and write the data to a ThingSpeak channel. Then, we use the TimeControl app to repeat the analysis every 5 minutes.

To setup MATLAB Analysis on a schedule, sign into ThingSpeak, select Apps, TimeControl, and New TimeControl.

My MATLAB code now runs every 5 minutes doing analysis and writing data to my ThingSpeak channel. The TimeControl settings can be tailored to your needs such as executing MATLAB code once a day or only on weekends. This combination of MATLAB Analysis + TimeControl allows you to create continuous analysis of your project data.

To try this out for yourself, we have a public channel of weather station data that we have collected in Natick, MA at our headquarters. You can use that data and do your own MATLAB Analysis and writing the results back to your own channel. Also, Check out the ThingSpeak Documentation where we have a complete tutorial for you to help get started with ThingSpeak and MATLAB.

The nodeIT is centered around the ESP8266 Wi-Fi microcontroller and allows you stack other boards to extend its base functionality. Once the nodeIT is connected to your Wi-Fi network, you can easily publish data to ThingSpeak and visualize the results, such as data collected by a barometric sensor.

For more information about nodeIT, follow their Kickstarter campaign and check out their ThingSpeak Room Monitor project.

[via Kickstarter]

The sensor records the PM10 and PM2.5 dust levels to get an accurate indication of the dust in the air. This project is a great example of how a little sensor could turn into something important for protecting machine shops, construction sites, and garages.

[via shadowandy / GitHub]

Hackaday.com wrote an article about Vegard’s soldering iron connected to the Internet of Things. Here’s what they had to say:

The data pushes out to the ThingSpeak server which handles pushing data out to the bigger network, and data representation (like the cool Google gauge…). The best part: [Vegard] gets a phone notification when he accidentally leaves his soldering iron on. How perfect is that?

That looks a lot like our desks… wires, microcontrollers, pliers, cutters, Wi-Fi modules, and soldering irons. And now, the soldering iron is on the Internet of Things.

[via Vegard Paulsen / Hackaday.com]

[via Twitter]

Greg built the project out of necessity to help his plants suffering from “localized drought”. Let’s hope his plants get proper watering and that other ThingSpeak users can quickly and easily build this project. Thanks for sharing!

[via Instructables]

The idea is that it is frustrating waiting for luggage at the airport and wondering where it is and why it is not on the baggage carousel. With this project, you can track luggage from start to finish. The advantages are not only for the traveler, the airlines could track luggage as well and get quality statistics for each airport. And, the base system has many applications outside of travel such as the Automotive Industry.

Chris explains the project really well on his blog and with a YouTube video.

Everything you need to know in order to build your own sensor logging project is on Noel’s Instructables.

[via Instructables]

All of the source code to connect Electric Imp to ThingSpeak and the 3D printer design files are available on Marcus’ blog ‘slickstreamer‘.

[slickstreamer / Dangerous Prototypes]

Mi Humidor de Cigarros conectado a Internet por medio de un Arduino

Question: How do I find ‘public’ ThingSpeak Channels?

In order to help developers find open data inside of ThingSpeak Channels, we created a new API for searching the public ThingSpeak Channels.

Here are the Public ThingSpeak Channels. We order the channels by activity and completeness. Channels may be tagged and this helps find data that you might find interesting for your application. We also have API commands that you can pass to the ThingSpeak Channel API to return the public ThingSpeak Channels in either JSON or XML format.

Here are some easy examples:

• http://api.thingspeak.com/channels/public.json – Returns the Public ThingSpeak Channels in JSON format
• http://api.thingspeak.com/channels/public.xml – – Returns the Public ThingSpeak Channels in XML format
• http://api.thingspeak.com/channels/public.json?tag=temperature – Returns the Public ThingSpeak Channels in JSON format that match the tag, “temperature”

For support and questions, please use the ThingSpeak Forum.

Looking over the code for the Electric Imp, it looks pretty easy to cross-clouds from the Imp to ThingSpeak. Check out the source code on GitHub and full details on Slickstreamer.

[via Slickstreamer]

For more information and Python source code, visit MY NERD JOURNAL.

[via MY NERD JOURNAL]

Indoor Environmental Quality (IEQ) is the measure of comfort and includes factors such as temperature, humidity, pressure, noise level, and indoor air quality. don’s original goal was to monitor the IEQ of his baby’s room, but he soon realized that his project has more applications around the house and for others.

Don published the full details of the project and submitted it to the Green Design Contest at Instructables. Great work!

[via Instructables]

Duke says,

“A demo of how to use ThingSpeak (an IOT web site) with a Gadgeteer Gas Sensor Device. Data from the sensors are displayed in real time on ThingSpeak and using some of ThingSpeak’s cool features the Gas Sensor device can send out Tweets for Alert and Alarm conditions.”

Another awesome part of this project is that it uses .NET Micro Framework library, μPLibrary 1.8, created by [paolopat]. This library makes it really easy to tap into ThingSpeak web services by embedded devices. It’s great to see different parts of the project coming together from multiple ThingSpeak users. We appreciate the creative combinations and the efforts that you are putting into your projects. Thanks!

For more information, check out the live sensor readings on the project’s ThingSpeak Channel and download the complete source code at Codeshare.

[via >TinyCLR Forums]

Here’s what the temperature looks like now in Australia:

Check out the family’s blog for the source code and to learn how to create your own solar water heater monitoring system.

[via Klink Family Adventures]

This video that we discovered on YouTube is the team’s presentation. You will get to see ThingSpeak in action, live in front of an audience about halfway thru…

We hope you got an “A” on the project (do they still give letter grades?)!

The Teracom box allows for 1-wire connections to sensors. David connected a temperature sensor to the 1-wire bus, an Ethernet connection, and customized the controller to push data to ThingSpeak for data logging of environmental sensor data. The tutorial also includes great photos clearly showing the setup for others to repeat.

We have created a new ThingSpeak Sketch for Arduino 1.0 that you can use for the Arduino and Ethernet Shield or the Arduino Ethernet all-in-one. All you have to do is add your ThingSpeak Write API Key to the sketch, upload to the Arduino, and connect to your network. The sketch includes automatic network configuration with DHCP, domain name resolution using DNS, a watchdog / reset function to keep the Arduino online, and a function to update ThingSpeak Channels. The new sketch has been running without hiccup in our lab for few weeks. We hope that you get the same reliability. Go ahead and copy, transform, and combine…

View Arduino 1.0 –> ThingSpeak Sketch on GitHub

Behind the scenes, Lars uses the Arduino microcontroller to collect data from the sensors and uses Processing to publish data to his ThingSpeak Channel.

From Lars’ project site:

The goal of this project is to log some weather data and be able to access it from anywhere. There is some sensor data (temperature, relative humidity, pressure, and ambient light) and some computed data (dew point). You can see the weather condition in my apartment in Ithaca, NY at my ThingSpeak Channel 346. You can also look at the Google Chart of my own MySQL solution, which I no longer maintain.

Check out a detailed breakdown of the Weather Station project and more awesome projects on Lars’ project site, called “make.larsi.org“.

Visit the ThingSpeak Plugin page for more information on how to use this plugin with your HomeVision home automation system.

Just imagine what we can learn from all of our things? Maybe we can save resources as an article by Brian McCann suggests. He also mentions connecting things to ThingSpeak as the Web of Things is being built from the ground up! Our community of developers and users are growing by leaps and bounds and we will continue to contribute to the advancement of the Internet of Things!

Brian says,

The Internet of Things refers to uniquely identifiable objects having an Internet presence. We’re not just talking about your computer, laptop, cellphone or even your TV here – we’re talking about everything. This includes your light switches, your fridge, even your toilet. With an Internet presence, all of your devices can start talking to each other and reacting to each other.

[via The Daily Gleaner]

[via MyBlog4Fun.com]

willnue added the ability to tweet to his GE Wireless Control Center Alarm system. He added an Arduino with Ethernet Shield and uses the ThingTweet app to connect the alarm to Twitter. Check out his detailed Instructables to learn more, build your own social thing, and enter the contest.

wilnue says,

This project will add tweeting capabilities to the GE 45142 Choice-Alert Wireless Control Center Alarm system. The alarm system allows you to connect up to 16 different sensors across 4 zones and with the addition of the Arduino powered AlarmingTweet you can enable it to keep you informed of its status anytime anywhere.

Good luck with the contest!

The mashup community ProgrammableWeb indexed the ThingSpeak API and the ThingSpeak Chart API. We entered the category of “Other”. Just imagine what web developers will create now that they have the Internet of Things at their fingertips.

[via ProgrammableWeb]

[Elad Salomons] of OptiWater noticed that his house water pressure was 9 bars and this set him on a collision course with the Internet of Things. In his research he discovered ioBridge and ThingSpeak. He was able to connect sensors to the web, visualize the data, and come up with a few ah-ha’s in the process.

Elad is enjoying the process so much that he wanted to share the learning experience with you. He has created a contest based on some sensor data he has collected. You can look at the data and download historical data over at his Water Simulation blog to see if you can explain the correlations. You have until June 30, 2011 to figure it out. Visit Elad’s blog for more information or look him up on Twitter. $100 to learn something? That’s awesome!

[via Water Simulation / ioBridge]

[via NueWire / Arduino Forum]

Outlet has created a detailed Instructables to guide you on how he created the project. This project is at prototype level, but we could see how this could be packaged into an efficient setup and used for many applications that require wireless sensors and remote monitoring and reporting. This is on the same lines as the ioBridge  Tide Alerts product used by many marinas to measure and alert tide levels in real-time.

Frank says,

This project uses a mbed microcontroller (LPC1768 ARM Cortex-M3) to monitor temperature using a DS1620 (digital temperature sensor IC), retrieve the time via NTP (network time protocol), and then log the current temperature to ThingSpeak along with a time-stamp.

[via Circle of Current / Dangerous Prototypes]