Your Site's RSS Feed

About Us

Wed, 18 Aug 2021 00:00:00 GMT

Our Objective

The TinoIOT (Internet Of Things) Club’s primary objective revolves around the introduction and promotion of engineering and collaboration.

Club Mission

Our mission is to provide each club member with the necessary knowledge to find their individual passions in the world of IoT. An IoT device, by definition, is an electronic device that can transfer data over a network without human interaction. Many of our common household appliances such as smart TVs, watches, and voice assistants are all constantly transmitting vital data in the background, and keeping their users reliably and consistently informed. Although IoT is all around us, many of us have never seen a network interface, or touched the hardware beneath the sleek exterior of these devices. TinoIOT serves as an enabling gateway that promotes free exploration and creation of IoT devices to students. Club members develop customizable IoT devices for applications of their choosing through instruction from both a detailed curriculum and informative project posts on our website.

The TinoIOT Experience

Along the way, members gain valuable hardware, software, and electrical knowledge that will allow them to pursue their own projects in the future. TinoIOT focuses on the exploration of many exciting technologies such as Computer-Aided-Design Software (CAD) that will allow students to design and 3D print custom enclosures and devices, full System on Chip(SoC) devices, microcontrollers, and home electronics. Members use cloud networking, databases, and machine learning, to fully connect the hardware and software aspects. By introducing these concepts, we hope to foster members’ growth in the IoT field, and provide a start in mitigating common issues and annoyances in our homes & communities.

Officer Team

Founded by Ethan and Sohom in 2019, the TinoIOT Officer Team now consists of 7 dedicated individuals who have a variety of experiences in the IOT world. The team provides club members with a foundation of IOT, relevant curriculum, and specific project posts to guide them along their journey in creating projects.


Shrinandan Narayanan Co-President	Krisha Chokshi Co-President


Max Liu Treasurer	Ryan Hsieh Secretary	Sungmin Baik Public Relations


Ishan Juneja Student Mentor	Arnav Deshpande Student Mentor

Final Notes

We hope everyone will find something enjoyable about our club. Feel free to email us with any questions at CupertinoIoT@gmail.com.

Want to join our Slack group for additional help? Please fill out our membership form here.

Take care,
TinoIoT Exec Team

Ring Door Bell Clone Part 1

Sat, 13 Feb 2021 00:00:00 GMT

Introduction

In this project we will be using the ESP32-CAM to create a Ring Door Bell type device. This small microcontroller has multiple capabilities, including:

Camera Capability
Wifi
Bluetooth
General Purpose Input Output (GPIO)

These features make it ideal for many applications, as it can interface with sensors and other hardware, and also communicate over Wifi or Bluetooth. During this project, we will be taking advantage of all of these features to create a Ring Door Bell device with this functionality:

Detect motion
Stream video
Notify user
Save images for later
Have a web interface
Have a case

Requesting Parts

If you would like to request the ESP32-CAM Microcontroller, please:

Fill out the form here
Select kit option with ESP32-CAM
- If you have a base kit, you can receive just the ESP-32 CAM
Donate here if you can!

Board Overview

Looking at the front and back of the board, we can see multiple features. On the front of the board, we can see the camera at the center. This camera is connected to the board with a thin ribbon cable, so be careful with the microcontroller. Youre camera might have a piece of tape to protect the lens which you can remove. Underneath the camera is a metal square. This square is a microSD card slot that can be used to save images to or other data. On the bottom left, there is a white square. This is a small LED that can be used to illuminate the subject of the camera. It is very bright, so don’t look directly into it from a close distance.

On the backside of the board, you can see the main chip in the silver rectangle. The gold snake like path is an antenna band. If you need to, it is possible to extend the range of Wifi by connecting an antenna to the white circle on the bottom right side of the chip, as this is an antenna port. On the top left side of the board, look carefully for a button. It is directly to the left of the yellow square. This is the reset/program button. We will be using it to let the microcontroller know if it is in programming mode or not.

Programming the Board

You may have noticed that the board does not have a USB port on it. To program it, we need a special device called an FTDI programmer. This device converts USB signals into a form of data the microcontroller can understand.

To connect the FTDI programmer, connect it to your microcontroller according to this wiring diagram using the parts in your kit. Pay attention to the arrow. This connects IO0 to GND. This wire is used to put the device into programming mode. I will be calling this “the jumper wire”

Next, download the Arduino IDE here and follow these tutorials to set it up depending on your system (Windows here, Mac/Linux here)

Then, select the ESP32-CAM Thinker Module and COM port through the Tools menu. Open the example code at “ File > Examples > ESP32 > Camera > Camera Web Server.” Change the SSID and password fields (leave the quotes in). Add ”//” in front of CAMERA_MODEL_WROVER_KIT and remove the ”//” in front of CAMERA_MODEL_AI_THINKER and save the file. To push the example code to the device, follow these instructions:

Connect FTDI Programmer as shown previously
Connect GND to IO0 (The jumper wire)
Press reset button under board
Push code from Arduino IDE
Disconnect GND and IO0
Press reset button under board

Now, open the serial monitor through the “Tools” menu and wait until a URL with an IP address appears. Make sure your computer is connected to the same network that you programmed the ESP32-CAM to connect to, and open the URL in your web browser. You can now start the camera stream and see the video displayed by your device. Try different resolutions and adjust the settings. There may be some issues with lag in the video depending on the quality of your network connection and other factors.

ESP32-CAM Code Explanation

Let’s run through the example code so you know how it works.

#include "esp_camera.h"
#include <WiFi.h>

//
// WARNING!!! Make sure that you have either selected ESP32 Wrover Module,
//            or another board which has PSRAM enabled
//

// Select camera model
//define CAMERA_MODEL_WROVER_KIT
//#define CAMERA_MODEL_ESP_EYE
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE
#define CAMERA_MODEL_AI_THINKER

#include "camera_pins.h"

const char* ssid = "****";
const char* password = "******";

void startCameraServer();

Lines 1-2 start by including files and libraries that the code needs to use. These store a bunch of code in the background so you have to do less work.

Lines 9-14 tell the compiler what type of board we’re using. In our club, we use the AI Thinker model, so we uncommented that line. The // comments out lines. It tells the compiler to ignore that line.

