Components Needed

• ESP8266 Development Board (e.g., NodeMCU or Wemos D1 Mini)
• MQ-135 Gas Sensor (detects gases such as ammonia, sulfide, and benzene steam)
• Jumper wires
• Breadboard (optional)
• USB Cable for ESP8266

Step 1: Setting Up the Arduino IoT Cloud Account

1. Go to the Arduino IoT Cloud website and create an account if you don't have one.
2. Once logged in, navigate to IoT Cloud and select Create New Thing.

Step 2: Setting Up Your IoT Thing and Variables

1. Name the Thing as "Gas Leak Sensor".
2. Add a Variable:
   • Name: GasLevel
   • Type: Float
   • Permission: Read Only
   • Update Policy: On Change
   • Threshold: 0
3. This variable will hold the gas level value from the MQ-135 sensor, which will be updated on the Arduino Cloud.

Step 3: Connect the ESP8266 to Arduino IoT Cloud

1. Go to Devices under Arduino Cloud and select Add Device.
2. Choose Set up a Third Party Device and select ESP8266.
3. You can also specify which ESP8266 board you are using. I am using WeMos Mini D1 for this example.
4. Follow the prompts to name your device and generate an API Key.
5. Once the device is registered, download the device Secret Key and store it safely; this will be needed in the code.

Step 4: Circuit Connection

1. MQ-135 to ESP8266 Wiring:
   • Connect VCC of the MQ-135 to 3.3V of the ESP8266.
   • Connect GND to GND on the ESP8266.
   • Connect Analog Output (AO) of the MQ-135 to the A0 pin on the ESP8266 (ESP8266 has only one analog pin, A0).

Step 5: Installing Required Libraries

Open the Arduino IDE (make sure it’s the latest version).

1. Install ArduinoIoTCloud and Arduino_ConnectionHandler libraries:
   • Go to Tools > Manage Libraries...
   • Search for and install the ArduinoIoTCloud library.
   • Repeat for the Arduino_ConnectionHandler library.
2. If you haven’t yet installed ESP8266 board support:
   • Go to File > Preferences and add http://arduino.esp8266.com/stable/package_esp8266com_index.json to the Additional Board Manager URLs.
   • Go to Tools > Board > Boards Manager..., search for ESP8266 and install it.

Step 6: Coding the ESP8266

Here’s the code to set up the ESP8266 to send gas sensor readings to the Arduino IoT Cloud.

1. Open a new sketch in Arduino IDE.
2. Replace SECRET_SSID and SECRET_PASS with your Wi-Fi credentials, and DEVICE_ID and SECRET_KEY with your Arduino Cloud device credentials.

#include "thingProperties.h"

// Analog pin for the MQ-135 sensor
const int mq135Pin = A0;
float gasLevel = 0;

void setup() {
  // Initialize serial and IoT Cloud properties
  Serial.begin(115200);
  delay(1500); 
  initProperties();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);

  // Wait for connection to the cloud
  while (!ArduinoCloud.connected()) {
    ArduinoCloud.update();
    delay(500);
  }
  Serial.println("Connected to Arduino IoT Cloud.");
}

void loop() {
  ArduinoCloud.update();

  // Read sensor value from MQ-135
  int sensorValue = analogRead(mq135Pin);

  // Convert the sensor value to a meaningful level
  gasLevel = sensorValue * (5.0 / 1023.0);

  // Log the gas level
  Serial.print("Gas Level: ");
  Serial.println(gasLevel);

  // Update cloud variable
  GasLevel = gasLevel;

  delay(1000);  // Adjust delay as needed
}

Step 7: Configuring Thing Properties

Before uploading, you need to configure thingProperties.h for your project:

1. Open thingProperties.h by selecting Sketch > Show Sketch Folder and finding thingProperties.h.
2. Set up your setupProperties() function to sync with the cloud variable:

#include <ArduinoIoTCloud.h> 
#include <Arduino_ConnectionHandler.h>

const char DEVICE_ID[] = "your_device_id";
const char SSID[] = SECRET_SSID;
const char PASS[] = SECRET_PASS;

void initProperties() {
  ArduinoCloud.setThingId(DEVICE_ID);
  ArduinoCloud.addProperty(GasLevel, READ, ON_CHANGE, NULL);
}

WiFiConnectionHandler ArduinoIoTPreferredConnection(SSID, PASS);

Step 8: Uploading the Code

1. Select your ESP8266 board and correct COM port in Tools.
2. Upload the code to your ESP8266.
3. Open the Serial Monitor (set it to 115200 baud rate) to confirm that your ESP8266 connects to Wi-Fi and begins sending gas level readings.

