Projects | Botshop
Wifi Scale project for Wemos D1 board Part two

Wifi Scale project for Wemos D1 board Part two

wemos d1 project

Scale project for Wemos D1 part 2- from pallet wood 

Now that we got the scale to work with an Arduino it is time to see how we will get it to work with a Wemos D1 board so that we can view the scale data from a Wifi connection on a web browser. This can also be a web browser on a cellular phone if you so wish. In short, we want to now expand our project to an IOT (Internet of things) scale. This scale project for Wemos D1 part 2 focus on the wifi part of this project, in part one we focus more on the load cells and amplification so first have a look (there is a link above).

Getting the D1 to work with the Arduino IDE.

In our review of this board, we gave details on how to get it to work with your Arduino IDE in the “Use your Arduino IDE to program the chip” section.

To recap:
  1. To install drivers remove all previous esp boards download and
  2. install http://www.arduined.eu/files/CH341SER.zip
  3. next open file>preferences
  4. enter http://arduino.esp8266.com/stable/package_esp8266com_index.json in the additional board manager urls area
  5. open tools>board>board manager
  6. search ESP8266 and
  7. install “esp8266 by ESP8266 community” version “1.6.5-947-g39819f0”
  8. next restart the Arduino IDE then select
  9. tools>board>WeMos D1 R2 & mini
  10. select upload speed at 115200 baud

 

Scale project for Wemos D1 – Hooking up the load cell HX711 amplifier

In part one of this project, we showed you how to connect the load cells to the amplifier board as well as to an Arduino Uno. We also talked about the pin differences between the Arduino and Wemos D1. Below is a picture again as well as a diagram connecting the amp to the Wemos board.

In the code, we also show, as comments in the pinouts for the Arduino.

Wemos D1 pin assignments

Wemos diagram

The LCD screen pinout can also be seen in the code.

LiquidCrystal lcd(0, 2, 4, 14, 12, 13); // WEMOS pins differ from UNO pins translated to uno would be (8, 9, 4, 5, 6, 7)

Scale project for Wemos D1: Explaining the code

Connecting to your WIFI network

To connect to a WiFi connection we use these 2 libraries (all the WiFi libraries will be automatically installed with the ESP8266 files when you add the board to your Arduino IDE):

#include <ESP8266WiFi.h>
#include <WiFiClient.h>

Next, you need to enter your WiFii details to connect to the network. Look for the lines below in the code and change the **** with your network name and network password.

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

Setting up the board as a web server

The first thing to understand is that we want to setup the D1 as a web server. If you are not familiar with web servers it basically means that we want to hand out web pages to web browsers for displaying when the web browsers connect to the D1 board. Hence the name web server – it serves web pages to your browser when the browser connects to it.

In the code (see below) you will use a library called ESP8266WebServer.h and the code to start the web server is simple:

ESP8266WebServer server(80);

The (80) specify the port the server should listen to and is standard as all web browsers by default try to connect to web servers on port 80. A port is nothing more than a number that distinguishes what data is intended for what application on a server. Thus, a web browser will connect to the web server and communicate that it wants to connect to the software that is assigned the number 80. Port numbers are of cause very important when you have many applications like FTP, email etc on one server,  else there is no way you will know for what application the data to your server is for.

Web page code

A web page is a text file with very basic code in it, this code is called HTML, In short, HTML code tells your web browser how to display and what to display on the web browser. It tells your web browser things like the size, font and colour of the text, where to find the images in the web page, where on the page the images must display and so on. (Note, that the images are not “in” this text file but rather a link to where the browser will find it on either the Internet or in the web servers file directory). A web browser thus “understand” HTML code and will generate the page you see in the web browser according to this code.

Here is an example of HTML in the code we will use soon:

webString=”<html><head><meta http-equiv=’refresh’ content=’3′> </head><body>Weight: “+String((float)value)+”kg</body></html>”;

This image below is what you will see in your web browser:

browser view plain