On the next few lines, we tell the microcontroller what our Wifi information is, and then start the Camera Server that runs on the ESP32-CAM.

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();

  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;

On lines 2-4, we are setting up the serial monitor. This is the way the ESP talks to the Arduino IDE’s serial monitor. Serial is the name of the method used to communicate with the ESP and computer. 115200 is some information about the speed of the serial connection.

On lines 6-26, we’re letting the microcontroller know what ports to use to connect to the camera. This is so the microcontroller can read camera data. We also set up some camera format and speed options.

//init with high specs to pre-allocate larger buffers
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }

#if defined(CAMERA_MODEL_ESP_EYE)
  pinMode(13, INPUT_PULLUP);
  pinMode(14, INPUT_PULLUP);
#endif

In this part, we set up some information about the camera size and streaming mode. On Lines 12-15, we check what type of microcontroller we’re using and set up a different mode. We can disregard this.

// camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }

  sensor_t * s = esp_camera_sensor_get();
  //initial sensors are flipped vertically and colors are a bit saturated
  if (s->id.PID == OV3660_PID) {
    s->set_vflip(s, 1);//flip it back
    s->set_brightness(s, 1);//up the blightness just a bit
    s->set_saturation(s, -2);//lower the saturation
  }
  //drop down frame size for higher initial frame rate
  s->set_framesize(s, FRAMESIZE_QVGA);

#if defined(CAMERA_MODEL_M5STACK_WIDE)
  s->set_vflip(s, 1);
  s->set_hmirror(s, 1);
#endif

On lines 2-6, we make sure that we were able to start the camera successfully. We then adjust the image, as by default it is flipped and colors aren’t that great on lines 8 to 16. Finally, we check the camera type and modify the camera flip options if it we’re using a certain type of camera.

WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");

  startCameraServer();

  Serial.print("Camera Ready! Use 'http://");
  Serial.print(WiFi.localIP());
  Serial.println("' to connect");
}

Here, we’re almost ready. We connect to Wifi. Lines 3-8 just wait until we connect to wifi. Next, we start the camera server and print the IP Address information.

void loop() {
  // put your main code here, to run repeatedly:
  delay(10000);
}

In this final part of the code, we can add any code that we want to run.

Next Steps

In our next blog post, we will be working on receiving camera information with Python. We will also be working on some facial detection applications with python. As always, if you have any questions feel free to email cupertinoiot@gmail.com.

First Meeting of Second Semester

Tue, 12 Jan 2021 00:00:00 GMT

Hi everyone!

Make sure to join our meeting today at 12pm with meet.tinoiot.com to learn about what projects we will be doing this semester. We will also do a quick review of first semester concepts and run a little PIR motion sensor demo. We hope to see you there.

Update on kits…

We are still working on assembling the kits and expect a message to schedule pickup times soon!

Best,

TinoIoT Officers

Introduction to Electronics

Wed, 07 Oct 2020 00:00:00 GMT

A Short Brief

In this meeting we introduced electronic concepts such as voltage, amperage, resistance, power, and Ohm’s law. We also went through a guided lab to figure out rules related to resistors and learned about different electrical components used with IOT (Internet of Things) devices and other electrical systems. The electronics knowledge we taught will be necessary to stay safe, protect your electronics, and design efficient circuits when working with IOT Applications.

Feel free to follow along with the video below or go at your own pace!

Slides:
Introduction to Electronics
(10/07/20)

What is Electricity?

Conductors vs Insulators

Conductors allow electricity to pass within, meaning that free electrons can move between atoms. They have different resistances to the flow of electrons depending on the type of conductors - superconductors have no resistance. Metals are generally really good conductors.

Insulators don’t allow electricity to pass through, meaning that they resist the movement of electrons between atoms. The reason why lightning travels through air is that if the electrons are strong enough / have enough energy they can change insulators to conductors. Rubbers are generally good insulators.

Charge

You can measure the flow/amounts of electrons with charge. The SI Unit of measurement for charge is a Coulomb which contains 6.24 x 10^18 electrons. Charge is the byproduct of chemical reactions in batteries, heat from nuclear sources or steam, or spinning wind turbine blades. These three examples are similar because they all lead to the movement of electrons, causing them to be charged.

Voltage

Voltage is the stored up energy between two points within a circuit. Its measured in Volts & defined as the amount of potential that leads 1 Joule of energy per Coulomb. This can be thought of through the height of water in a tank - the higher the water level, the more work each unit of water can do. Similarly a higher voltage would mean that each unit of charge has the ability to do more work.

Amperage

Amperage is the amount of charge in a single unit of time. It is defined as 1 Coulomb per second and measured in amps. A way to think about this is the speed of water flow. For example, a high speed of water which is the same pressure of low speed water transfers the same amount of energy, but in a faster time. Similarly, a higher current does the same amount of work as a lower current at the same voltage, but in a much faster time. This could be a potential storage drainer though.

Resistance

The resistance to the flow of electricity is measured in Ohms & is defined to be the resistance that 1 voltage => 1 amp of current. Lesser resistance means a smoother flow, and higher resistance limits the flow.

Ohm’s Law

Ohm’s law states that V = IR, V being voltage in volts, I being the current in amps, and R being the resistance in Ohms. This equation describes the relation of current, voltage, and resistance in conductivity in almost all electrically conductive objects (objects that don’t adhere to this law are known as non-ohmic materials, such as semiconductors)

Circuits

Circuits are full loops that allow the flow of electrons and electricity to be transferred from one place to another. We explored this with our online simulator that showed you how to create circuits. Open circuits (a gap somewhere within your loop) prevent your flow & stop it somewhere, and closed circuits allow the flow.

Example Problem: Which resistor do we need?

Ohm’s law is very useful when putting together electronics and staying safe. Let’s say you have a 9 volt battery. The recommended current for an LED (Light Emitting Diode) is 18 milliAmps (mA) or .018 Amps. What resistor should the circuit use?

Answer:

Using V=IR, we find that R = 500 Ohms. Using a 500 Ohm resistor in our circuit will prevent too much current from entering the LED and damaging it.

Types of Electrical Components

Wires

Wires conduct electricity, and connect together the different electrical components in a circuit, to make sure the energy flows throughout the entire system. The higher the amperage, the bigger the wire needs to be, because all wires have resistance, which will convert the electron flow into heat.