Step 9: Monitoring the Gas Levels on Arduino IoT Cloud

1. Return to Arduino IoT Cloud and open your Thing.
2. You should see the GasLevel variable updating in real-time.
3. Optionally, set up dashboards or notifications for specific thresholds if you want alerts.

Step 10: (Optional) Adding a Visual Dashboard

1. Under Arduino IoT Cloud, go to Dashboards and select Build Dashboard.
2. Add a Gauge Widget for real-time monitoring.
3. Link the GasLevel variable to the gauge.

Summary

You’ve now set up an IoT gas leak sensor with ESP8266 and MQ-135, with real-time monitoring through the Arduino IoT Cloud. This setup can serve as an effective safety tool to monitor potentially hazardous gas levels in your home or workspace.

The post ESP8266 IoT Gas Leak Sensor with Arduino Cloud appeared first on Teach Me Microcontrollers!.

Materials

• HC-SR04 Ultrasonic Sensor
• WeMos D1 Mini or Arduino Pro Mini (5V, 16 MHz)
• Solenoid Lock
• Relay Module
• 2N7000 MOSFET
• LM2596 DC-DC Converter
• 3-6 V Buzzer
• 9-12 V DC Power Supply

Wiring Diagram

About the Project

The HC-SR04 produces an ultrasonic signal which bounces back to it when there’s an object in front. The distance of the object from the sensor is known through the time difference between sending the signal (trigger) and receiving back the signal (echo) then multiplying by half of the speed of sound.

In the equation above, 0.034 is the speed of sound in centimeters (CM).

I set the trigger distance to 10 CM, i.e., the solenoid triggers every time an object is within 10 CM from the sensor. Solenoid locks require a high current to trigger and may produce unwanted flyback. Thus, the solenoid and the microcontroller must be isolated.

A MOSFET is used to drive the solenoid which requires 9-12 VDC and 1 A of current. The higher voltage is converted to 5 VDC using the LM2596 DC-DC converter. The MOSFET is, in turn, driven by a relay module by shorting its gate to the 5 VDC source. The MOSFET and relay combination ensures that the microcontroller is properly isolated from the solenoid. A buzzer is added to indicate that the lock has been released.

WiFi App

If a WeMos D1 Mini is used instead of the Arduino Pro Mini, the lock can be triggered remotely using WiFi. This is done through the MQTT protocol. I created a simple web app that sends a command to the MQTT broker when a button is pushed. The broker, in turn, publishes the command to a topic where the WeMos D1 Mini is listening to. Here’s a screenshot of the web app, viewed from a smartphone:

The Arduino sketch and code for the web app (remote trigger) are found in this repository.

How to Get Parts

For those living in the US or Europe who would like to clone this project, I strongly recommend getting the parts at UTSource. They support almost all global payment options and shipping and they have refurbished parts that are very much cheaper compared to new ones. For example, their refurbished original Arduino UNO is:

In comparison, here’s the price for the board from other stores:

I've experienced using refurbished Arduino's before and I can say it still performs like a new one.

Kindly share this project with others if you find it to be useful. Thanks for reading!

The post Ultrasonic Door Lock with WiFi Control appeared first on Teach Me Microcontrollers!.

Materials

• WeMos D1 Mini
• Tower Pro SG90 Micro Servo
• Connecting wires, power source

The WeMos D1 Mini is one of the smallest breakout boards for the ESP8266. In this project, I will write the code for the WeMos D1 using the Arduino IDE.

All digital pins of the WeMos D1 Mini support PWM so there’s a lot of options in connecting the servo motor. I will presume that you already know how a servo motor works with a microcontroller.

The SG90 servo motor was chosen primarily because of its lower power consumption. I haven’t tried a larger servo motor but I presume using it, with the WeMos D1 on WiFi, will strain the device.

Wiring Diagram

The WeMos D1 Mini connects to the servo motor as shown:

As previously mentioned, all digital pins of the WeMos D1 Mini supports PWM. I chose D4 because it’s the closest one to the power pins.

WiFi Servo Controller App

Most WiFi servo controllers I see use buttons to move the servo motor arm between positions. For this project, I decided to use a rotating wheel to move the servo motor arm.

To achieve this, I need to use JQuery UI to make the wheel rotatable and then AJAX to send the angle of the wheel to be read by the WeMos D1 server. JQuery UI is for desktop web applications so I also needed to add a plugin for the app to work on touch devices. Finally, I also used bootstrap to position the elements on the app.

All in all, these were the needed Javascript libraries:

<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script>
<script type='text/javascript' src='https://code.jquery.com/ui/1.11.4/jquery-ui.js'></script>
<script type='text/javascript' src='https://www.jqueryscript.net/demo/jQuery-UI-Rotatable-Elements/jquery.ui.rotatable.js'></script>
<script src='https://cdnjs.cloudflare.com/ajax/libs/jqueryui-touch-punch/0.2.3/jquery.ui.touch-punch.min.js'></script>
<script src='https://maxcdn.bootstrapcdn.com/bootstrap/3.4.1/js/bootstrap.min.js'></script>

These are all in the <head> tag of the app.

Here’s the HTML code for the <body> of the app:

<div class='container'>
  <h1>WeMos D1 Servo Controller</h1> "
  <h4>Rotate wheel to rotate servo</h4>"
  <a href='https://www.teachmemicro.com/wifi-servo-controller-using-wemos-d1-mini'>Full tutorial</a>"
  <div class='row'>
     <div class='col-xs-12'>
       <div id='wheel'></div>
     </div>
     <div class='col-xs-12'>
        <img id='tmm-logo' src='https://i.imgur.com/G80eVhL.png' />
      </div>
   </div>
</div>

$(document).ready(function(){
            $('#wheel').draggable({handle: '.ui-rotatable-handle'}).rotatable({
               rotate: function(e, ui){
               var degrees = ui.angle.current * 180/Math.PI;
               if ( degrees > 90 ) {    
                  ui.angle.current = Math.PI/2;    
               } else if ( degrees < -90) {        
                  ui.angle.current = -1*Math.PI/2;  
               }
               degrees = degrees + 90;
               console.log(degrees);
               var s = String(degrees);
            $.ajax({
               type: 'POST',
               url: 'dataHandler',
               data: s,
               contentType: 'application/x-www-form-urlencoded'
            });
           },snap: true   //for the wheel to snap at discrete angles
          });
});;