In short all web page code start with <html> and end with </hml> . We then have the <head> tag that gives your browser information like the name of the page and so on, in the example above we use the “refresh” tag that tells the web browser to reload the page, in this case, every 3 seconds. This is required because we want the web page to refresh by itself so it will display the weight of the scale when the weight changes. The <body> tag tells the browser what it should actually display in the browser window and the </body> tag tells the browser when the end is reached of what should be displayed.  In between the body tags we display the Weight from the scale in the browser.

If you spice up your HTML knowledge a bit you can make it look better. I added a picture and some other formatting to the code so it shows our logo.

webString=”<html><head><meta http-equiv=’refresh’ content=’3′> </head><style>body {background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }</style><body><img src=’https://www.botshop.co.za/wp-content/uploads/2017/03/logowebsite2.png’><br><b>Weight: “+String((float)value)+”kg</body></html>”;

Here is the result:

browser view formatted

Connect to the D1 web server

Once your server is running use your web browser to connect to the D1. In the URL field in your web browser type the IP address (see below on where to get it) of your web server and press Enter. In our code, we created an additional page called test. To get to it use your ipaddress/test e.g 192.168.0.1/test

Get your IP from serial monitor. We simply used the code below to get the IP address you should connect to and that will display in serial monitor for you to know what the IP is. You can also display it on the LCD display if you so wish.

Serial.print(“IP address: “); // displays ssid and IP on serial monitor and also IP on LCD
Serial.println(WiFi.localIP()); //

Code

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <HX711.h>
#include <LiquidCrystal.h>

LiquidCrystal lcd(0, 2, 4, 14, 12, 13); // WEMOS pins differ from UNO pins translated to uno would be (8, 9, 4, 5, 6, 7)

#define DOUT 16 // uno pin 2
#define CLK 5 // uno pin 3

float value;
String webString=””;
#define calibration_factor 21900 // Do Not change unless other load cells are used
HX711 scale(DOUT, CLK); // initialize load cell amplifire

const char* ssid = “*********”; // function as metioned in bellow comments
const char* password = “*******”; //

ESP8266WebServer server(80); // starts server on port 80

const int led = 13;

void handleRoot() { //
digitalWrite(led, 1); //
server.send(200, “text/plain”, “please enter correct page”);
digitalWrite(led, 0); //
char temp[400]; //
} //

void handleNotFound(){ //
digitalWrite(led, 1); //
String message = “File Not Found\n\n”; //
message += “URI: “; //
message += server.uri(); //
message += “\nMethod: “; //
message += (server.method() == HTTP_GET)?”GET”:”POST”; //
message += “\nArguments: “; // typical error 404/page not found
message += server.args(); //
message += “\n”; //
for (uint8_t i=0; i<server.args(); i++){ //
message += ” ” + server.argName(i) + “: ” + server.arg(i) + “\n”; //
} //
server.send(404, “text/plain”, message); //
digitalWrite(led, 0); //
} //

void setup(void){
pinMode(led, OUTPUT);
digitalWrite(led, 0);
Serial.begin(115200);
WiFi.begin(ssid, password);
lcd.begin(16, 2);
Serial.println(“”);
scale.set_scale(calibration_factor); // calibrate scale
scale.tare(); // zero scale
/*
while (WiFi.status() != WL_CONNECTED) { // I have disabled this to allow client to play with device,
delay(500); // What this does is it waits for the WiFi to be connected
Serial.print(“.”); // and while waiting it displays which ssid it is trying to
lcd.setCursor(0,0); // connect to I was thinking to add a script to show all
lcd.print(“Connecting to”); // available ssid’s so the client can select which one to use
lcd.setCursor(0,1); // using the keypad on lcd shield and also enter the password
lcd.print(ssid); //
} //
delay(750); // allows enough time to see that its connecting
*/
Serial.println(“”); //
Serial.print(“Connected to “); //
Serial.println(ssid); //
Serial.print(“IP address: “); // displays ssid and IP on serial monitor and also IP on LCD
Serial.println(WiFi.localIP()); //
lcd.setCursor(0,1); //
lcd.print(WiFi.localIP()); //

if (MDNS.begin(“esp8266”)) {
Serial.println(“MDNS responder started”);
}

server.on(“/”, handleRoot); //home page

server.on(“/test”, [](){        //enter IP followed by /test
char temp[400]; //to display scale value
value=scale.get_units(), 0; //
webString=”<html><head><meta http-equiv=’refresh’ content=’3′> </head><body>Weight: “+String((float)value)+”kg</body></html>”; //this line has an automatic refresh built in it is also the string to display the value
server.send(200, “text/html”, webString); //
}); //

server.onNotFound(handleNotFound); // 404 error

server.begin();
Serial.println(“HTTP server started”);
}

