Here are some tips that I have learned after a few seasons in New England with an Ariens 1128 Sno-Thro snowblower.

RTFM. The manual contains a lot of clues. Ariens.com has manuals for all of its models archived. Actually, I find that the manual gets more helpful over time. Initially, you don’t know anything about this machine that you just bought. How hard could it be, you may think? The machine typically works pretty well when you first get it. Once you get a little time under your belt, read the manual. You will find little details that help you understand what’s going on.

Take notes. When you learn something, write it down. Your future self will thank you. Write down the socket sizes, threads, part numbers for replacement parts, and any tips that you discover.

Watch videos on YouTube. When you encounter a problem or a developing issue, find appropriate videos on YouTube. You will have to make sure that you watch a video on your specific model, as sometimes you might be watching a video on a different model. I tend to act like a detective and seek out the information from the videos. Not all of the videos, or every video you are going to find, are going to apply. This is a good skill to develop to speed up the learning process with anything that you may want to learn.

Grease the shear bolts. Your snowblower is designed to fail-safe when you run over a dog toy, a tree branch, or a rock. A shear bolt is designed to break in case of a jam instead of putting the forces back on the belt, drive, and motor. When you replace your shear bolt, grease it up. It will be easier to remove and replace when you inevitably hit something.

Keep a stock of shear bolts. Use the manual to find the type of shear bolt you need. Write down the part number. Buy a bunch of shear bolts. Try them out as soon as you get them. Make sure they fit and last with normal wear. On Amazon, there is a variety of quality that you will find. So, find ones that work and return the ones that don’t. You will be thankful when you need them. In New England, they tend to be out of stock in the winter since everyone is breaking their shear bolts and going out to buy them. Mine uses a 1/2″ socket to install. Yes, I wrote that down in my notes.

Grease the auger when you replace the shear bolts. A good time to grease the auger shaft is when you replace the shear bolts. I like to take the shear bolts off and apply grease via the Zerk fittings and then spin the auger to spread out the grease. I squeeze grease in there until it comes out the sides of the auger. This was something I had to watch a YouTube video on. I never used my grease gun before and didn’t even know how to attach it to the grease fitting.

Maintain the correct tire pressure. My Ariens 1128 tires require 14 psi to function properly. I bought a battery-powered air compressor to make it easy to fill the tires. I also like that it tells me the pressure in the tire with a digital readout. Make sure that both tires are set to the same air pressure. This will help the snowblower travel in a straight line. If you don’t know your target PSI, check the sides of the tires. It is usually written on the walls of the tire.

Take advantage of the calm before the storm. It’s freezing in the winter, and it’s not convenient to perform maintenance. In the spring or fall, you can take advantage of warmer weather and lower stakes. Grease the auger, buy some shear bolts from Amazon, clean the gas, add oil, tighten the chute, and set the right air pressure in your tires.

Godspeed.

CheerLights is a fun way to get started with IoT, microcontrollers, and LED lights. If you know how to make CheerLights work, you can build some other awesome IoT projects. CheerLights is a great project to get people interested in IoT. It’s often used as an “Hello, World” project for the Internet of Things, and what you learn can be applied to other project ideas.

To make a Halloween-inspired project, you can take the CheerLights color and illuminate a pumpkin or even a… skull from Pimoroni.

Check out other Halloween CheerLights projects over at the CheerLights blog. Have fun with the idea, build something spooky, and help spread the… fear.

ThingSpeak is an Internet of Things (IoT) platform that allows you to collect, analyze, and act on data from sensors and other IoT devices. The platform provides a web-based interface for users to create and manage channels, which are virtual locations where data from sensors and other devices can be collected and analyzed using the built-in MATLAB analytics app.

With ThingSpeak, you can visualize your data in real-time, generate alerts and notifications based on pre-defined thresholds, and even automate actions based on specific conditions. The platform also includes built-in integrations with popular IoT hardware platforms, such as Arduino and Raspberry Pi, making it easy to connect your devices to the internet and start collecting data.

Top 10 IoT Project Ideas for ThingSpeak