$('#wheel').draggable({handle: '.ui-rotatable-handle'}).rotatable({
               rotate: function(e, ui){
               var degrees = ui.angle.current * 180/Math.PI;
               ...

  if ( degrees > 90 ) {    
      ui.angle.current = Math.PI/2;    
  } else if ( degrees < -90) {        
      ui.angle.current = -1*Math.PI/2;  
  }
  ...

    ...
    degrees = degrees + 90;
    console.log(degrees);    //for debugging on the browser
    var s = String(degrees);
    $.ajax({
         type: 'POST',
         url: 'dataHandler',
         data: s,
         contentType: 'application/x-www-form-urlencoded'
    });

//Home page. Contents of 'page' is in mainpage.h
server.on("/", []() {
  server.send(200, "text/html", page);
});
//JavaScript! Contents of 'javascript' is in jscript.h
server.on("/jscript.js", []() {
  server.send(200, "text/javascript", javascript);
});
//POST data handler
server.on("/dataHandler",HTTP_POST,dataHandler);
//start web server
server.begin();
//Just stating things
Serial.println("HTTP server started");
}

<script type='text/javascript' src='jscript.js'></script>

//JavaScript! Contents of 'javascript' is in jscript.h
server.on("/jscript.js", []() {
  server.send(200, "text/javascript", javascript);
});

//POST data handler
server.on("/dataHandler",HTTP_POST,dataHandler);

void dataHandler(){
  String angle = server.arg("plain");
  Serial.print("Received: ");
  Serial.println(angle);
  server.sendHeader("Location","/");
  server.send(303);
  int pos = angle.toInt();
  myservo.write(pos);
  delay(15);
}

String angle = server.arg("plain");

Serial.print("Received: ");
Serial.println(angle);

server.sendHeader("Location","/");
server.send(303);

int pos = angle.toInt();
myservo.write(pos);
delay(15);

The post WiFi Servo Controller using WeMos D1 Mini appeared first on Teach Me Microcontrollers!.

What You’ll Need

• Flame sensor module
• Microcontroller (Arduino or NodeMCU ESP8266 or PIC)
• Power source
• Output device (buzzer or smartphone)

Flame Sensor Module

The star of this project is this flame sensor module:

This module contains a phototransistor and signal conditioning electronics. A phototransistor conducts more electrical current when exposed to light. Physics taught us that (visible) light comprises of all colors, from red to violet. By coating the phototransistor with black epoxy, it becomes more sensitive to red or even invisible below red or infrared. Interestingly, flame emits infrared radiation. Thus, when this sensor sees flame, it conducts more current.

Microcontrollers read voltage, not current. Thus, the signal conditioning circuit in the module converts the current into levels of voltage that is considered safe for the microcontroller (typically, the maximum voltage should be the supply voltage to the microcontroller).

The flame sensor module also contains indicator LEDs. One LED lights up (PWR-LED) when the module is powered up while another lights up (D0-LED) when the sensor detects fire.

Moreover, the voltage from the D0 pin falls to zero in the vicinity of fire and rises to the supply voltage when there is none. We use this as a trigger for the microcontroller.

Arduino - Flame Sensor Interface

I aim to use three different kinds of microcontroller for this project. First, I’ll show how to build an Arduino flame sensor with a buzzer as indicator.

Since the module only provides two values, on and off, we don’t need to use any of the analog pins of the Arduino. The wiring diagram below shows that the D0 pin of the module connects to the digital pin 2 of the Arduino UNO:

Moreover, the VCC or + pin connects to 5V and the G pin is connected to GND. Note that the fire detector module can also run on 3.3V. Finally, the buzzer’s red wire is connected to pin 5 while its black pin is wired to GND. In this project, I am using a buzzer that can run from voltages 3 to 24 V.

The sketch is straightforward:

const int sensor_pin = 2;
const int buzzer = 5;

void setup() {
  pinMode(sensor_pin,INPUT_PULLUP);
  pinMode(buzzer,OUTPUT);
}

void loop() {
  if(digitalRead(sensor_pin) == LOW){
    digitalWrite(buzzer,HIGH);
  }else{
    digitalWrite(buzzer,LOW);
  }
}

I gave pins 2 and 5 appropriate aliases:

const int sensor_pin = 2;
const int buzzer = 5;

Inside setup(), we declare sensor_pin as an input pin while buzzer is an output pin:

pinMode(sensor_pin,INPUT_PULLUP);
pinMode(buzzer,OUTPUT);

In loop(), we check if the sensor_pin voltage is zero. If it is, we sound the buzzer. If not, then turn off the buzzer.

void loop() {
  if(digitalRead(sensor_pin) == LOW){
    digitalWrite(buzzer,HIGH);
  }else{
    digitalWrite(buzzer,LOW);
  }
}

The fire sensor can detect flame within its 60 degree capture angle. The distance of the flame varies with ambient light. In my tests, the sensor was able to detect a match’s flame from around 5 cm.

Using the Flame Sensor with PIC16F877A

The difference here is that we are using a different microcontroller and thus, a different compiler. Nevertheless, the concept is the same: the PIC16F877A reads the D0 pin and if its low, fire up the buzzer and so on.

Here’s the wiring diagram:

The D0 pin of the fire detector module connects to RB0 while the buzzer’s red wire is connected to RB1.

The C code (XC8) for the circuit above is shown below:

#define _XTAL_FREQ 4000000
#include <xc.h>

void main(void) {
    
    TRISBbits.TRISB0 = 1;
    TRISBbits.TRISB1 = 0;
    while(1){
        if(PORTBbits.RB0 == 0){
            PORTBbits.RB1 = 1;
        }else{
            PORTBbits.RB1 = 0;
        }
    }
    return;
}

The pin RB0 is an input pin while RB1 is an output pin. Hence their corresponding TRIS bits should be:

TRISBbits.TRISB0 = 1; 
TRISBbits.TRISB1 = 0;

We then use simple if-else statements to check if the sensor detects a fire and then turn on or off the buzzer:

while(1){
 if(PORTBbits.RB0 == 0){
    PORTBbits.RB1 = 1; 
 }else{ PORTBbits.RB1 = 0; 
 } 
}

There's no loop() function in XC8 so we create our own infinite loop using the while(1) statement.

That's it for interfacing the flame detector with a PIC microcontroller.

Flame Sensor and ESP8266

Finally we are down to our last microcontroller, the ESP8266. Of course, we will be using the flame sensor with the ESP8266 according to the latter’s capabilities. In this version, the user will receive a push notification on his or her smartphone everytime the fire detector is triggered.

Here’s the wiring diagram:

This diagram is the simplest since we don’t need the buzzer anymore. Note that I am using a NodeMCU ESP8266 board for this project. If this is your first time using the NodeMCU, please follow the instructions to program it using the Arduino IDE.

Here is the full sketch:

/*
 *  This sketch sends push notifications via Pushbullet App through PushingBox.
 *
 *  You need to create a service and scenario at pushingbox.com to acquire
 *  a device ID. Also change lines 12 and 13 to your own WiFi SSID and password
 *
 */
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

const char* ssid     = "<your WiFi SSID>";
const char* password = "<your WiFi password>";

const char* host = "api.pushingbox.com";
const char* devid = "vADAB279A6A4DA5A";

const int sensor_pin = 14;

void setup()
{
    pinMode(sensor_pin,INPUT_PULLUP);
    pinMode(buzzer,OUTPUT);
    
    Serial.begin(115200);
    delay(10);

    // 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());
}

int value = 0;

void loop()
{
    delay(5000);

    if(digitalRead(sensor_pin) == LOW){  //flame sensor triggered

    Serial.print("connecting to ");
    Serial.println(host);

    // Use WiFiClient class to create TCP connections
    WiFiClient client;
    const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
        Serial.println("connection failed");
        return;
    }

    // We now create a URI for the request
    String url = "/pushingbox";
    url += "?devid=";
    url += devid;
    
    Serial.print("Requesting URL: ");
    Serial.println(url);

    // This will send the request to the server
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                 "Host: " + host + "\r\n" +
                 "Connection: close\r\n\r\n");
    unsigned long timeout = millis();
    while (client.available() == 0) {
        if (millis() - timeout > 5000) {
            Serial.println(">>> Client Timeout !");
            client.stop();
            return;
        }
    }

    // Read all the lines of the reply from server and print them to Serial
    while(client.available()) {
        String line = client.readStringUntil('\r');
        Serial.print(line);
    }

    Serial.println();
    Serial.println("closing connection");
    }else{;}
}