void loop(void){
server.handleClient(); // monitors user interaction on web
value=scale.get_units(), 0; //
lcd.setCursor(0,0); //displays scale vallue and ip on lcd
lcd.print(“Wheight: “); //
lcd.print(value); //
lcd.print(“kg”); //for some reason this jumps around alot
delay(1000); //
}

scaleCode text file

 

Scale project for Arduino and Wemos D1

Scale project for Arduino and Wemos D1

wemos d1 project

Scale project – Arduino and WiFi scale (see part 2 of this tutorial) from pallet wood

This scale project is built around the Arduino Uno and part 2 of this tutorial around the Wemos D1 development board. In its basic form, it will display the weight of an object on an LCD display and in the next tutorial in a web page using WiFi. This project can of cause be expanded even more to capture the weight in a database and so on. Here are lots to learn, from weight load cells all the way to Wifi with the D1 board that is cheaper than an Arduino Uno. We have a review  of the Wemos D1 here:

When doing an Arduino or Wmos D1 scale project there are a couple of things to know, The first is the development board itself, then the coding that can be done directly from an Arduino IDE and then some HTML coding to create the web page when doing the WiFi parts. If you are already coding Arduino projects you have very little learning to do on the coding of the Wemos D1 board.

 

The Wemos D1 board is designed to be similar than an Arduino Uno and you will immediately recognise the power headers and I/O header.

If you are not planning to use the scale as a wifi project the Arduino Uno will be just fine.

The D1 microcontroller is much more powerful than that of an Arduino

Saying that… you can easily build this scale using an Arduino Uno if you prefer.

One thing that stands out from the D1 is that it uses the very powerful ESP8266 chip that is a microcontroller and Wifi chip all in one. What’s even more impressive is that the microcontroller is much more powerful than an Arduino microcontroller with much more memory for your wifi projects.

Read this post first: Before you move on, read this blog post that has much more details about the Wemos D1 development board and how to set it up for the first time. https://www.botshop.co.za/wemos-d1-review-wifi-development-board/

Let’s look at the scale first.

To build a scale you need 3 parts: load cells, an amplifier and then a micro controller to interpret the results and display it somehow. The micro controller can be one of many, including a WeMos D1, ESP8266 controller, Arduino and Raspberry Pi.

load cell image

Load cells come in many different types and if you plan on working with them extensively you will need to read up on all the types available. In this tutorial, we use  50kg load cells that is one of the products we sell on our site here. You will need 4 load cells that you must place on the 4 corners of a solid base that will act as the weighing platform of your scale.

The 4 load cells can handle 50kg each so you will end up with a scale that can measure up to 200kg.

scale frame   load cell

It does not have to be fancy, we used a couple pieces of pallet wood to create the base as shown in above picture, then you need to drill big holes for the cells to fit, note the correct way to fit the cells in above picture.

The HX711 load cell amplifier

Load cells operate at very small voltage changes, therefore an amplifier will be required. We sell the HX711 Load Cell (Weight) Amplifier that works perfectly with the load cells.

Below is a diagram on connecting the cells to the amplifier. The diagram and code below are for an Arduino and in our next tutorial, we will show you how to connect it to a Wemos D1 to change your scale into an “Internet of things” project.

load cell amplifier

Below is the code to get it going for your Arduino. It will print the weight out in Serial monitor for now.

#include "HX711.h"

