Configure the Arduino IDE to Support the Arduino UNO RF WiFi Board

To use the Arduino UNO R4 WiFi board, you need to update and install some board drivers.

• Open the Arduino IDE (from Arduino) and update to v2.3.3 or newer.
• Go to the Boards Manager, search “Arduino UNO R4” and click INSTALL.

Controlling the LED Matrix

I am here for the LEDs.

Here’s how to use the onboard LED matrix, which requires the LED_Matrix library. Start your sketches with “#include “Arduino_LED_Matrix.h”, create an instance, and begin it in the setup section of your code.

Here’s an animation example:

#include "Arduino_LED_Matrix.h"   
#include "animation.h"            

ArduinoLEDMatrix matrix;  

void setup() {
  matrix.loadSequence(animation);
  matrix.begin();
  matrix.play(true);
}

void loop() {
}

I learned everything that I know about this from the Arduino documentation: https://docs.arduino.cc/tutorials/uno-r4-wifi/led-matrix/

The cool part is that the library includes predefined frames. You can load these, and the Arduino UNO R4 WiFi displays them without knowing how to code the frames.

#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix matrix;          

void setup() {
  matrix.begin();                 
}

void loop() {
  matrix.loadFrame(LEDMATRIX_HEART_BIG);
}

Here are the available frames in the LED_Matrix library:

• LEDMATRIX_BLUETOOTH
• LEDMATRIX_BOOTLOADER_ON
• LEDMATRIX_CHIP
• LEDMATRIX_CLOUD_WIFI
• LEDMATRIX_DANGER
• LEDMATRIX_EMOJI_BASIC
• LEDMATRIX_EMOJI_HAPPY
• LEDMATRIX_EMOJI_SAD
• LEDMATRIX_HEART_BIG
• LEDMATRIX_HEART_SMALL
• LEDMATRIX_LIKE
• LEDMATRIX_MUSIC_NOTE
• LEDMATRIX_RESISTOR
• LEDMATRIX_UNO

Going Further

George and I explored this new board together. We had a lot of fun trying out the examples from the Arduino documentation and experimenting on our own. You know that I will be hooking this up to CheerLights soon, but we noticed that the LEDs are only red. We will have to get creative. Then, George had an idea… He said, “Let’s make a CheerLights for emoji. Like, red could be a smiley face.” Great idea. I might just do that.

The SIM800L module is a GSM/GPRS module that can be used to connect to the internet via a cellular network. It has a built-in SIM card slot and can be used to send and receive data over a cellular network connection instead of WI-Fi. ThingSpeak is an IoT platform that allows you to send and receive data from devices over the internet.

In this tutorial, we will use the SIM800L module and ThingSpeak’s API to send data from an Arduino board to be stored in the cloud.

Hardware

To complete this tutorial, you will need the following hardware:

• Arduino board
• SIM800L module

Setting up the SIM800L module

First, let’s set up the SIM800L module. To use the SIM800L module with your Arduino board, you’ll need to connect it to the appropriate pins on the Arduino. The SIM800L module has a number of different pins, including power pins, serial communication pins, and control pins. You’ll need to consult the documentation for your particular module to determine which pins to use.

Once you have the SIM800L module connected to your Arduino board, you’ll need to use AT commands to communicate with it. AT commands are simple text-based commands that are used to control the module and send and receive data. Some common AT commands include AT+CPIN, which is used to enter the SIM card PIN number, and AT+CREG, which is used to check the registration status of the module.

To connect to the internet using the SIM800L module, you’ll need to attach it to the GPRS service and get an IP address. You can do this using the following AT commands:

sendATCommand("AT+CFUN=1", 2000, DEBUG); // Enable full functionality
sendATCommand("AT+CIPMUX=0", 1000, DEBUG); // Set single connection mode
sendATCommand("AT+CGATT=1", 1000, DEBUG); // Attach to GPRS service
sendATCommand("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"", 1000, DEBUG); // Set connection type to GPRS
sendATCommand("AT+SAPBR=3,1,\"APN\",\"YOUR_APN\"", 1000, DEBUG); // Set APN
sendATCommand("AT+SAPBR=1,1", 1000, DEBUG); // Enable GPRS
sendATCommand("AT+SAPBR=2,1", 1000, DEBUG); // Get IP address

Setting up ThingSpeak

Now that we have the SIM800L module set up, let’s set up ThingSpeak. To use ThingSpeak’s API with your SIM800L module, you’ll need to create a new “channel” on the ThingSpeak website. A channel is a way to represent a device or a group of devices on the ThingSpeak platform. Once you’ve created a channel, you’ll be given an API key that you can use to access and update the channel from your Arduino sketch.

Sending data to ThingSpeak

To send data to ThingSpeak using the SIM800L module, you’ll need to use the AT+HTTPPARA command to set the necessary parameters for the HTTP request, and then use the AT+HTTPACTION command to send the request.

Receiving a response from ThingSpeak

After sending the request, you can use the AT+HTTPREAD command to read the response from the server. The response will be a string of text, which you can parse to check for any errors or confirm that the data was successfully sent.

Putting it all together

Here is an example of how you can use the SIM800L module and ThingSpeak’s API to send data from your Arduino board to the internet:

#include <SoftwareSerial.h>

SoftwareSerial sim800l(10, 11); // RX, TX

void setup() {
  sim800l.begin(9600);
  sendATCommand("AT+CFUN=1", 2000, DEBUG); // Enable full functionality
  sendATCommand("AT+CIPMUX=0", 1000, DEBUG); // Set single connection mode
  sendATCommand("AT+CGATT=1", 1000, DEBUG); // Attach to GPRS service
  sendATCommand("AT+SAPBR=3,1,\"CONTYPE\",\"GPRS\"", 1000, DEBUG); // Set connection type to GPRS
  sendATCommand("AT+SAPBR=3,1,\"APN\",\"YOUR_APN\"", 1000, DEBUG); // Set APN
  sendATCommand("AT+SAPBR=1,1", 1000, DEBUG); // Enable GPRS
  sendATCommand("AT+SAPBR=2,1", 1000, DEBUG); // Get IP address
}

void loop() {
  sendDataToThingSpeak();
  delay(20000); // delay 20 seconds
}

void sendDataToThingSpeak() {
  String cmd = "AT+HTTPPARA=\"URL\",\"http://api.thingspeak.com/update?api_key=YOUR_API_KEY&field1=42\"";
  sendATCommand(cmd, 1000, DEBUG); // Set URL
  cmd = "AT+HTTPACTION=0";
  sendATCommand(cmd, 3000, DEBUG); // Send request
  delay(1000);
  String response = sendATCommand("AT+HTTPREAD", 1000, DEBUG); // Read response
  Serial.println(response);
}

String sendATCommand(String cmd, const int timeout, boolean debug) {
  String response = "";
  sim800l.println(cmd);
  long int time = millis();
  while((time+timeout) > millis()) {
    while(sim800l.available()) {
      char c = sim800l.read();
      response += c;
    }
  }
  if (debug) {
    Serial.println(response);
  }
  return response;
}

In this example code, the sendATCommand function sends AT commands to the SIM800L module and reads the response. The sendDataToThingSpeak function is used to set the URL for the HTTP request using the AT+HTTPPARA command, send the request using the AT+HTTPACTION command, and read the response using the AT+HTTPREAD command. The loop function calls the sendDataToThingSpeak function every 20 seconds to send data (the number 42 in this case) to ThingSpeak. You can customize the code to send any data that you want to the fields of your ThingSpeak channel.

Conclusion

In this tutorial, we have learned how to use the SIM800L module and ThingSpeak’s API to send data from an Arduino board to the internet. We have set up the SIM800L module and used AT commands to connect to the internet and send HTTP requests. We have also set up a ThingSpeak channel and used the API to send data to the internet.

With these tools and techniques, you can build your own IoT projects and start collecting and analyzing data from your devices. You can use ThingSpeak to visualize the data and create charts and graphs, or you can use the data in your own applications or MATLAB analyses.

If you found this tutorial helpful and would like to stay updated with more IoT and Arduino tips and tricks, consider subscribing to my blog. I post about once per week.

I have been exploring MicroPython ever since I got a Raspberry Pi Pico W. The community is moving fast and making more and more examples and libraries for MicroPython. Having the Arduino team lean into making the Arduino Lab IDE for MicroPython is a good indicator where things are headed. I was able to build an awesome CheerLights display using MicroPython running on a Raspberry Pi Pico W connected to a Pimoroni Galactic Unicorn PED panel.

Consider Arduino Labs for MicroPython as pre-release, experimental software. Things are moving fast and the project will stabilize. Follow the project on GitHub and file any problems that you come across on GitHub Issues.

LED panels are really bright without a diffuser. You can buy a diffuser to enhance the look of the display… if you remember to buy one. I found an 8×10 clear document frame stand at my house and remembered that I have Rust-Oleum Frosted Glass Spray Paint the I used for my arcade cabinet project. I sprayed on three coats of the frosted glass spray while allowing for each coat to dry for about 15 minutes.

As an added bonus, the document frame also doubled as a stand for the Matric Portal display. The frosted glass enhancement turned out really well and greatly enhances the look of the LEDs.

Take a look at what Adafruit’s LED Sand demo looks like behind the diffused acrylic stand.

You never know who you are going to run into. I was so happy to meet one of the first users of ThingSpeak! This is Andy Leer of Leer Media. Andy was introduced to my IoT projects back in 2008 at Hack Pittsburgh! He was instrumental in me being able to kickstart my startup and help support my growing community. Andy provided meeting space for my IoT Meetup in Pittsburgh.

A couple of the Mythbusters also showed up at the Bay Area Maker Faire. I got to talk about MathWorks software with both Adam Savage and Grant Imahara. Grant remembers using MATLAB quite a bit in his education and later his engineering projects.

Click to view slideshow.

I have been getting ready for this year’s Bay Area Maker Faire. Stop by the MathWorks booth to see our latest hardware projects and demos. We have giveaways and info on the latest products. See you soon at the Maker Faire!

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.

In order to send data to ThingSpeak using an Arduino^®, you need an Arduino with network connectivity either onboard or with a shield. ThingSpeak has an official library that requires Arduino 1.6.x or above running on Windows^®, MAC OS X^®, or Linux^®. This library needs to be installed and used by the Arduino device in order to send data to ThingSpeak using one of the examples.

Setup ThingSpeak

ThingSpeak requires a user account and a channel. A channel is where you send data and where ThingSpeak stores data. Each channel has up to 8 data fields, location fields, and a status field. You can send data every 15 seconds to ThingSpeak, but most applications work well every minute.

• Sign up for a new User Account – https://thingspeak.com
• Create a new Channel by selecting Channels, My Channels, and then New Channel
• Note the Write API Key and Channel ID

Full REST Interface API information for ThingSpeak is available in the documentation.

Install ThingSpeak Communication Library for Arduino

In the Arduino IDE, choose Sketch/Include Library/Manage Libraries. Click the ThingSpeak Library from the list, and click the Install button.

Setup Arduino Sketch

We have provided a few Arduino sketch examples with the ThingSpeak library. They are designed to work right away with no changes.  To make the examples work with your ThingSpeak channel, you will need to configure the myChannelNumber and myWriteAPIKey variables.

unsigned long myChannelNumber = 31461;
const char * myWriteAPIKey = "LD79EOAAWRVYF04Y";

Send an Analog Voltage to ThingSpeak

The WriteSingleField Arduino sketch example reads an analog voltage from pin 0, and writes it to a channel on ThingSpeak every 20 seconds. Load the example in the Arduino IDE. Make sure to select the correct Arduino board and COM port. Then, upload the code to your Arduino.

Sending Multiple Values to ThingSpeak

Since ThingSpeak supports up to 8 data fields, you might want to send more than one value to ThingSpeak. To send multiple values to ThingSpeak from an Arduino, you use ThingSpeak.setField(#,value) for each value to send and then use ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey) to send everything to ThingSpeak. Use the WriteMultipleFields Arduino sketch example to send multiple pin voltages to ThingSpeak.

Examples

The library includes several examples organized by board type to help you get started. These are accessible in the Examples > ThingSpeak menu of the Arduino IDE.

• ReadField: Reading from a public channel and a private channel on ThingSpeak.
• WriteSingleField: Writing a value to a single field on ThingSpeak.
• WriteMultipleFields: Writing values to multiple fields and status in one transaction with ThingSpeak.

Complete source code and examples for the ThingSpeak Library are available on GitHub.

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 %%
plot(time, data);

Support

If you need support for the ThingSpeak Arduino Library, use the ThingSpeak Community on MATLAB Central or join us on the Quandary Discord Server.

Additional Resources

• Source Code for the ThingSpeak Arduino Library on GitHub
• Arduino Examples for ThingSpeak

Update: March 2022

ThingSpeak now supports MQTT as a way to send data to ThingSpeak. MQTT is a publish/subscribe communication protocol that uses TCP/IP sockets or WebSockets. MQTT over WebSockets can be secured with SSL. A client device connects to the MQTT broker and can publish to a channel or subscribe to updates from that channel.

Want to see/hear how far the closest Uber is from you? All you have to do is press a button on an AWS IoT connected device. I created this project to allow anyone to have access to Uber even without a smartphone and for those with different capabilities.

I used the Arduino Yun and the Grove Starter Kit for Arduino to build a physical interface with Uber services. The full project details are available on Hackster.io and GitHub.

It has been a real treat watching this project evolve as more and more people add lights… and other things. Things like Android and iPhone apps that check the latest color of CheerLights, an old Commodore 64, and Christmas trees.

To control the lights around the world, send a Tweet mentioning @CheerLights and a color. The command is processed by ThingSpeak platform and distributed to all of the lights listening to the CheerLights API.

@CheerLights I am dreaming of a White Christmas

Another powerful aspect of the CheerLights project is that is shows off what is possible with the emerging Internet of Things. With a single message sent via a social network like Twitter, 1000’s of objects around the world are in sync with each other. Lights are connected by many types of controllers, such as Arduino, ioBridge, Philips, and the Raspberry Pi. This project is only possible through the Internet and the coordination of developers around the world.

Learn how to join the project at CheerLights.com.

We are all connected…