Before uploading this sketch, we need to configure Pushingbox and Pushbullet for this project to work. 

First, go to Pushingbox and signup or login to your account. You will then be redirected to the Dashboard page:

Click the My Services tab and click “Add a service”:

Next, look for the Pushbullet service:

However, before your press the “Select this service” button, you need to have a Pushbullet account first.

Go to Pushbullet:

Sign up or login to your account. After that, find Settings on the dashboard. There you’ll find your access token:

Go back to Pushingbox, click add a service again and this time click the “Select this service” button for pushbullet. A window appears:

Give the configuration a name, paste your Pushbullet token then click submit.

Next, click the My Scenarios tab to add a scenario linked to the service just created:

After creating the scenario, add an action:

Make sure you select the appropriate scenario:

A window appears; give the action title, push notification message and then click submit.

Finally, copy the device ID whose location is shown:

Now on the sketch, locate line 16 and change the device ID:

const char* devid = "vADAB279A6A4DA5A";

Also, don’t forget to provide your own WiFi’s SSID and password on lines 12 and 13:

const char* ssid     = "<your WiFi SSID>";
const char* password = "<your WiFi password>";

Upload the sketch and you're good to go! Now, install the Pushbullet app on your smartphone and login to your account. Everytime the fire detector is triggered, you will receive a push notification!

Conclusion

The flame sensor project here is limited in capture angle and range. However, there's a special module that contains five phototransistors:

This 5-way fire detector module has a capture angle of 120°. Check prices here.

Hopefully, this article helps you in any way. For any questions, reactions or suggestions, kindly drop comments below.

The post Flame Sensor Project: Comprehensive Guide appeared first on Teach Me Microcontrollers!.

Setting Up

As already mentioned, this project uses the DHT22 and a NodeMCU ESP8266 board. The hardware connections are straightforward:

Here is a photo of my actual setup:

As for the firmware, I used the following libraries for the sketch:

• SimpleDHT library by winlinvip
• MQTT library by 256dpi
• ESP8266 Arduino Core (see Intro to NodeMCU for details)

Basically, all I did was read temperature and humidity data from the DHT22 and publish that data to shiftr’s MQTT broker service. You can use shiftr’s Try channel if you’re short on time but I recommend creating your own account. With that, you can create your own namespace and you will be provided with a Key and Password as shown:

Here, my Key is feceaf58 and my password is 5d0a52d449f797ca.

Sketch

Next, I modified the AdafruitHuzzahESP8266 example sketch that came with the MQTT library. I added a few lines for reading the data from the DHT22 and also inserted my own Key and password from above. Here is the full sketch:

#include <ESP8266WiFi.h>
#include <MQTT.h>
#include <SimpleDHT.h>

const char ssid[] = "<Your-WiFi-SSID>";
const char pass[] = "<Your-WiFi-Password>";
const char mqttkey[] = "<Your-MQTT-Key>";
const char mqttpw[] = "<Your-MQTT-Password>";

WiFiClient net;
MQTTClient client;

int pinDHT22 = 4;
SimpleDHT22 dht22(pinDHT22);
float temperature = 0;
float humidity = 0;
  