// HX711.DOUT - pin #A1
// HX711.PD_SCK - pin #A0

HX711 scale(A1, A0);

void setup() {
 Serial.begin(9600);
 Serial.println("HX711 Demo");

Serial.println("Before setting up the scale:");
 Serial.print("read: \t\t");
 Serial.println(scale.read());

Serial.print("read average: \t\t");
 Serial.println(scale.read_average(20));

Serial.print("get value: \t\t");
 Serial.println(scale.get_value(5));

Serial.print("get units: \t\t");
 Serial.println(scale.get_units(5), 1);

scale.set_scale(2280.f); 
 scale.tare();

Serial.println("After setting up the scale:");

Serial.print("read: \t\t");
 Serial.println(scale.read());

Serial.print("read average: \t\t");
 Serial.println(scale.read_average(20));

Serial.print("get value: \t\t");
 Serial.println(scale.get_value(5));

Serial.print("get units: \t\t");
 Serial.println(scale.get_units(5), 1); 
 Serial.println("Readings:");
}

void loop() {
 Serial.print("one reading:\t");
 Serial.print(scale.get_units(), 1);
 Serial.print("\t| average:\t");
 Serial.println(scale.get_units(10), 1);

scale.power_down(); 
 delay(5000);
 scale.power_up();
}

LCD screen

Next, you will need a display and here you have many choices. The easiest to use is the I2C LCD display. We also have a basic LCD display that is cheaper.

Whats the difference? The I2C LCD shield has an extra board connected to the normal LCD shield, turning it into an I2C device, that means it has much fewer wires to connect and it is much easier to program with. The little I2C board take away allot of the job the Uno had to do.

That concludes our scale project, our next tutorial will take this scale and change it into a wifi (internet of things) scale using the Wemos D1 board.

Part 2 of this project is here!

Simple Arduino esp8266 web server ESP-07 ESP-12

Simple Arduino esp8266 web server ESP-07 ESP-12

Arduino esp8266 web server

To be able to host your own simple web server is easy all you need is the ESP8266 Serial WIFI Module and FTDI232 downloader here is a short description of both and a link on where to find it, An Arduino is not required at all and the ESP8266 board can be a stand alone board and it can be programmed with an FTDIboard. This blog is called Arduino esp8266 web server because you can also connect the wifi module to an Arduino if you want.

The ESP8266-03 is a highly integrated chip designed for the needs of a new connected world. It offers a complete and self-contained Wi-Fi networking solution, allowing it to either host the application or to offload all Wi-Fi networking functions from another application processor.

The USB to TTL serial adapter is based on the high quality and very popular FTDI FT232RL chipset and is an excellent way to connect TTL serial devices to a PC through a USB port and to program your Arduino esp8266 web server.

Unlike most USB to TTL serial adapters, this adapter supports both 5V AND 3.3V operation! Simply set the jumper as required to choose between 5V and 3.3V as labelled on the board.

Part List
  • ESP-07/ESP-12
  • FTDI232
  • Jumper Wires
  • 10k Resistor
  • Pushbutton
  • Breadboard
  • Stripboard
  • 2x 8 pin headers male or female
STEP1: Easy Access

Grab your headers, ESP module and strip board. Cut the Stripboard down to size (8 columns 9 rows), if you are unsure of the size you could cut it afterwards, remember to break the tracks at the bottom. Next solder thin wire to the pads of the ESP module and put each wire in its own column and solder it to the stripboard, next solder in the headers.

This part is very important because the pitch of the module’s pads are 2mm and that of the breadboard are 2.54mm.

esp8226-bb-2

20161123_111632

STEP2: Wiring

Now we will look at the wiring of the module, something to keep in mind is that the module runs on 3.3V. The above mentioned Downloader(FTDI232) supports both 3.3V and 5V, switch the jumper to 3.3V if your downloader does not support 3.3v, you will have to add a voltage divider as shown below, below that is the wiring of the module.

untitled

esp8226-bb-1

 

STEP3: Setup