1. Weather Station: Build a weather station using a microcontroller such as Arduino or Raspberry Pi that collects data on temperature, humidity, and air pressure, and sends it to ThingSpeak for real-time monitoring and analysis.
2. Home Automation: Use ThingSpeak to automate your home by controlling lights, fans, and other appliances based on sensor data, such as motion, temperature, or light levels.
3. Smart Agriculture: Monitor soil moisture, temperature, and other environmental variables to optimize crop growth and water usage, using ThingSpeak to collect and analyze the data.
4. Water Quality Monitoring: Monitor water quality in lakes, rivers, and other bodies of water using sensors to collect data on pH, temperature, and other parameters, and then use ThingSpeak to analyze the data and generate alerts for unsafe conditions.
5. Smart Parking: Use ThingSpeak to monitor parking spots and guide drivers to available spots using sensors and real-time data analysis.
6. Industrial Automation: Monitor machine data in a factory or other industrial setting to detect anomalies and predict equipment failures, using ThingSpeak to collect and analyze the data.
7. Healthcare Monitoring: Use ThingSpeak to monitor patients’ health data, such as heart rate, blood pressure, and oxygen levels, in real-time and alert healthcare professionals of any critical changes.
8. Air Quality Monitoring: Use ThingSpeak to collect data on air quality, including particulate matter and pollutants, and generate alerts and visualizations for high-risk areas.
9. Smart Energy: Monitor energy usage in homes or businesses and automatically adjust consumption based on sensor data, such as occupancy or sunlight levels.
10. Smart City: Use ThingSpeak to monitor and optimize traffic flow, waste management, and other city services based on sensor data from a network of IoT devices.

Subscribe to the About Things blog for more IoT news, tips, and projects. If you need help or want to share ideas, connect with me and the community on our Quandary Discord Server.

This version of the On Air Light is cheaper and easier to build than my previous versions.

The Idea

I want a light that turns on when my webcam turns on. I want the light to turn off when my camera turns off. The idea is that my camera is on when I am in an online meeting. The light is a good indicator to everyone, including myself, that I am in a meeting.

The System

In order to turn a light on and off, I need a script that monitors my webcam for activity. This script will then send the status of my webcam to ThingSpeak, a cloud IoT platform that allows you to save and retrieve sensor data. Then, the on-air light controller will read the data from ThingSpeak and turn the light on if my camera is on.

The Parts

I was able to find everything you need on Amazon to build this project.

• On Air sign
• ESP32 board
• ESP32 screw terminal board
• LED light strip

Here are some notes about these parts.

• You can use any sign that you want to light up. I chose this one since it was $15 US and looks great. It also includes a Micro USB cable that you can use for the ESP32 device.
• Screw terminals make this project a solder-free project. Some people who wrote me said that soldering was a barrier to getting started. I want this to be accessible to as many makers as possible. Screw terminals offer a quick way to break out the pins of the ESP32 board and easily connect wires.
• Only certain styles of the ESP32 board work with the screw terminals. The terminals are for the 38-pin version of the HiLetgo ESP-WROOM-32 ESP32 dev board. The two parts that I linked to on Amazon will fit together perfectly. Other ESP32 boards might not work with the screw terminal expansion board.

ThingSpeak Setup

ThingSpeak is an IoT service hosted by MathWorks. It is focused on being easy to collect data and then retrieve that data. We are going to leverage that core functionality for this project. ThingSpeak stores data in a channel and each channel has eight fields.

Visit ThingSpeak.com and Sign Up for an account. This will just take a minute and user accounts are free. Once you have a user account, you need to create a channel. ThingSpeak channels are where data gets stored. Create a new channel by selecting Channels, My Channels, and then New Channel. Name the channel, “On Air Light” and name Field 1, “Webcam State”. Click “Save Channel” at the bottom to finish the process.

Click API Keys and note your write API key and read API key. The write API key will be used by the code to track your webcam state. The read API key will be used to turn on or off the light based on the webcam state.

Track Webcam State

I wrote a Python script that uses OpenCV to detect if the camera is in use or not. It sends a “1” to field1 of the ThingSpeak Channel if the camera is in use. It sends a 0 if the camera is not in use. Just run this code on a periodic basis to track the state of your webcam.