unsigned long lastMillis = 0;

void connect() {
  Serial.print("checking wifi...");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(1000);
  }
  Serial.println("WiFi Connected!");
  Serial.print("IP address: ");
  Serial.println(net.localIP());
  delay(2000);
  Serial.println("connecting to MQTT broker...");
  while (!client.connect("DHT22-NodeMCU", mqttkey, mqttpw)) {
    Serial.print(".");
    delay(1000);
  }

  Serial.println("\nconnected!");

  client.subscribe("/DHT22");
  // client.unsubscribe("/hello");
}

void messageReceived(String &topic, String &payload) {
  Serial.println("incoming: " + topic + " - " + payload);
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, pass);

  // Note: Local domain names (e.g. "Computer.local" on OSX) are not supported by Arduino.
  // You need to set the IP address directly.
  client.begin("broker.shiftr.io",net);
  client.onMessage(messageReceived);

  connect();
}

void loop() {
  client.loop();
  delay(10);  // <- fixes some issues with WiFi stability
  int err = SimpleDHTErrSuccess;
  if ((err = dht22.read2(&temperature, &humidity, NULL)) != SimpleDHTErrSuccess) {
    Serial.print("Read DHT22 failed, err="); Serial.println(err);delay(2000);
    return;
  }

  Serial.print((float)temperature); Serial.print(" *C, ");
  Serial.print((float)humidity); Serial.println(" RH%");
  delay(2000);
  if (!client.connected()) {
    connect();
  }

  // publish a message roughly every second.
  if (millis() - lastMillis > 1000) {
    lastMillis = millis();
    client.publish("DHT22-NodeMCU/temperature", (String)temperature);
    client.publish("DHT22-NodeMCU/humidity", (String)humidity);
  }
}

Don’t forget to insert your own credentials on the sketch above!

If the sketch is uploaded successfully to the NodeMCU, the Shiftr channel should now show the sent temperature and humidity data:

Embedding Data to Web Page

I’m not done yet! I want to embed the temperature and humidity data to my own web page and add a graph with the values vs. time.

Shiftr provides an example Javascript code for embedding MQTT data. What I did is modify that code so that it displays two messages from two topics:

$(function(){
  var client = mqtt.connect('mqtt://feceaf58:5d0a52d449f79c7a@broker.shiftr.io', {
    clientId: 'browser-client'
  });
    
  var temperature;
  var humidity;
 
 
  client.on('connect', function(){
    console.log('client has connected!');
  });
 
  client.subscribe('DHT22-NodeMCU/temperature');
  client.subscribe('DHT22-NodeMCU/humidity');

  client.on('message', function(topic, message) {
      if(topic === 'DHT22-NodeMCU/temperature'){
        temperature = message;
      }else if(topic === 'DHT22-NodeMCU/humidity'){
        humidity = message;
      }else{;}
   if(temperature && humidity){
    $('#temperature').text(temperature.toString());
    $('#humidity').text(humidity.toString());
    temperature =  undefined;
    humidity = undefined;
   }

   
  });

})

Then I used Dygraph for plotting the data against time. This library requires a Dygraph object with given properties.

var g = new Dygraph(document.getElementById("div_g"), data,
            {
                drawPoints: true,
                showRoller: true,
                valueRange: [0.0, 100, 100],
                labels: ['Time', 'Temperature', 'Humidity']
            });
  

Here, I created div_g HTML div element where the graph is located.

Here’s my full Javascript code:

$(function(){
  var client = mqtt.connect('mqtt://feceaf58:5d0a52d449f79c7a@broker.shiftr.io', {
    clientId: 'browser-client'
  });
    
  var temperature;
  var humidity;
 
  var data = [];
  var y;
  var z;
   
  var g = new Dygraph(document.getElementById("div_g"), data,
            {
                drawPoints: true,
                showRoller: true,
                valueRange: [0.0, 100, 100],
                labels: ['Time', 'Temperature', 'Humidity']
            });
   
  client.on('connect', function(){
    console.log('client has connected!');
  });
 
  client.subscribe('DHT22-NodeMCU/temperature');
  client.subscribe('DHT22-NodeMCU/humidity');

  client.on('message', function(topic, message) {
      if(topic === 'DHT22-NodeMCU/temperature'){
        temperature = message;
      }else if(topic === 'DHT22-NodeMCU/humidity'){
        humidity = message;
      }else{;}
   if(temperature && humidity){
    $('#temperature').text(temperature.toString());
    $('#humidity').text(humidity.toString());
    y = temperature.toString();
    z = humidity.toString();
    temperature =  undefined;
    humidity = undefined;
   }

    var x = new Date();  // current time
     console.log(y);
    console.log(z);
    data.push([x, y, z]);
    g.updateOptions( { 'file': data } );
 
  });

})