First things first, if you haven’t got the ESP8266 library yet see “Getting Started with NodeMCU with ESP8266 part 1” on how to install the library, next we have to select the type of board and programmer.

First select the Board Tools -> Board -> Generic ESP8266 Module

board

Next select the programmer Tools -> Programmer -> USBasp

programmer

Now you can connect your programmer and select the port. We’re using an example sketch for this tutorial. File -> Examples -> ESP8266WebServer -> Hello Server. Remember to add your SSID and password.

 

STEP4: Uploading

Now that the wiring is done and your Arduino IDE is set up, we can start the upload process.Uploading to the ESP module could become tricky if you don’t keep track so pay close attention.

Firstly  connect GPIO 0 to ground.

gpio0

If the ESP module is powered up already, press the reset button you installed on the breadboard (pushbutton), if not just power up the module via the USB cable to the downloader. This process boots the  module up in program mode. You can now upload you sketch to the module. Once upload is complete, disconnect GPIO 0 from ground and reset it again, this allows the module to operate as normal. and your upload is complete.

 

STEP5: Connecting To The Server

When you are done uploading and you have removed the wire from GPIO 0 you can open your “Serial Monitor”. It should display the connection status after it has connected to your WIFI-router it will display an IP-address, copy this IP and enter it into your browser’s search bar. It will display the words “Hello From ESP8266” in your browser window.

Arduino Simulator App Review

Arduino Simulator App Review

Arduino Simulator Review – Start Developing Without a Real Arduino Board

We had stumbled across this Arduino simulator, in which you can use both electronics and you Arduino skills to be able to test your circuit before buying the necessary component or just to prevent you having a fried Arduino.

This Arduino simulator is free and works really great, although it has one major downside, the sketches have to be saved in .hex files then imported into the simulator but other than that it’s a really great app to have. Once you get the hang of creating the hex files it is actually not too bad and it becomes quite effortless.

 

 

Below is a simple explanation on how to use the Simulide Arduino simulator.

First, you will have to download Simulide.zip and extract the entire archive to your desired folder. If you run the executable from within the archive some functions will not be available. After extraction process has completed you can run the executable (.exe).

Next, build your circuit, remember to adjust the resistor values, on the left click on Properties and double click on the resistance value.

 

 

After you have built your circuit you can compile your sketch into a HEX file. In your Arduino IDE make sure your sketch is saved then go to Sketch->Export compiled Binary, or press Ctrl->Alt->S.

Now it’s time to load your sketch into the simulator, Right-click on the Arduino and select “Load firmware” and load your HEX flie you just exported, there will be two HEX files “xx.ino.standard.hex” and “xx.ino.with_bootloader.standard.hex” you have to select the one without the bootloader.

You are all set now and you can click on the power button at the top.

Another great Feature

The probe is another great feature the app has. Put the probe on up to four of your output pins and right click on it and select add to plotter.

Please note that this might look like an oscilloscope but it is a logic analyzer and will not work with PWM signals, for PWM signals select “Add to Oscope” instead of “Add to plotter”

How to create a PCB From a Diagram

How to create a PCB From a Diagram

How to create a pcb

Converting a circuit diagram to a Printed Circuit Board (PCB) could prove to be a challenging task.

But luckily with technology today it is fairly simple to complete this task, so there’s no need to be stressed out. We will be doing an easy one for today. It is called an A-Stable Multi Vibrator.

First, I will explain the circuit and the working thereof. Imagine that R2 were absent from the circuit, and suppose Q1 started out being turned on. Then Q2 would have nothing to turn it on, and Q1 would be held on by current through R3, while the R4 and the LED would charge C2. The effect would be that LED1 would come on and stay on, while LED2 would never light.

Now add R2. This will cause C1 to charge to -0.7 volts, until Q2 turns on. Once that happens, the charge on C2 would cause the base of Q1 to go negative, turning it off. When that happens, current flowing through LED1  will start flowing through C1 and the base of Q2, turning it on even harder. Once Q2 has turned on, it will keep Q1 off until C2 charges to -0.7 volts.