The code to track my webcam state and upload the state to ThingSpeak is available on GitHub. Update the code with your ThingSpeak Channel’s write API key.

Most of the magic is here:

def returnWebcamStatus(webcamIndex):

    webcam = cv2.VideoCapture(webcamIndex, cv2.CAP_DSHOW)

    if webcam.isOpened():
        webcam.release()
        return True #Webcam not in use
    else:
        return False #Webcam in use

Assembly

Get your parts together and get ready to put everything together. Take your time and step through. There is no soldering, just some connections to be made on a set of screw terminals. You will need cutters, a small screwdriver, and some tape to complete the assembly.

Connect the ESP32 board to the SCrew Terminal Board

Make sure to get the right orientation of the boards together. The 5V pins should line up and the USB part should be pointing down.

Cut Off the Out Connector from the LED Strip

We can use the connector on the out side of the LED strip. Cut this off and strip back some of the insulation. We will use this connector for the screw terminals.

Connect the Connector to the Screw Terminal Board

Connect the red wire to the 5v terminal. Connect the green wire to P13. Connect the white wire to GND.

Connect the LED Strip to the Connector

Program the ESP32

Using the Micro USB cable that comes with the On Air Light, connect the ESP32 to your computer.

The code that the Arduino IDE uses is called a “sketch” – this is just a short program that the device runs over and over. In this project, we are going to have the code that checks the ThingSpeak channel for the webcam status and sets the LED strip to either on or off. Copy the example code to your Arduino IDE and change some of the defaults to match your Wi-Fi network and ThingSpeak settings.

Once everything is set, click Sketch and then Upload. This will take the code and program the ESP32 with it. It takes a minute, so be patient. If anything goes wrong, make sure that you have the right board settings and that your “Port” matches what your laptop thinks the port is.

Open the On Air Light

The housing of the On Air light is held together by several tabs. Take your screwdriver and gently twist in each opening. It will come apart without damage. Just take your time and open each tab.

Remove the Existing LED Board

Remove the existing board on the inside of the light. Trim the wires off close to the circuit board so you have some length to work with.

Connect the USB Wires to the Board

Connect the red wire to the 5v screw terminal. Connect the black wire to the GND screw terminal. You will have two wires in each. I used some tape to make sure that the screw terminal board doesn’t move around.

Snap It All Back Together

Carefully snap the two halves back together.

Profit.

Enjoy your On Air light. Maybe this will remind you or someone in your family that you actually work when you are home.

My goal was to show you the steps as clearly as possible and share the code. I hope that you can reproduce this as easily as possible. If you need help leave a comment or join me on my new Discord server.

Most people experienced MATLAB on their PC, but you can also access MATLAB in your browser with MATLAB Online. MATLAB Online is a web-based version of MATLAB that allows users to access the software and its features through a web browser. It eliminates the need to install and configure the software on a local computer, making it accessible from anywhere with an internet connection.

In this project, I will be using MATLAB Online to take a picture with a webcam, classify the image using a pre-trained deep learning model, and display the results.

I selected the ResNet-50 model, which is a deep convolutional neural network (CNN) trained on the ImageNet dataset. ResNet-50 stands for “Residual Network with 50 layers” and was developed by Microsoft Research in 2015. The architecture is known for its ability to train very deep neural networks without the problem of vanishing gradients, which allows for improved performance on image classification tasks. The model is capable of identifying objects in images and classifying them into one of 1000 different categories.

% Connect to webcam
cam = webcam;

% Take a picture
img = snapshot(cam);

% Resize image to [224 224 3]
img = imresize(img, [224 224]);

% Display the picture
imshow(img);

% Load pretrained model
net = resnet50;

% Classify image
label = classify(net, img);

% Display label
disp(label);

% Release webcam
clear cam;

What’s really neat is that MATLAB Online can use your webcam. This code takes a photo, resizes it for ResNet-50, shows the output, and classifies the photo.

Check out MATLAB Online and run the very latest version of MATLAB and select toolboxes. Everyone should be able to try this project out and get started with image classification.

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.

ChatGPT is a variant of the GPT-3 language model that was specifically designed to support conversation and chatbot applications. It was developed by OpenAI, and is notable for its ability to generate human-like text that is coherent and appropriate for a wide range of conversation topics.