I saved this Javascript code as mqtt.js.

And here’s the HTML as well:

<html>
 <title>NodeMCU Weather Monitor</title>
<head>
    <script src="https://code.jquery.com/jquery-2.2.3.min.js"></script>
    <script src="https://assets.shiftr.io/js/mqtt-2.9.0.js"></script>
      <script src="https://dygraphs.com/dist/dygraph.js"></script>
    <script src="mqtt.js" charset="utf-8"></script>
    
</head>
  <body>
    <div id="temp"><p><h3>Temperature (&#176;C): </h3><p id="temperature"></p></p></div>
    <div id="humid"><p><h3>Humidity (%RH): </h3><p id="humidity"></p></p></div>
    <div id="div_g" style="width:600px; height:300px;"></div
  </body>
</html>

The web page lacks CSS so it’s kinda ugly. But it works!

The post NodeMCU IoT Weather Device appeared first on Teach Me Microcontrollers!.

This NodeMCU IoT project is a simple demonstration on how to send sensor data to the Internet. Powered by a NodeMCU ESP8266 microcontroller, this project is able to show temperature, humidity and atmospheric pressure to any MQTT subscriber.

Introduction

Using MQTT is much faster than using HTTP because of reduced overhead. In fact, MQTT is one of the preferred protocols for Internet of Things.

To use MQTT, we need a broker and there are lots of them! For this project, I used Shiftr.IO. I already detailed how to use the MQTT protocol with the NodeMCU so kindly check that out first.

Materials

For temperature and humidity, I used SHT1x from DFRobot. For the atmospheric sensor, I used the old reliable BMP085. My Arduino BMP085 tutorial covers how to use this sensor with the Arduino. The NodeMCU uses the same Arduino IDE and code as long as the ESP8266 core is installed.

• NodeMCU
• SHT1X Temperature and Humidity Sensor
• BMP085 Atmospheric Pressure Sensor

Another requirement for this project is a free account in Shiftr.IO. I’ve created an “environment-monitor” channel in Shiftr and was promptly given username and passwords which is needed when connecting to the broker.

Also, the MQTT library is required and is downloadable here. Finally, you’ll be needing the SHT1X library and the BMP085 library, both of which (thankfully) are NodeMCU-compatible.

Wiring Diagram

The SHT1X library uses software SPI while the BMP085 uses I2C.

The default I2C pins of the NodeMCU are D1 (SCL) and D2 (SDA) or GPIO5 and GPIO4. Naturally, the BMP085’s SDA and SCL pins should be connected to those pins. As for the the SHT1X, I decided to use the D3 and D4 pins for clock and data respectively.

Here is the Fritzing diagram:

Arduino Sketch

The sketch is similar to that in my MQTT tutorial. The first part of the sketch is establishing the WiFi connection. Then, we connect to the MQTT broker through

client.begin("broker.shiftr.io", WiFiclient);

Next, I connected to the MQTT channel using

client.connect("environment-monitor", "<username>", "<password>")

The username and password is found on the URL of the MQTT channel. For example, if this is your URL: mqtt://7fb2fd2f:b9f1e26ae8d3dac8@broker.shiftr.io ( found in namespace settings). Your username is 7fb2fd2f and the password is b9f1e26ae8d3dac8.

To publish data, I used

client.publish("environment-monitor/temperature", (String)temp_c);

There is no need to create the /temperature topic as it’s automatically created once you call the function above. Of course, you can publish multiple topics:

client.publish("environment-monitor/temperature", (String)temp_c);
client.publish("environment-monitor/humidity", (String)humidity);
client.publish("environment-monitor/pressure", (String)pressure);

Anyway, here’s the full sketch:

/*NodeMCU IoT Environment Monitor
 * 
 * By Roland
 * 
 * From https://www.teachmemicro.com/nodemcu-iot-environment-monitor
 */

#include <SHT1x.h>
#include <Wire.h>
#include <Adafruit_BMP085.h>
#include <ESP8266WiFi.h>
#include <MQTTClient.h>
 
// Replace with your network credentials
const char* ssid = "Les Boise Engr. Innovations";
const char* password = "tingkarol";

WiFiClient WiFiclient;
MQTTClient client;

unsigned long lastMillis = 0;

String page = "";
String text = "";
String data;

// Specify data and clock connections and instantiate SHT1x object
#define dataPin  2 //D4
#define clockPin 0 //D3
SHT1x sht1x(dataPin, clockPin);

Adafruit_BMP085 bmp;

float temp_c;
float humidity;
float pressure;

void setup()
{
   Serial.begin(115200); // Open serial connection to report values to host
   Serial.println("Starting up");
   if (!bmp.begin()) {
    Serial.println("Could not find a valid BMP085 sensor, check wiring!");
    while (1) {}
   }

   WiFi.begin(ssid, password); //begin WiFi connection

   // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print("."); 
}

 Serial.println("");
 Serial.print("Connected to ");
 Serial.println(ssid);
 Serial.print("IP address: ");
 Serial.println(WiFi.localIP());
 Serial.print("connecting to MQTT broker...");
 client.begin("broker.shiftr.io", WiFiclient);
 connect();

}