Note that while the circuit would have a stable state with both transistors on and both capacitors reverse-biased by 0.7 volts, in practice the winky-blink circuit always starts oscillating rather than entering such a state.

 

We will now start with our process. First download your software HERE for Design Spark or HERE for EAGLE CAD, I use Design Spark most of the time.

 

STEP1: Layout
,,,hFirst we’re going to place all of the components in the correct place.

flip-flop-raw-schem

It can be a bit difficult to find the components, but design spark has a great function under view -> Model Source Bar where you could either look under categories or enter a RS Components stock ,number just select your country and search your components you need, enter the stock number and click use component the software will tell you in which library it save the component and you can go fetch it from there. Marked in red are the two ways to find the components you need.

finding-comps-flip-flop-schem

 

STEP2: Connecting
Next we will connect the components together as shown in the image above, note that instead of a battery I have have added a two pole header, when we have the final product we will have two holes where you can solder in the battery leads or you can put headers in those same holes.

flip-flop-schem

STEP3.1: Converting
From here you have a few options. First option is to simply click on translate to PCB.

translate-to-pcb

and follow the easy steps. Your PCB will look something like this

translated-to-pcb

This does not always come out like expected, in which case we will see how to fix this in Step 3.2

STEP3.2: Converting
If your results was not what you expected in Step 3.1, click on Tools -> Unroute Nets -> All Nets.

unroute

You will see that the tracks has disappeared and now there are thin yellow lines. These yellow lines are to show you how the components were connected.

If you chose not to follow the previous option you will have to insert the components manually again. If you did follow the previous option you now only move the components how you feel fit.

This is what mine looks like yours can be different.

option-12-layout

STEP4: Wiring Compnents
For option 1 go to Tools -> Auto Route Nets -> All Nets

auto-route

and follow the instructions.

For option 2 you have to add the track in manually as in the schematic.

Your end result may look different than mine, but in the end, we achieve the same product.

finale

Note: Using option two may result in errors making the PCB useless. Yes option one may have errors as well but only if your schematic was wrong. Some of these errors may prove to be fatal.

I hope this blog post gave you a starting point on how to create a pcb.

IOT devices NodeMCU with ESP8266 part 2

IOT devices NodeMCU with ESP8266 part 2

IOT devices Part 2

Part 1 can be read here.
In this tutorial we will control electrical devices like fans, lights, etc., using esp8266 from a web browser.  To do that we need to get familiar with IOT devices. The Arduino sketch below shows how you can add HTML code (web page code) to the NodeMcu board so it will give you a web page when connecting to it. The web page the NodeMcu shows you will have buttons you can click on to control relays that in turn will control lights and so on.
What makes this cool is that you can connect to your NodeMcu from your wireless network from any device that got a web browser, including your phone.
Note: Make sure your browser enabled devices and the NodeMcu board is on the same wireless network. Depending on your networking knowledge you can take this a step further and configure your wireless router to do port forwarding and dynamic DNS to access your NodeMcu from anywhere on the Internet. Another good idea is to setup your router to always assign the same IP to your NodeMcu board in your router’s DHCP settings.
The components that you will need for completing this project are very simple, you need to have a NodeMcu module and a relay, make sure you buy a 5v relay, which are very easy to use with esp chips, it doesn’t require an external power supply.
We tested and sell this NodeMCU board.
You can also use this board with the easy and powerful LAU scripting language, more info can be found on the LAU website.

For this example project, I have used a 2 relay circuit. The actual program is written to connect four relays to IOT devices.

You can watch the above video on how it works and how to connect your browser to the IP address returned from esp, all the details are included in this video. The MCU IoT devices make it really easy these days.

Copy the below Arduino code and paste it into your Arduino IDE, then upload the program to your nodemcu or any other esp devices that you are using, make sure to choose the correct port and board. Also, don’t forget to change the SSID and password to your Wi-fi settings.
This program for the esp8266 also will return the status of the device, which will. in turn notify you when it’s connected to the specified network and it will also tell you what IP it received from the router.

#include <ESP8266WiFi.h>