Switches/Buttons

Switches open and close a circuit, and can turn off the flow of electricity. There are two types of switches: momentary and latching. A momentary switch is like a button press, and will release if you let go. Latching switches stay in the position they move to, like a light switch. Within switches, there are different ways they can operate (single pull, single throw)

Voltage Sources

You need a voltage source in a circuit to push electrons through wires. Most common are batteries. Different voltage and different maximum current output. Measured in Amps per hour. Stacking more batteries will increase the voltage. Putting batteries next to each other will increase the current.

Resistor

Resistors provide resistance to the flow of electricity. Made of poor conductors such as carbon, provide different levels of heat resistance. Band code will show how much resistance each resistor will have. Measured in ohms.

Variable Resistors / Potentiometers

Variable resistor: used in volume control, or controlling a light. Works by having a wiper rotate along a resistor strip; the more distance between the wiper and the voltage source, the more resistance there will be.

Adding Resistors

Resistors connected in a series (in a line) vs parallel (electricity flows through at the same time)

Please watch our meeting recording (starting from 18:36 to 28:56) to view some example resistor problems, and see how to use them in an actual circuit!

Resistor Formulas

Total resistance in series: Sum of individual resistances

Total resistance in parallel: add all the reciprocals of resistors, then take the reciprocal of that value.

Capacitors

Capacitors temporarily store a charge on them. The amount of capacitance they have is measured using the formula q=CV, where q is the amount of charge they can store, C is the capacitance and V is the voltage.

Diodes / LEDs

Diodes only allow electricity to flow in 1 direction. They also create a nearly constant voltage drop. LED’s (Light Emitting Diodes) are diodes that produce light.

Transistors

Transistors are used as switches for electrical components. In a transistor, there are 3 connections, Source/Collector, Gate/Base, and Drain/Emitter. A voltage is applied to the source. If another lower voltage than the source is provided to the gate, the voltage applied at the source will be able to flow through to the drain. This means that transistors can be used to control higher currents / voltages. For example, transistors can be used to allow a device that uses 3.3 volt logic to control devices with 5 volt logic.

Integrated Circuits

Integrated circuits are a way of combining multiple electrical components into one, compact piece. Integrated circuits vary in size and complexity and have many different functions

How can we express circuits?

We can express circuit diagrams using symbols. These symbols make it easier for other people to replicate circuits or figure out how they work. There are many different diagram styles and standards, but many of the most basic components will be very similar on all circuit diagrams.

Breadboards

Breadboards make it easy to prototype with electrical components. Many electrical components work directly with breadboards and they allow you to easily connect components and build circuits.without soldering or complex wiring.

Summary

We know we just went over a lot of information but, trust us, it will all be important later on! In the next few meetings, we will be exploring applying these electrical knowledge to create actual IoT devices… stay tuned!

Control LED Lights

Tue, 06 Oct 2020 00:00:00 GMT

What you will need:

5mm LEDs
220 Ohm Resistor
2 Jump Wires
Node MCU/ESP8266
A Breadboard
Arduino IDE
A ThingSpeak Account

Project Background

This tutorial will walk you through how to build your own RGB lights that can be controlled from the internet! Through this project, you will learn the basics of electronics, hardware, and software by setting up your own light module and writing code to interact with ThingSpeak to control your light.

Setting up the LED Module

To set up the LED Module, we first place the NodeMCU on the breadboard by placing the port side of the Node facing outwards and firmly pressing the Node into the breadboard. Make sure the NodeMCU is completely inside the breadboard or else the module may not be powered properly.

Following this, add a jumper wire from the GND pin on the Node to the ”-” column on the breadboard. Following this, insert the longer side of the LED prong (Anode) into the same ”-” column where you placed the jump wire. Place the shorter side of the LED (Cathode) prong into another column in the breadboard.

Place a second jumper wire from the D7 pin on the Node to the same row as the shorter prong of the LED. Finally, place your resistor between both jump wires and the corresponding prong on the LED. The resistor is used to control the flow of current to LED.

Your board should look like this when you are done.

Connecting to ThingSpeak

Before you begin, make sure you create a ThingSpeak account first.

Steps:

Create a channel
1. In the “My Channels” page click on “New Channel”
2. Enter a name and brief description for your channel
3. Enable Field 1 by checking the checkbox and provide a name (The field corresponds to the led on your module)
4. Click “Save Channel”
Modify Channel Sharing Settings
1. After creating your channel, go the “Sharing” tab and enable “Share Channel With Everyone”
Copy Channel ID
1. Head to the “Channel Settings” tab and copy the “Channel ID” (you will need to input this ID in your code)

Once you have completed your steps, you are ready to move on! Check out our more detailed ESP ThingSpeak tutorial to learn more.

Controlling the LED

Open your Arduino IDE and ensure that you have the ESP8266 and ThingSpeak libraries installed.

In your file, add the code below. To connect to the internet you must first acquire your SSID and password of your wifi-router. In addition, paste the “Channel ID” you copied earlier into the “channel” variable.

#include "ThingSpeak.h"
#include <ESP8266WiFi.h>

// Replace your wifi credentials here
// ssid: your wifi name
// password: your wifi password
const char* ssid     = "YourWiFiName";
const char* password = "YourWiFiPassword";

// Replace with your own ThingSpeak Account Channel ID
unsigned long channel = 11111;

// 1 is a channel field. You don't need to change if you are following
// this tutorial. You can modify it according to your application
unsigned int led = 1;

WiFiClient  client;


void setup() {
  Serial.begin(115200);
  delay(100);
  
  pinMode(D7, OUTPUT);

  // We start by connecting to a WiFi network
 
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
 
  Serial.println("");
  Serial.println("WiFi connected");  
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  Serial.print("Netmask: ");
  Serial.println(WiFi.subnetMask());
  Serial.print("Gateway: ");
  Serial.println(WiFi.gatewayIP());
  ThingSpeak.begin(client);

}

void loop() {
 
  // get the last data of the fields
  int led_1 = ThingSpeak.readFloatField(channel, led);
  
  if(led_1 == 0){
    digitalWrite(D7, 1);
    Serial.println("D1 is On..!");
  }
  else if(led_1 == 1){
    digitalWrite(D7, 0);
    Serial.println("D1 is Off..!");
  }
    
  Serial.println(led_1);
  delay(5000);
}