One potential topic for a blog post about ChatGPT could be a review or evaluation of the model’s performance. This could involve comparing ChatGPT to other chatbot models or discussing its strengths and weaknesses in terms of its ability to generate natural-sounding text and handle different types of conversation.

Another possible angle for a blog post on ChatGPT could be a tutorial or guide on how to use the model to build a chatbot application. This could include step-by-step instructions on how to access and utilize ChatGPT, as well as tips and best practices for getting the most out of the model.

There are many other possible topics that could be explored in a blog post about ChatGPT, depending on your interests and goals. Some other ideas might include exploring the technical details of the model and how it works, discussing the potential applications of ChatGPT in various fields, or examining the ethical considerations surrounding the use of chatbot technology.

Write a blog post about the ChatGPT model’s performance

To evaluate the performance of ChatGPT, we can compare it to other chatbot models and assess its ability to generate natural-sounding text and handle different types of conversation. One way to do this is to test ChatGPT in a variety of scenarios and compare its output to that of other models.

One area where ChatGPT appears to excel is in its ability to maintain coherence and context in long-term conversations. Unlike some chatbot models that struggle to keep track of past conversations and may produce unrelated or nonsensical responses, ChatGPT is able to retain and utilize information from previous exchanges to generate more relevant and appropriate responses.

Another strength of ChatGPT is its versatility. It is able to handle a wide range of conversation topics and styles, and can generate text that is appropriate for different audiences and contexts. This makes it a good choice for chatbot applications that need to support a diverse set of conversation types.

However, ChatGPT is not without its limitations. Like any language model, it is not perfect and may produce responses that are unnatural or inappropriate in certain situations. It may also struggle with more complex or abstract topics, or those that require a deep understanding of specific domain knowledge.

Overall, ChatGPT is a highly capable chatbot model that is able to generate natural-sounding text and handle a wide range of conversation types. While it is not perfect and may have some limitations, it is a strong performer in the field of chatbot technology and is well-suited for many different applications.

Can you write a blog post about your second idea?

Certainly! Here is a blog post on the topic of using ChatGPT to build a chatbot application:

The ChatGPT model is a variant of the GPT-3 language model developed by OpenAI specifically for chatbot applications. It is designed to generate natural-sounding text that is coherent and appropriate for a wide range of conversation topics. In this blog post, we will provide a tutorial on how to use ChatGPT to build a chatbot application.

Step-by-step guide:

1. First, you will need to sign up for an OpenAI API key to gain access to ChatGPT. You can do this by visiting the OpenAI website and creating an account.
2. Once you have obtained your API key, you can use the OpenAI API to send requests to ChatGPT and receive responses back. You can use one of the API client libraries provided by OpenAI or make requests directly using the API endpoint.
3. To use ChatGPT, you will need to provide it with a prompt, which is a piece of text that the model will use to generate a response. The prompt should include any necessary context or information that the model needs to understand the conversation.
4. You can customize ChatGPT’s behavior by setting various parameters in your API request, such as the length of the generated response or the type of response you want (e.g. multiple choice options or open-ended text).
5. Once you have sent your request and received a response back from ChatGPT, you can use this text to update your chatbot’s conversation with the user.

Tips and best practices:

• It is a good idea to test ChatGPT with a variety of prompts and parameters to get a sense of its capabilities and limitations.
• You can use the OpenAI API’s “temperature” parameter to control the level of creativity and diversity in ChatGPT’s responses. A higher temperature will result in more varied responses, while a lower temperature will produce responses that are more predictable and conservative.
• ChatGPT is trained on a large dataset of human conversation, so it is important to remember that it may generate responses that are inappropriate or offensive. It is up to you as the developer to implement any necessary filters or moderation to ensure that your chatbot’s responses are suitable for your intended audience.

The ChatGPT model is a powerful tool for building chatbot applications that can engage in natural-sounding conversation with users. By following the steps outlined in this tutorial, you can use ChatGPT to create a chatbot that is capable of handling a wide range of conversation topics and styles. With its ability to generate coherent and appropriate responses, ChatGPT is a valuable resource for chatbot developers looking to create engaging and lifelike conversational experiences.