const char* ssid = “Your Network Name”;
const char* password = “Your Password”;

; //
WiFiServer server(80);

void setup() {
Serial.begin(9600);
delay(10);
pinMode(5, OUTPUT);
pinMode(4, OUTPUT);
pinMode(0, OUTPUT);
pinMode(13, OUTPUT);
digitalWrite(5, LOW);
digitalWrite(4, LOW);
digitalWrite(0, LOW);
digitalWrite(13, LOW);

// Connect to 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”);

// Start the server
server.begin();
Serial.println(“Server started”);

// Print the IP address
Serial.print(“Use this URL to connect: “);
Serial.print(“http://”);
Serial.print(WiFi.localIP());
Serial.println(“/”);

}

void loop() {
// Check if a client has connected
WiFiClient client = server.available();
if (!client) {
return;
}

// Wait until the client sends some data
Serial.println(“new client”);
while(!client.available()){
delay(1);
}

// Read the first line of the request
String request = client.readStringUntil(‘\r’);
Serial.println(request);
client.flush();

// Match the request

if (request.indexOf(“/light1on”) > 0) {
digitalWrite(5, HIGH);

}
if (request.indexOf(“/light1off”) >0) {
digitalWrite(5, LOW);

}

if (request.indexOf(“/light2on”) > 0) {
digitalWrite(4, HIGH);

}
if (request.indexOf(“/light2off”) >0) {
digitalWrite(4, LOW);

}
if (request.indexOf(“/light3on”) >0) {
digitalWrite(0, HIGH);

}
if (request.indexOf(“/light3off”) > 0) {
digitalWrite(0, LOW);

}
if (request.indexOf(“/light4on”) > 0) {
digitalWrite(13, HIGH);

}
if (request.indexOf(“/light4off”) > 0) {
digitalWrite(13, LOW);

}
// Set ledPin according to the request
//digitalWrite(ledPin, value);

// Return the response
client.println(“HTTP/1.1 200 OK”);
client.println(“Content-Type: text/html”);
client.println(“”); // do not forget this one
client.println(“<!DOCTYPE HTML>”);
client.println(“<html>”);
client.println(“<head>”);
client.println(“<meta name=’apple-mobile-web-app-capable’ content=’yes’ />”);
client.println(“<meta name=’apple-mobile-web-app-status-bar-style’ content=’black-translucent’ />”);
client.println(“</head>”);
client.println(“<body bgcolor = \”#f7e6ec\”>”);
client.println(“<hr/><hr>”);
client.println(“<h4><center> Esp8266 Electrical Device Control </center></h4>”);
client.println(“<hr/><hr>”);
client.println(“<br><br>”);
client.println(“<br><br>”);
client.println(“<center>”);
client.println(“Device 1”);
client.println(“<a href=\”/light1on\”\”><button>Turn On </button></a>”);
client.println(“<a href=\”/light1off\”\”><button>Turn Off </button></a><br />”);
client.println(“</center>”);
client.println(“<br><br>”);
client.println(“<center>”);
client.println(“Device 2”);
client.println(“<a href=\”/light2on\”\”><button>Turn On </button></a>”);
client.println(“<a href=\”/light2off\”\”><button>Turn Off </button></a><br />”);
client.println(“</center>”);
client.println(“<br><br>”);
client.println(“<center>”);
client.println(“Device 3”);
client.println(“<a href=\”/light3on\”\”><button>Turn On </button></a>”);
client.println(“<a href=\”/light3off\”\”><button>Turn Off </button></a><br />”);
client.println(“</center>”);
client.println(“<br><br>”);
client.println(“<center>”);
client.println(“Device 4”);
client.println(“<a href=\”/light4on\”\”><button>Turn On </button></a>”);
client.println(“<a href=\”/light4off\”\”><button>Turn Off </button></a><br />”);
client.println(“</center>”);
client.println(“<br><br>”);
client.println(“<center>”);
client.println(“<table border=\”5\”>”);
client.println(“<tr>”);
if (digitalRead(5))
{
client.print(“<td>Light 1 is ON</td>”);

}
else
{
client.print(“<td>Light 1 is OFF</td>”);

}

client.println(“<br />”);

if (digitalRead(4))
{
client.print(“<td>Light 2 is ON</td>”);

}
else
{

client.print(“<td>Light 2 is OFF</td>”);

}
client.println(“</tr>”);
client.println(“<tr>”);

if (digitalRead(0))

{
client.print(“<td>Light 3 is ON</td>”);

}

else

{
client.print(“<td>Light 3 is OFF</td>”);
}
if (digitalRead(13))
{
client.print(“<td>Light 4 is ON</td>”);

}
else
{
client.print(“<td>Light 4 is OFF</td>”);
}

client.println(“</tr>”);
client.println(“</table>”);

client.println(“</center>”);
client.println(“</html>”);
delay(1);
Serial.println(“Client disonnected”);
Serial.println(“”);

}

Internet of things: Arduino + Blynk

Internet of things: Arduino + Blynk

Recently there is quite a swing with the term Internet of things. Wouldn’t it be nice if you can control your appliances with your smartphone.
Lets get started.

Step 1: Video

Step 2: Parts List

The part list for this project is super simple.

All you need is a Arduino, a LED, a computer with internet access and the Blynk app(running on either Android or iOS), and like most sketches the Blynk Library.

Step 3: Connections and Test

1.Connect one end of the usb to your arduino and the other to the computer having internet access.

2.Insert the led to Digital pin 13 as shown.(The shorter one is the cathode and goes to ground)

3.Install the Blynk app from google play store or app store.

4.Download the Blynk library from the link given.

5.Extract the zip file into Arduino’s library folder.

6.Now open the Arduino software,go to examples—>Blynk—->Boards_USB_serial—>Arduino_USB_serial

7.Enter the Authentication token from your email and then hit upload.

8.Go back to the Blynk library folder and under script open the windows batch file

9.Enter the COM port your Arduino is connected to.
Note:Make sure you do not close the command window.

*Now you are ready to blynk*

Step 4: Success!!!

Using a Washer To Steady Joints While Soldering

Using a Washer To Steady Joints While Soldering

If you have “helping hands,” clamping wire leads against a washer, as shown, stabilizes the whole setup dramatically by connecting the two arms with a rigid member, so you can bear down a bit more with the iron without pushing things out of alignment. But the hole in the middle of the washer still allows all-round access to the junction.

If you don’t have helping hands, you can just use a washer, as shown, with a pair of alligator clips (or even small binder clips) as a pretty effective improvised workholding jig for this kind of soldering.

using-a-washer-to-stabilize-soldering

Joining wires, The NASA way

Joining wires, The NASA way

Joining wires

Some commenters on my post about using a washer as a soldering aid noticed my sloppy splicing technique and were kind enough to educate me about the so-called “Western Union splice,” aka the “Lineman’s splice,” which is the preferred method for twisting solid-core wire leads together for inline electrical connections.

Developed during the heydey of the telegraph, the Lineman’s splice is designed for joining wires that will be under tension. It is commonly claimed that, properly made, a Lineman’s splice is stronger than the wires of which it is composed. In any case, it is a time-proven method, and, coolest of all, one of NASA’s Required Workmanship Standards. To wit, in a NASA-approved Lineman’s splice:

  1. The conductors shall be pre-tinned.
  2. There shall be at least 3 turns around each conductor and the wraps shall be tight with no gaps between adjacent turns.
  3. The wraps shall not overlap and the ends of the wrap shall be trimmed flush prior to soldering to prevent protruding ends.
  4. Conductors shall not overlap the insulation of the other wire.

Though the Lineman’s splice was originally used without solder, today soldering is common. And NASA insists on it:

  1. Solder shall wet all elements of the connection.
  2. The solder shall fillet between connection elements over the complete periphery
    of the connection.

This material comes from page 84 of NASA-STD 8739.4 (PDF), which is a great reference if you’re interested in best practices for interconnecting cables and wires.