void connect() {
 while (!client.connect("environment-monitor", "7fb2fd2f", "b9f1e26ae8d3dac8")) {
   Serial.print(".");
 }

 Serial.println("\nconnected!");
 client.subscribe("environment-data");
}

void loop()
{
  
  // Read values from the sensor
  temp_c = sht1x.readTemperatureC();
  humidity = sht1x.readHumidity();
  pressure = bmp.readPressure();
  
  client.loop();
  if(!client.connected()) {
   connect();
  }

  if(millis() - lastMillis > 1000) {
   lastMillis = millis();
   client.publish("environment-monitor/temperature", (String)temp_c);
   client.publish("environment-monitor/humidity", (String)humidity);
   client.publish("environment-monitor/pressure", (String)pressure);
  }
}

The sensor data is published every second.

Images

Here’s some pictures of my actual setup:

I had to go from the computer to take better pictures, hence the project is powered by a small power bank. It will still run drawing power from a computer.

Video

The post NodeMCU IoT Environment Monitor appeared first on Teach Me Microcontrollers!.

Disclaimer: This tutorial aims to bring awareness to security vulnerabilities of the 802.11 WiFi standard and not to promote mischievousness. The author doesn’t take responsibility for whatever further application this tutorial may result in.

Install the ESP Core for Arduino and Edit A File

We will be using the ESP8266 core for Arduino IDE in this tutorial. If you haven’t installed this already, go over to my Introduction to NodeMCU tutorial to show you how.

Once you have the core installed, go to File > Preferences. Click on the preferences path:

This will open a file dialog window. Go to packages > esp8266 > hardware > esp8266 > 2.3.0 > tools > sdk > include and open the user_interface.h file. Scroll to the bottom of the file and just before the #endif, add these lines:

typedef void (*freedom_outside_cb_t)(uint8 status);int wifi_register_send_pkt_freedom_cb(freedom_outside_cb_t cb);void wifi_unregister_send_pkt_freedom_cb(void);int wifi_send_pkt_freedom(uint8 *buf, int len, bool sys_seq);

Save the file and close the Arduino IDE.

Download the Deauther Project

Next, download the deauther project from Stefan Kremser’s (spacehuhn) Github repository.

Open the sketch found at esp8266_deauther-master\esp8266_deauther\.

Note that the sketch contains a lot of headers so don’t just copy this. Download the entire library! Also, Stefan has made his own board with a lot of features not found on a NodeMCU. This causes the sketch to have errors when uploaded. The solution is to add these libraries:

• ArduinoJson
• ESP8266 OLED SSD1306
• Adafruit NeoPixel
• LinkedList

Upload the sketch, selecting the correct NodeMCU board beforehand.

Running the NodeMCU WiFi Jammer

Open the serial monitor and this should show up:

Mounting SPIFFS...OK
Switched to Channel 1
Settings loaded from /settings.json
Settings saved in /settings.json
Device names loaded from /names.json
SSIDs loaded from /ssids.json
Scan results saved in /scan.json
Serial interface enabled
Started AP
[WiFi] Path: '/web', Mode: 'AP', SSID: 'pwned', password: 'deauther', channel: '1', hidden: false, captive-portal: true
STARTED! \o/
v2.0.5
Executing /autostart.txt
Done executing script

Now, use your smartphone or computer and connect to the NodeMCU AP showed above (SSID: pwned, password: deauther)

Now, go to 192.168.4.1 using the smartphone or computer connected to the NodeMCU. Click the “Attacks” tab:

Click the start button on the Deauth row to start the attack. Note that the AP stops so you may end up losing this user interface. Nevertheless, all the WiFi devices connected to the chosen SSID should now be disconnected.

The post NodeMCU WiFi Jammer appeared first on Teach Me Microcontrollers!.