Can you discuss potential applications of ChatGPT for bloggers?

Here are a few potential applications of ChatGPT for bloggers:

1. Blog comment moderation: ChatGPT could be used to help moderate the comments section of a blog by automatically detecting and flagging inappropriate or offensive comments. The model could be trained on a dataset of previously moderated comments to learn what types of language are acceptable and what types are not.
2. Blog post generation: ChatGPT could be used to generate blog post ideas or outlines by providing the model with a list of keywords or topics related to the blog. The model could then generate a list of potential post ideas or an outline for a post based on these keywords.
3. Chatbot assistant: ChatGPT could be used to build a chatbot assistant for a blog, allowing readers to ask questions or get help with tasks related to the blog. For example, a blogger could use ChatGPT to create a chatbot that can answer frequently asked questions about their blog, suggest related posts, or provide information about the blogger.
4. Social media management: ChatGPT could be used to assist with social media management by generating social media posts or responses to comments and messages. For example, a blogger could use ChatGPT to generate Twitter or Instagram posts based on a list of keywords or topics related to their blog.

There are many other potential applications of ChatGPT for bloggers, depending on the specific needs and goals of the blogger. Some other ideas might include using ChatGPT to generate newsletter content or email responses, or to assist with the research and fact-checking of blog posts.

Can you write a nice wrap up to these blog posts with a call-to-action to subscribe to the About Things blog?

Thank you for reading these blog posts about ChatGPT and its potential applications for bloggers. We hope you found this information useful and that it has given you some ideas on how you can use ChatGPT in your own blog or chatbot projects.

If you enjoyed these posts and would like to stay up-to-date with the latest news and insights from the About Things blog, be sure to subscribe to our newsletter. By subscribing, you’ll receive updates on our latest posts and access to exclusive content and resources.

Don’t miss out on the valuable information and inspiration that the About Things blog has to offer. Subscribe now and join our community of like-minded bloggers and chatbot enthusiasts.

Borrowing ideas from my Lofi Girl CheerLights Shadowbox project, George and I made a CheerLights Gift for under our Christmas tree. This gift changes color based on the latest CheerLights color and anyone on Twitter or Discord can change its color and the color of all of the other CheerLights projects.

The CheerLights Gift project is based on the Pimoroni Plasma Stick 2040 W and NeoPixel string lights for illumination. The Plasma Stick ships with CheerLights code main MicroPython file, so all you have to do is change the Wi-Fi network name and password. The microcontroller makes a request to the ThingSpeak API to get the latest CheerLights color, sets the color of the NeoPixel LED lights, waits 10 seconds, and repeats. This is about the fastest way to build your own CheerLights display.

I used a metal gift box that I found in a craft store to house the lights and controller. All we needed to do was stuff the LEDs inside and glue them in place. I only burned my fingers twice.

The project turned out well and kept my five-year-old’s interest for the duration of the build. I was happy that the Plasma Stick 2040 W made it really easy to get the project going.

Join the CheerLights IoT community at CheerLights.com.

LIFX lets you control the lights with the LIFX Cloud API. The only thing stopping you is the authentication token. The token will be needed to send API requests to the LIFX Cloud API to leverage all of the commands in the HTTP REMOTE CONTROL API. All requests require an OAuth 2 access token.

How to get your LIFX Bearer Token

To get your access token for LIFX, go to: https://cloud.lifx.com/, sign in with the same account that you registered your lights, and click Settings. Under Personal access tokens, click GENERATE NEW TOKEN, enter a label, and click Generate. This will generate a new token that you can use for the LIFX Cloud API. Caution thought. This will be the last time that you see this token. If you lose it, you will have to generate a new API key.

How to use the LIFX Access Token

I recommend using the LIFX token in the HTTP authorization header. It is pretty easy to do. Here’s an example in Python.

import requests


token = "[[app:Token]]"

headers = {
    "Authorization": "Bearer %s" % token,
}

response = requests.get('https://api.lifx.com/v1/lights/all', headers=headers)

Have fun and build some cool integrations with the LIFX Cloud API!