After this is complete, connect your NodeMCU with a micro-usb cable to your laptop and upload the code by pressing Cmd/Ctrl + U. While it is uploading, click on Tools > Serial Monitor to view log updates (such as connecting to Wifi and LED status).

Following this, head back to your ThingSpeak channel, click on “API Keys” tab and copy the “Write to Channel Feed” API link. Paste the link in the browser and you should be all set! From this page, in the edit the url periodically, changing the “field1=” attribute to between 0 and 1 (this is to toggle the LED on and off). As you do this, you should see your LED turning on and off (there will be a delay) as well as status updates in the Serial Monitor Log.

After a couple of changes to the “field1” value, you should see some data in your chart! The data represents the time the LED status changed and the status it was changed to.

Congratulations on creating your own LED light module and controlling it using ThingSpeak!

Challenge: Create a software UI that allows you to toggle the status of the LED switch using the ThingSpeak API. This can be as simple as creating an on/off button using html which makes a GET request to the ThingSpeak API or as complicated as you would like!

Send us a message on Slack if you need help and make sure to join.tinoiot.com to join our groups : )

Our Links

Mon, 05 Oct 2020 00:00:00 GMT

Meeting link

Make sure you are using your student account (we won’t allow-in any other!) Right click on the link above -> Copy link address to save

Membership Form

Use this form to join our official communication channels!

Past Curriculum Slides

Revisit some of our old lessons to learn the fundamentals of software, hardware, and electric engineering!

Past Meeting Recordings

You can use this (or our meeting debriefs) to catch up on our lessons on IoT fundamentals. We will also post tutorial highlights on there to get you started on your own IoT adventures.

Parts Request Form

Looking for sensors, MCs, boards, wires, and more? Perhaps we have some. Fill out the form to get in contact with us : )

Introduction Slides

Quickly learn about what we do in the form of 8 slides!

Short Link To This Page

Feel free to share this with your friends and introduce them to IoT in a quick way

As always, feel free to message us with any questions regarding IoT.

Common Questions

Thu, 24 Sep 2020 00:00:00 GMT

Hi everyone! Below is a list of commonly asked questions (along with answers) during the first meeting today. Feel free to DM us for more specific questions :)

How do we get components for projects?

Components, as of now, can’t be lent out by us because of restrictions on in-person meetings. In short, it would be fastest to purchase from an online store if you want to get started right away (we always provide links to recommended retailers).

How much would these components cost?

The good thing about IoT is that it has a very very low barrier to entry. It cost less than 50 dollars to build our prototype doorbell camera. The most expensive component—the microcontroller—can be reused endless times for other projects. After the initial purchase of a microcontroller + breadboard kit, a typical project would cost around 10 dollars.

Would I be able to publish my own projects on tinoiot.com?

Yes… eventually. We are currently in the process of setting up a submission form and all posts will have to follow strict guidelines (and have to go through the mandatory review process).

When are the meetings?

Our meetings will be at 12pm, on Wednesdays. Please make sure to use your school email when joining our Zoom call at meet.tinoiot.com

How do I become a member? Are there requirements?

TinoIoT does not have requirements nor fees, visit join.tinoiot.com to get started!

What if I can’t make the meetings on Wednesday?

It would be best if you can make the bi-weekly meetings so you can ask questions and get more information / personalized help. However, we will be posting our slides on our website along with commentaries to help everyone stay on track with their projects.

Are the slides posted?

Of course! How could we not make another tiny link. Visit slides.tinoiot.com to view ALL of our slides. They will be posted and updated to that site every meeting.

Do I have to follow the curriculum / projects?

Nope. You are always welcome to start your own projects and you could always message us for any help. Our officers have a wide range of capabilities, feel free to ask about anything!

Make sure to join.tinoiot.com to get future announcements.

Air Quality Sensor

Sun, 20 Sep 2020 00:00:00 GMT

What you will need:

PMS5003 (pm2.5 sensor)
Esp8266 (nodemcu)
Arduino IDE
Breadboard and cables
ThingSpeak Account

Project Background

With ongoing fires, air pollution, and many harmful impurities in the air, it’s important to understand how the data you see from air quality maps come to be. This project guides you through how to set up your own iot project to measure pm2.5 (particulate matters), which is a significant factor in calculating aqi (air quality index).

This New York Department of Health article goes more in depth of the health hazards if you are interested: https://www.health.ny.gov/environmental/indoors/air/pmq_a.htm.

This monitoring project is made achievable via pms5003 sensor using light scattering principle, and that coupled with the esp over thingspeak allows for you to access the data from the pms over the internet.

Setting everything up / wiring

This step applies if your purchase came with a connector. If it doesn’t, go to the next step titled wiring from pms to esp.

The wiring for this module to its connector is as follows:

From Right to Left: Pin 1 Vcc: To Power supply (5V) Pin 2 GND: To gnd (negative power) Pin 3 SET: To SET, a TTL input signal Pin 4 RXD: To RXD, serial receiving Pin 5 TXD: To TXD, serial sending Pin 6 RST: To RST, which is reset signal

Be careful not to plug these in backwards.

The descriptions on the sensor saying ttl@3.3V simply indicates that any voltage applied that is below 3.3V will not work/run. That is why, in the next step, we have to connect to 5V on the esp.

If you skipped here without a connector, just follow the following steps, but use 4 male to male dupont cables directly from the black and red connector strip into the breadboard tie points (or breadholes, as we unironically call them) that match to each pin of the esp. 2 indents on the white connector should match up to the rails in the PMS’s sensor port. If you need to brush up on some breadboard how-to’s, refer to this post here. Remember - each connector and each pin should match to their respective destinations!

The wiring from the pms5003 sensor to the esp8266 is as follows: pms esp Pin 1 Vcc: To Vin Pin (5V) Pin 2 GND: To gnd Pin 3 TXD: To TXD (tx) Pin 4 RXD: To RXD (rx)

You may have realized by this point that wiring is pretty intuitive for the most part - everything just matches up to their names, or their name meanings.

Getting Thingspeak up and Running

Please get a thingspeak account set up. Then, please reference this article, Sending Sensor Data to ThingSpeak, to get some preliminary information on how to send live air sensor data and visualize/analyze said data via http and mqtt. However, instead of a BME280, it’ll be your pms5003 - focus on the setup as well as learning how to send live data, then come back here for a specific walkthrough. You could try this particular section of the Thingspeak walkthrough just to see some cool stuff happen - and to also test if you have all the wifi shenanigans done correctly.

We will be using it to monitor the particulate levels sensed. Create a channel (you can name it air quality system or anything you’d like), and keep track of the url under “white a channel feed” and set it under the correct server name. Again, all is shown in the above linked article if you’re confused.

Use the following code:

The setup loop takes care of making sure wifi is all set up properly. We will be graphing the values in ug/m3, with the x axis being time, or rather just timestamps.

// import statements allow for different types of sensors or controllers to be used
#include <ESP8266WiFi.h>
#include <Arduino.h>

#define LENG 31   // 0x42 + 31 bytes equal to 32 bytes
unsigned char buf[LENG];

// these declarations are used to track the values to then plot into thingspeak. upon initalization they'll be set to 0 as a baseline.
int PM01Value = 0;
int PM2_5Value = 0;
int PM10Value = 0;

// allow for data to be sent to your computer via wifi
const char *ssid = "YOUR_WIFI_NAME";
const char *password = "YOUR_WIFI_PASSWORD";

String serverName = "https://api.thingspeak.com/update?api_key=YOUR_WRITE_KEY";
WiFiClient client;

unsigned long lastTime = 0;
unsigned long timerDelay = 60000;

// the setup loop's purpose is just to ensure connectivity and that your wifi is working
void setup() {
    Serial.begin(9600);

    WiFi.begin(ssid, password);
    Serial.println("Connecting");
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("");
    Serial.print("Connected to WiFi network with IP Address: ");
    Serial.println(WiFi.localIP());
}

void loop() {
    // starts to read when it gets data from buffer
    if (Serial.find(0x42)) {
        Serial.readBytes(buf, LENG);

        // reads the sensor value in this loop and uses previous variable to keep track of it
        if (buf[0] == 0x4d) {
            if (checkValue(buf, LENG)) {
                PM01Value = transmitPM01(buf);  // count PM1.0 value of the air detector module
                PM2_5Value = transmitPM2_5(buf);  // count PM2.5 value of the air detector module
                PM10Value = transmitPM10(buf);  // count PM10 value of the air detector module
            }
        }
    }

// prints out the values read from the sensor out to your computer
    static unsigned long OledTimer = millis();
    if (millis() - OledTimer >= 1000) {
        OledTimer = millis();

        Serial.print("PM1.0: ");
        Serial.print(PM01Value);
        Serial.println("  ug/m3");

        Serial.print("PM2.5: ");
        Serial.print(PM2_5Value);
        Serial.println("  ug/m3");

        Serial.print("PM10 : ");
        Serial.print(PM10Value);
        Serial.println("  ug/m3");
        Serial.println();

        // if able to send data over to thingspeak, it will do so here, and allow it to be displayed. You can look at ts api for clarification as needed
        if (client.connect(server, 80)) {
            String postStr = apiKey;
            postStr += "&field1=";
            postStr += String(PM01Value);
            postStr += "&field2=";
            postStr += String(PM2_5Value);
            postStr += "&field3=";
            postStr += String(PM10Value);
            postStr += "\r\n\r\n";

            client.print("POST /update HTTP/1.1\n");
            client.print("Host: api.thingspeak.com\n");
            client.print("Connection: close\n");
            client.print("X-THINGSPEAKAPIKEY: " + apiKey + "\n");
            client.print("Content-Type: application/x-www-form-urlencoded\n");
            client.print("Content-Length: ");
            client.print(postStr.length());
            client.print("\n\n");
            client.print(postStr);
        }
        client.stop();
    }
}

char checkValue(unsigned char *thebuf, char leng) {
    char receiveflag = 0;
    int receiveSum = 0;

    for (int i = 0; i < (leng - 2); i++) {
        receiveSum = receiveSum + thebuf[i];
    }
    receiveSum = receiveSum + 0x42;

    // check the serial data
    if (receiveSum == ((thebuf[leng - 2] << 8) + thebuf[leng - 1])) {
        receiveSum = 0;
        receiveflag = 1;
    }
    return receiveflag;
}

int transmitPM01(unsigned char *thebuf) {
    int PM01Val;
    PM01Val = ((thebuf[3] << 8) + thebuf[4]);  // count PM1.0 value of the air detector module
    return PM01Val;
}

// transmit PM Value to PC
int transmitPM2_5(unsigned char *thebuf) {
    int PM2_5Val;
    PM2_5Val = ((thebuf[5] << 8) + thebuf[6]);  // count PM2.5 value of the air detector module
    return PM2_5Val;
}

// transmit PM Value to PC
int transmitPM10(unsigned char *thebuf) {
    int PM10Val;
    PM10Val = ((thebuf[7] << 8) + thebuf[8]);  // count PM10 value of the air detector module
    return PM10Val;
}

In a few minutes, you should now see 3 live data plots graphing pm1, 2.5, and 10! Congrats!

All About IoT

Sat, 22 Aug 2020 00:00:00 GMT

What is IoT?

IoT, internet of things, refers to the billions of physical devices that are connected to each other via the internet and sharing data and other information. Thanks to the arrival of affordable computer chips and the commonality of wireless networks, it is more simple than ever to turn anything into a part of the IoT. By connecting these devices together, adding sensors and writing software to read and manipulate data, these devices are now becoming smarter than ever and are adding an aspect of digital intelligence to our daily lives.

Examples of IoT

As IoT continues to grow, its products are becoming more prevalent than ever in a society. One of the most popular IoT implementations is smart homes. Smart Home appliances are one of the most affordable and valuable IoT products on the market as the devices communicate with one another to create a smooth flow of data transmission. Some of the most common appliances are Amazon Alexa, Nest thermostat, and much more! Other common examples of IoT include smartwatches, temperature sensors, GPS trackers, and smart doorbells.

Why IoT Matters

In IoT, devices are connected to the internet where they are equipped with the capabilities to collect, send, and receive data. From a consumer point of view, IoT devices increase the efficiency of tasks and are able to perform them autonomously.

Let’s take a smart doorbell for example. Smart doorbells allow you to monitor the activity near the front of your house, be it a guest, mail package, or even a thief. By replacing the peephole on common doors, smart doorbells are able to act on its own and notify users when activity is noticed outside their front door by streaming video to the user’s mobile devices. Not only does this alleviate the burden of checking your front door but also ensures the user’s safety by enabling them to view and communicate to those outside their home.

To be rendered as “smart”, a device doesn’t need to have a powerful brain of its own, all it requires is to be connected to a more powerful machine. A connection is the principle of the IoT.

In the Internet of Things, a connection is used for 2 primary purposes:

To collect and send data
To receive and act on data

All of these fundamentals are vital to building a rudimentary IoT device.

Collecting and Sending Information

The collection of data is performed through the use of sensors. Sensors are distributed in various forms: motion sensors, pressure sensors, temperature sensors, air quality sensors, and so on. When connected to the internet, these senors are automatically able to collect the data we need and upon request, send the data over the internet to servers or to other IoT devices.

Receiving and Responding to Information

Upon receiving information from sensors, the information is either kept static for analytical/display purposes or is manipulated to derive further information.

In our day to day lives, we are often blind to the occurrences of data manipulation. For example, your printer receives a document sent by your laptop/mobile device and prints it out. Your car key, when “unlock” is pressed, sends a signal to your car which unlocks the door.

What’s Next?

The potential of the IoT is endless and as Bruce Schneier says,

“The internet is no longer a web that we connect to. Instead, it’s a computerized, networked, and interconnected world that we live in. This is the future, and what we’re calling the Internet of Things.”

If you are interested in learning more about the IoT and building IoT projects of your own, you’ve come to the right place! Stay tuned to our blogs as we will be posting more articles and tutorials on how you can kickstart your journey into the Internet of Things.

Sending Sensor Data to ThingSpeak (esp32)

Sat, 22 Aug 2020 00:00:00 GMT

What you will need:

Adafruit BME280 - You could use any sensor you want, you’ll just have to figure out how to interface with it on your own.
Adafruit HUZZAH32 – ESP32 Feather Board
Jumper Wires
Bread board - Recommended for keeping things organized but not necessary.
Arduino IDE
A few Arduino Libraries for connecting to the internet and simplifying using the bme280 (We will get to these later)
ThingSpeak Account - It’s free for up to 4 channels, which is plenty.

Project Overview

This project is meant to give you a practical example of what you can do with IoT skills. We will be using the esp32 huzzah feather board as our microcontroller because it has the esp32 chip that can connect to the internet. We will use this connectivity to send an HTTP GET request to ThingSpeak periodically so we can chart the temperature where ever we decide to place our device.

Setting up our Board

Install the Arduino ide on your computer by following the instructions here.

Download the proper USB driver for your system here.

Next, we need to install the esp32 board in the Arduino ide. Run your ide and navigate to the preferences window. Enter https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json in the Additional Board Manager URLs field. Then open the board manager (Tools > Board > Board Manager) and search for esp32. Now Install esp32. Then open your boards again and select Board > ESP32 Arduino > Adafruit ESP32 Feather. To verify that you have everything set up correctly, you can run the following program to your board:

// Code that runs once at the beginning
void setup(){
  pinMode(13, OUTPUT); // Sets the digital pin 13 as output
}


// Code that runs repeatedly after setup
void loop(){
  digitalWrite(13, HIGH); // Set the digital pin 13 on
  delay(1000); // Wait 1000 ms
  digitalWrite(13, LOW); // Set the digital pin 13 off
  delay(1000);
}

If everything is good, you should see a red light blink on the board.

Installing Libraries

Now we are going to install libraries to make it easier for us to interface with the bme280 and connect to the internet.

Go to Tools > Library Manager, type in Adafruit BME280 Library, and install it. It will prompt you to install other dependency libraries. Select Install All.

Wiring

Connect the following pins with jumper wires (esp32 to bme280): 3V to VIN GND to GND SCL to SCK SDA to SDI You can test if everything is wired correctly by running Adafruits example. It can be found at File > Examples > Adafruit BME280 Library > bme280test. Because we are using I2C with the default pins, we don’t have to modify anything in the example code. Run it and then open the Serial Monitor (Tools > Serial Monitor). You should see readings every second for each of the sensors that look something like this:

Temperature = 24.93 *C
Pressure = 1004.25 hPa
Approx. Altitude = 75.19 m
Humidity = 47.32 %

Setting up ThingsSpeak

First, create a ThingsSpeak account here. Then go to the channels tab and click Create New. Name the channel something like BME280 or Sensor Test, whatever you want. Check the boxes for four fields, and enter the names Temperature, Pressure, Altitude, Humidity. Ignore the rest of the text inputs and click Save Channel.

Now that we have our channel set up, go to the API Keys tab. Take note of the URL under Write a Channel Feed. It should look something like https://api.thingspeak.com/update?api_key=<YOUR KEY>&field1=0. Your key is the most important part and is what will allow you to get to your thing speak channel.

Sending Data to Thing Speak

Now let’s try sending some data to each of our channels four fields. Try out this code. Make sure to replace “ssid” with your wifi name, “password” with your wifi password, and the “serverName” with your own from ThingSpeak.

// Import nessesary libraries
#include <WiFi.h>
#include <HTTPClient.h>

// Set our wifi name and password
const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";

// Your thingspeak channel url with api_key query
String serverName = "https://api.thingspeak.com/update?api_key=YOUR_WRITE_KEY";

// Assign some variables to allow us read and send data every minute
unsigned long lastTime = 0;
unsigned long timerDelay = 60000;


void setup() {
  Serial.begin(9600); // Opens up the serial port with a baudrate of 9600 bits per second


  WiFi.begin(ssid, password); // Attempt to connect to wifi with our password
  Serial.println("Connecting"); // Print our status to the serial monitor
  // Wait for wifi to connect
  while(WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to WiFi network with IP Address: ");
  Serial.println(WiFi.localIP());
}


void loop() {
  if ((millis() - lastTime) > timerDelay) { // Check if its been a minute
    if(WiFi.status()== WL_CONNECTED){ // Check to make sure wifi is still connected
      sendData(1, 2, 3, 4); // Call the sendData function defined below
    }
    else {
      Serial.println("WiFi Disconnected");
    }
    lastTime = millis();
  }
}


void sendData(double temp, double pres, double alt, double hum){
  HTTPClient http; // Initialize our HTTP client


  String url = serverName + "&field1=" + temp + "&field2=" + pres + "&field3=" + alt + "&field4=" + hum; // Define our entire url
      
  http.begin(url.c_str()); // Initialize our HTTP request
      
  int httpResponseCode = http.GET(); // Send HTTP request
      
  if (httpResponseCode > 0){ // Check for good HTTP status code
    Serial.print("HTTP Response code: ");
    Serial.println(httpResponseCode);
  }else{
    Serial.print("Error code: ");
    Serial.println(httpResponseCode);
  }
  http.end();
}

First we define your home wifi credentials, ssid and password. We begin our connection and wait.
Every minute we call the sendData(1, 2, 3, 4); function. In the function we take the paramaters and add them to our url query string.
Finaly we send the GET request and print to the serial that we sucseded.

Again check the serial monitor to see if you connected to wifi and when the data is sent. It will take 60 seconds to send first and then send again every 60. You should see the points show up on your charts.

Right now we are just adding the values 1, 2, 3, and 4 to the charts repeatedly. Let’s try to get our live sensor data in there now.

Sending Live Data to ThingSpeak

Now we are going to combine everything to finaly get our data from the sensor then send it to our ThingSpeak channel. You will probobly want to clear your channel before you start getting real data. To clear it go to Channel Settings and click Clear Channel at the bottom of the page.

// Import nessisary libraries
#include <WiFi.h>
#include <HTTPClient.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

// Set our sealevel pressure
#define SEALEVELPRESSURE_HPA (1013.25)


const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";


String serverName = "https://api.thingspeak.com/update?api_key=FL36D2MOEQ9HTM86";


unsigned long lastTime = 0;
unsigned long timerDelay = 60000;

Initialize the bme280 object
Adafruit_BME280 bme;


void setup() {
  Serial.begin(115200); 


  initBme280(); // Initialize the bme280


  WiFi.begin(ssid, password);
  Serial.println("Connecting");
  while(WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to WiFi network with IP Address: ");
  Serial.println(WiFi.localIP());
}


void loop() {
  if ((millis() - lastTime) > timerDelay) {
    if(WiFi.status()== WL_CONNECTED){
// Read data from our bme280 object and pass it to our sendData function 
sendData(bme.readTemperature(), bme.readPressure() / 100.0F, bme.readAltitude(SEALEVELPRESSURE_HPA), bme.readHumidity());
    }
    else {
      Serial.println("WiFi Disconnected");
    }
    lastTime = millis();
  }
}


void sendData(double temp, double pres, double alt, double hum){
    HTTPClient http;


    String url = serverName + "&field1=" + temp + "&field2=" + pres + "&field3=" + alt + "&field4=" + hum;
      
    http.begin(url.c_str());
      
    int httpResponseCode = http.GET();
      
    if (httpResponseCode > 0){
      Serial.print("HTTP Response code: ");
      Serial.println(httpResponseCode);
    }else{
      Serial.print("Error code: ");
      Serial.println(httpResponseCode);
    }
    http.end();
}


void initBme280(){
  unsigned status;
    
  status = bme.begin();  
  if (!status) {
      Serial.println("Could not find a valid BME280 sensor, check wiring, address, sensor ID!");
      Serial.print("SensorID was: 0x"); Serial.println(bme.sensorID(),16);
      Serial.print("        ID of 0xFF probably means a bad address, a BMP 180 or BMP 085\n");
      Serial.print("   ID of 0x56-0x58 represents a BMP 280,\n");
      Serial.print("        ID of 0x60 represents a BME 280.\n");
      Serial.print("        ID of 0x61 represents a BME 680.\n");
      while (1) delay(10);
  }
  Serial.println("BME280 Initialized");
  Serial.println();
}

First we initialize the bme object and call the initBme280() function to ensure that we have the sensor connected correctly.
We then pass bme.readTemperature(), bme.readPressure(), bme.readAltitude(SEALEVELPRESSURE_HPA), and bme.readHumidity() into our sendData() function from before.

Congrats! You should now have live data once a minute. If you ever want to change that time, simply change the timerDelay to the number of millis you want it to wait.

Whats next?

Hopefully, from this, you have learned enough to be able to figure out how to send any kind of data you want to ThingSpeak so you could explore some more on your own.

There are some other kinds of visualizations that ThingSpeak has available for your data that you could check out.
Make your channel public and share it with your friends.
Try reading data from ThingSpeak using GET requests, as shown in the API Keys tab.
You could also want to add something to catch if the network goes down and then keep trying to reconnect so that you don’t ever have to restart your device.

Sending Sensor Data to ThingSpeak (RasPi)

Wed, 12 Aug 2020 00:00:00 GMT

What you will need:

Adafruit BME280 - You could use any sensor you want, you’ll just have to figure out how to interface with it on your own.
Raspberry Pi (RasPi) - I’ll be using a 4B, but you should be able to use any model you want with wifi.
Jumper Wires
A few python modules for simplifying using the bme280 (We will get to this later)
ThingSpeak Account - It’s free for up to 4 channels, which is plenty.

Project Overview

This project is meant to give you a practical example of what you can do with IoT skills. We will be using the RasPi because it has a wifi chip and GPIO (General Purpose Input Output pins). We will use this connectivity to send an HTTP GET request to ThingSpeak periodically so we can chart the temperature wherever we decide to place our device.

Setting up our RasPi

Make sure you have python3 and pip set up first.

Next, we have to enable I2C on our RasPi. I2C is a common protocol for sending data. In your shell, run sudo raspi-config in the shell. Then select Interfacing Options > I2C > yes.

Now we are going to install some python modules. In your shell run pip3 install RPI.GPIO then pip3 install adafruit-blinka then pip3 install requests

Wiring

Connect the following pins with jumper wires (RasPi to bme280): 3V to VIN 3V to CS GND to GND SCL to SCK SDA to SDI If your not sure, here is the pinout for most RasPis.

Reading the BME280

Let’s verify that we have everything wired and set up correctly by attempting a read. Try out the following code:

# Import necessary modules
import board, busio, adafruit_bme280

i2c = busio.I2C(board.SCL, board.SDA)

bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)
bme280.sea_level_pressure = 1013.4

# Printing out our temp, humity, pressure, and altitude data by refencing our bme280 object.
print("\nTemperature: %0.1f C"  % bme280.temperature)
print("Humidity: %0.1f %%"  % bme280.humidity)
print("Pressure: %0.1f hPa"  % bme280.pressure)
print("Altitude = %0.2f meters"  % bme280.altitude)

First, we created an i2c object that we can reference by passing in our board.SCL and board.SDA pins.
The we created a bme2280 object by passing in our i2c object. We reference this object to get readings from our sensor.
- The sea_level_pressure of the bme280 is defined for my location. Depending on where you are this might be different
Finally we print our data by referencing our bme280. Don’t worry if you don’t understand the %0.1f. It’s just a way to format strings.

When you run the code, you should see something like this in the shell:

Temperature: 23.1 C
Humidity: 80.9 %
Pressure: 1004.9 hPa
Altitude = 70.90 meters

Setting up ThingsSpeak

Sending Data to Thing Speak

Now let’s try sending some data to each of our channels four fields. Try out this code. Make sure to replace “YOUR_WRITE_KEY” with your own from ThingSpeak.

# Import the request module
import requests

queries = {"api_key": "YOUR_WRITE_KEY",
               "field1": 1,
               "field2": 2, 
               "field3": 3,
               "field4": 4}
r = requests.get('https://api.thingspeak.com/update', params=queries)
if r.status_code == requests.codes.ok:
    print("Data Received!")
else:
    print("Error Code: " + str(r.status_code))

First, we create a dictionary object, queries. This is a cleaner way to add the queries at the end of our URL. For example the key-value pair "api_key": "YOUR_WRITE_KEY" would add ?api_key=YOUR_WRITE_KEY.
We then pass the queries dictionary, and the beginning of the ThingSpeak URL to our requests modules GET request. An HTTP GET request is a way for us to communicate over the internet.
The result of the request is assigned to the object r. We then check if the status_code is ok, meaning that our data was successfully received by ThingSpeak. If the status is not ok, we report the error. Here is a list of status codes if you want to learn more.

When you run this, you should see one point of data in each of the four fields on ThingSpeak and Data Received! in your shell.

Right now we are just adding the values 1, 2, 3, and 4 to the chart. Let’s try to get our live sensor data in there now.

Sending Live Data to ThingSpeak

Now we will combine everything to finally get our data from the sensor and then send it to our ThingSpeak channel. You will probably want to clear your channel before you start getting real data. To clear it, go to Channel Settings and click Clear Channel at the bottom of the page. We are also using the python scheduler module, which will allow us to set an interval for polling data.

# Import necessary modules
import board, busio, adafruit_bme280
import requests
import sched, time

# Set up I2C and bme280 objects
i2c = busio.I2C(board.SCL, board.SDA)
bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)
bme280.sea_level_pressure = 1013.4

# Create our scheduler to run every n seconds
s = sched.scheduler(time.time, time.sleep)
interval = 60

# Definition to read sensor data and send it to ThingSpeak
def read_and_send(sc): 
	# Read bme280 and set the query string
    queries = {"api_key": "YOUR_WRITE_KEY",
               "field1": round(bme280.temperature, 2),
               "field2": round(bme280.pressure, 2), 
               "field3": round(bme280.altitude, 2),
               "field4": round(bme280.humidity, 2)}
    # Send the request to ThingSpeak
    r = requests.get('https://api.thingspeak.com/update', params=queries)
    # Verify that ThingSpeak recived our data
    if r.status_code == requests.codes.ok:
        print("Data Recived!")
    else:
        print("Error Code: " + str(r.status_code))
    # Re-add this definition to run again in n seconds    
    s.enter(interval, 1, read_and_send, (sc,))

# Add our read_and_send task to the scheduler and run it.
s.enter(interval, 1, read_and_send, (s,))
s.run()

We use the sched module to easily repeat every n seconds. If you ever want to change that time, simply change the interval to the number of seconds you want it to wait.

Congrats! You should now have live data once a minute.

Whats next?

Hopefully, from this, you have learned enough to figure out how to send any kind of data you want to ThingSpeak so you could explore some more on your own.

There are some other kinds of visualizations that ThingSpeak has available for your data that you could check out.
Make your channel public and share it with your friends.
Try reading data from ThingSpeak using GET requests, as shown in the API Keys tab.

Your Site's RSS Feed

About Us

Our Objective

Club Mission

The TinoIOT Experience

Officer Team

Shrinandan Narayanan

Krisha Chokshi

Max Liu

Ryan Hsieh

Sungmin Baik

Ishan Juneja

Arnav Deshpande

Final Notes

Ring Door Bell Clone Part 1

Introduction

Requesting Parts

Board Overview

Programming the Board

ESP32-CAM Code Explanation

Next Steps

First Meeting of Second Semester

Update on kits…

Introduction to Electronics

A Short Brief

What is Electricity?

Conductors vs Insulators

Charge

Voltage

Amperage

Resistance

Ohm’s Law

Circuits

Example Problem: Which resistor do we need?

Types of Electrical Components

Wires

Switches/Buttons

Voltage Sources

Resistor

Variable Resistors / Potentiometers

Adding Resistors

Resistor Formulas

Capacitors

Diodes / LEDs

Transistors

Integrated Circuits

How can we express circuits?

Breadboards

Summary

Control LED Lights

What you will need:

Project Background

Setting up the LED Module

Connecting to ThingSpeak

Controlling the LED

Our Links

Meeting link

Membership Form

Past Curriculum Slides

Past Meeting Recordings

Parts Request Form

Introduction Slides

Short Link To This Page

Common Questions

How do we get components for projects?

How much would these components cost?

Would I be able to publish my own projects on tinoiot.com?

When are the meetings?

How do I become a member? Are there requirements?

What if I can’t make the meetings on Wednesday?

Are the slides posted?

Do I have to follow the curriculum / projects?

Air Quality Sensor

What you will need:

Project Background

Setting everything up / wiring

Getting Thingspeak up and Running

All About IoT

What is IoT?

Examples of IoT