Learn with Edwin Robotics

DIY Remote Control Car

Rashmi Menon — Mon, 19 Feb 2018 08:01:07 +0000

Remote control cars have been the dream the toy for most kids. And you can never outgrow them! In this post, We will show you step by step, how to make a simple Remote Control Car that operates in RF (radio frequency). This is a very simple and beginner level robotic project which can be made by anyone with interest. We will be discussing on the working of all integrated circuits (IC) and modules used in this robot. And there is no programming required for making this robot!

Introduction to Ardublockly using Medusa – Reading a digital sensor

Rashmi Menon — Fri, 02 Feb 2018 13:43:28 +0000

In project 2 we will learn utilization of digital sensors. In order to achieve this, we have to familiarize with the read pin block. The read digital pin facilitates the action of choosing the digital pin which acts as an input and reading its state.

Essential for this project we will require the following items.

Medusa Head for SparkFun ESP32

Buzzing a Buzzer using a Digital Sensor

The easiest way to get introduced to your input pins is a simple project using a touch sensor and buzzer. Every time the touch sensor senses an action of touch, the buzzer should beep.

In this example – pin number 25 will be set as the input pin on which the touch sensor is connected. Pin number 12 can be set as the output pin to which the buzzer is connected.

If the touch sensor is in contact with the hand the controller board (in this case SparkFun ESP32 Thing mounted on a Medusa Head) should turn on the buzzer else the buzzer should remain off. So let’s write a program when the touch sensor connected to pin number 25 turns High then the Buzzer connected to pin number 12 of Medusa Head should turn on for 1 second and turn off for 1 second. To achieve this we use an IF Block and a compare block. In the compare block, we can do various comparisons between an action and its corresponding response. In this case, we will be comparing a read digital pin block and a state block.

The next exercise will be replacing the touch sensor with a switch. The switch has a pull-up resistor, which makes give out a low value (zero) when pressed and when in a normal state (not pressed), it gives a high value (1). The best way to check this is by using the previous program. Unlike in the case of a touch sensor, the buzzer will turn off when the switch is pressed and turn on when release. This is not quite what is expected when we consider our understanding that every time a digital sensor is not sensing, it is at a zero else at 1. The pull-up resistor makes in a high state when not sensing and low when sensing.

Thus, replacing a touch sensor with Switch to operate the buzzer, the following sketch can be uploaded on to the board to achieve the desired output.

Block	Description
	The block for Digital Read automatically initializes the pin, by automatically calling the pin number in void setup and specifying its mode as input. Initializing is a crucial process in any program, and is always done under void setup. This process helps us to define to the micro microcontroller which pin we are selecting and what are we utilizing it as input or output. This block can be found under Input Output.
	The IF DO block is a comparative block found under Logic Section, as is used to execute a conditional activity. For example, if a particular event happens then do the following actions. The block has 2 sections. The section next to If is for putting the condition, and a section under Do is for the output action.
	This block is to specify the outputs state, high or Low. The State block can be found under the Input/Output Section
	The compare block can be found under logic . It has 2 sections to insert the statements to compare. In middle, there is a drop-down menu, with choice of more than, more than or equal to, less than, less than or equal to, equal to options.

Program 1 – Buzzer Control using Touch Sensor

Program 2 – Buzzer Control using Switch

The door switch and PIR work in the same ways as the touch sensor. When not sensing their state is low and when in contact with a change they are in a high state. Now that we have covered the basic, you can try programming them.

Medusa Magnetic Door switch

Medusa PIR Sensor

Resources:

Introduction to Ardublockly using Medusa – Blinking an LED

Rashmi Menon — Mon, 29 Jan 2018 08:40:17 +0000

This introductory project to Medusa Line for SparkFun ESP32 Thing is focused on using the block of a set digital pin.

The set digital pin block does a simple function of Output Function, which allows the process of choosing which digital pin acts as your output and specifying the state of it.

To execute this project you will need a Medusa Head for SparkFun Esp 32 Thing along with an LED Module.

Medusa LED Module

Medusa Head for SparkFun ESP32

Medusa Cables

Prerequisites:

To complete the projects you will need to install Arduino, ESP32 Arduino Core, and Ardublockly.

Blinking an LED

Before we get into the project, we will cover basic concept of an LED. The light emitting diode is a semiconductor doped in a way as to form a p n junction, and when it conducts, it emits light.

On the Medusa Led Module, there are 2 slots, one for positive and other for negative. The positive leg i.e. longer leg goes into the positive slot and the negative leg i.e. the shorter leg, into the negative slot.

You can control the brightness by adjusting the potentiometer, which is the small circular disc, at the back of the PCB using a screwdriver.

As you know on and off of LED can be considered as a digital output of High and Low. So the next question will be – How to set up a digital pin High (on) or Low (off)?

There are 2 parts to it.

To choose the pin on to which you need to digital write
To choose the state in which you want it – High or Low

The following is the Digital Write block in Ardublockly, which can be found under Input/Output :

It comprises of 2 blocks, and the first block helps the programmer specify the number and the second allows to decide the state if it high or low.

So, let’s start a project,

Take the led module connect it to a pin on the Medusa Head for SparkFun ESP32 thing using the Medusa Connector as shown in the photo:

In this case, we will be using the pin number 25 on the Medusa Head.

now let’s create a small blinking on and off of LED for 3 times for 1 second each with a gap of 2 seconds in between. To achieve this duration we will use a Wait block from the Time menu.

You can also try the following program without wait block, the on and off of LED will be too fast that you can hardly notice the difference.

Go ahead and upload the program on to the board.

While uploading the program there are 2 main things steps, i.e, Under Ardublockly, in preferences Select the Arduino Board option as Spark Fun ESP32 and COM Port as USB serial

Is the LED glowing more than 3 times? Do you think the program is repeating?

This is because your current program by default is in the forever loop of code. To avoid this we introduce an Arduino start block, which you will be able to find under Functions.

As seen, the start block has 2 parts :

Arduino Run First: Any program written into this executes only once and you will have to reset the microcontroller to execute it for another time. This part serves as the Void Setup () of C programming in which the pin gets initialized.

Arduino Loop Forever: The program written on to this will get executed forever. This part is the void Loop in C programming.

Now the new set of program to avoid repetition will be as follows:

One of the main features of a good program is to avoid maximum unnecessary code. This can be achieved by putting the action of turning high and low into a loop. This is achieved by using a repeat do block found under the loops category. In this block, we can select the number of times the program should run, in this case, 3 times.

In case you want to repeat the program forever, then you put the on and off command into the loop forever part of the start block.

The following table will help you better understand the function of each block.

BLOCK	Description
	The block for Set Digital Pin does the function of 2 syntax- 1) it automatically initializes the pin, by automatically calling the pin number in void setup and specifying its mode as output. Initializing is a crucial process in any program, and is always done under void setup. This process helps us to define to the micro microcontroller which pin we are selecting and what are we utilizing it as input or output. 2) the second is to control the outputs state, high or Low.
	Wait block corresponds to delay syntax on to which the programer writes duration in milliseconds. You also have the option of Microseconds wait block under Time Menu.
	This block does the function of counting how many times the program should repeat.
	As explained earlier, this Start block in Functions helps us to define Void setup and Void loop

Now you can practice the learning from your first project with buzzer as well as Haptic motor module.

Whenever you want to do projects using elements connected to main power supply we use the Relay. CAUTION: While using the relay, there are high chances of getting electrocuted and may lead to Death. So be careful.

CLICK HERE FOR PROGRAM FILES

Essentially after this module, you will be able to use the following module with the Medusa Head for SparkFun ESP32 Thing.

Medusa Haptic Motor

Medusa Buzzer

Medusa SPDT Relay

Resources:

Laser Tag

Rashmi Menon — Mon, 25 Dec 2017 09:56:38 +0000

OVERVIEW:

It is a simple and Easy DIY game you can play with your friends, using dartboard with an Ambient Light Sensor in its center along with an LCD to display the score and a Laser arm to aim at the center of the Dart Board. In this game, each player will have 10 shots to aim at the Dart Board and the game is to score the maximum points with 10 chances in a duration of 1 minute. While the LCD on the Dart Board setup shows the time remaining , the LCD on the laser arm shows the number of shots left. This game is a sure test of focus, aim, and speed.

There are 2 parts to this project:

Dartboard

Medusa Head for SparkFun ESP 32 Thing
Medusa Ambient Light Sensor
Medusa Touch Sensor
Medusa Buzzer
Medusa I2C 16 x 2 LCD Display
Cardboard Cutouts and color Paper for dartboard
3 medusa 500mm cable and 3 Medusa 150 mm cable
a power bank

Medusa Head for SparkFun ESP 32 Thing

Medusa Touch Sensor

Medusa Ambient Light Sensor

Medusa Cables 500 mm

Medusa Cable 150 mm

Medusa Buzzer

Medusa 16 x 2 LCD Display

Laser Tag –

inspired by the ironman missile arm, we have put together a simple laser arm DIY using the following components:

Medusa Head for SparkFun ESP 32 Thing
Medusa Laser Diode
Medusa Push Button
Medusa LCD Display
LiPo Battery
Crepe Bandage to Wrap the components around

Medusa SparkFun ESP 32

Medusa Push Button Sensor

Medusa 16 x 2 LCD Display

Medusa Laser Diode

Lithium Polymer Battery

Medusa Cable 150 mm

NOTE :  For the exact same implementation of the project you will need 2 Medusa ESP 32 Boards along with 
        2 Medusa LCD Display

Building Instructions

Dartboard

1) When it comes to making the dartboard , the material of choice is cardboard. Cut the cardboard into the shape of your choice and cover it with colored paper or paint.

CardBoard Cutouts to Make the DartBoard

2) Drill a hole into the middle so you can pull out a wire (Medusa 500mm Cable) which is connected to the Medusa Ambient Sensor. Using a double-sided tape, attach the Sensor to the middle of the dart board.

Fixing of Ambient Light Sensor on CardBoard

Repeat similar steps for the n-number of boards you require to make the game fun. We are using 3 boards in this example.

3) Fix the rest of the components into the ports of choice depending on the program. Based on the example code provided, the following components are connected to the Medusa Head for SparkFun ESP 32 Thing

Medusa Ambient Light Sensors- 33, 32, 25

Medusa Touch Sensor – 5

Medusa Buzzer – 14

Medusa LCD Display- I²C

Component Connection for DartBoard

4) Using double sided tape fix it on the wall. And connect a power bank to power the circuit.

Fixing the Setup on Wall using Double Sided Tape

NOTE :  Total load required in this circuit setup is minimal , leading to automatic switching of 
        power bank in some cases, this can be overcome by connecting another loade like mobile phone 
        on to the power bank.

Laser Arm

1)Make the following circuit connection to the Medusa Head for SparkFun ESP 32

Medusa Laser Diode – 33

Medusa Push Button – 32

Medusa LCD Display- I²C

Component Connection for Laser Arm

2) Power the circuit using a lipo battery

Lipo Battery being placed in between the SparkFun ESP 32 board and Base Shield of Medusa Head.

3) Next step is to wrap the components on to hand, using a crepe band. Place the components in the required position on to your hand , with the help of double sided tape. In the demo for the blog , the Push Button was placed inside the palm , while Medusa Heas as well as LCD display on wrist , and laser diode in between the nuckles of the fingers. Then the Crepe band is bound on to it.

Sample of a Crepe band Wrap.

ENJOY LASER TAG GAME WITH YOUR FRIENDS !!!

CODE

Dartboard –

The following code works as mentioned: To start the game, touch the Medusa Touch Sensor, which makes the buzzer give a sound indicating the start of the count to the participant. Simultaneously the LCD screen displays start and the count which spans for a minute (60 Seconds)

#include 
#include 
#include 

//Define the pin to which the modules are connected
#define touch 5
#define S1 33
#define S2 32
#define S3 25
#define buzzer 14


#define gameTime 60 //Game duration in seconds

Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield(); //Initialize the i2c LCD module

//Threshold values for the sensors. If reading exceeds this threshold value, it is considered as point scored
int S1threshold = 256;
int S2threshold = S1threshold;
int S3threshold = S1threshold;


int score = 0; //Initialize score to zero
boolean touchReleased = true; //Determine if the user has released his finger from the touch sensor

unsigned long startTime = millis(); //Variable to keep track of the start time of the game
boolean gameStarted = false; //Variable to keep track whether the game has started or not. 

void setup() {

 
 // put your setup code here, to run once:
 //Initialize all pins
 pinMode(touch,INPUT);
 pinMode(S1,INPUT);
 pinMode(S2,INPUT);
 pinMode(S3,INPUT);
 pinMode(buzzer,OUTPUT);
 
 //Initialize the LCD
 lcd.begin(16,2);
 lcd.setBacklight(HIGH);
 lcd.print("Start");
 //Initialize the Serial for debug purposes. 
 Serial.begin(9600);
}

void loop() {
 analogRead ( S1);
 analogRead ( S2);
 analogRead ( S3);
 Serial.println (analogRead ( S1));
 Serial.println ( analogRead ( S2) );
 Serial.println ( analogRead (S3));
 
 
 // put your main code here, to run repeatedly:
 if(digitalRead(touch) && !gameStarted) // Check if touch sensor is pressed and that game has not started
 {
 touchReleased = false;
 startGame();
 }
 else if(digitalRead(touch) && touchReleased && gameStarted) // Check if a) touch sensor is pressed b) user has released his hand from the touch sensor since game start
 // and c) whether the game has already started
 {
 touchReleased = false;
 stopGame();

 }
 else if(!digitalRead(touch)) //Check if user has released his finger from the touch sensor
 {
 touchReleased = true;
 }
 // If game has already started, a) update the display if game is not over b) if timer has exceeded stop the game. 
 if(gameStarted)
 {
 // If time has exceeded game time, stop the game
 if(((millis() - startTime)/1000)>=gameTime)
 {
 stopGame();
 }
 else
 {
 //If the game is going on, update the display
 lcdUpdate();
 //Check if any of the sensors are triggered
 if ((analogRead(S1)>S1threshold) || (analogRead(S2)>S2threshold) || (analogRead(S3)>S3threshold))
 {
 //If any of the sensors is triggered, increase the score
 score++;
 digitalWrite(buzzer,HIGH); // Turn on the buzzer
 delay(500); // Wait 1 second
 digitalWrite(buzzer,LOW); // Turn off the buzzer
 delay(250);
 
 }
 }
 }
}

//Function to be run when stopping the game
void stopGame()
{
 digitalWrite(buzzer,HIGH); // Turn on the buzzer
 delay(1000); // Wait 1 second
 digitalWrite(buzzer,LOW); // Turn off the buzzer
 lcd.clear(); // Clear the LCD
 lcd.print("Score: "); //Print the score
 lcd.print(score);
 lcd.setCursor(0,1);// Move the cursor to the Second row
 lcd.print("Time Left: 0"); 
 gameStarted = false; //Reset the game started variable
}
//Function to be run when start the game
void startGame()
{
 digitalWrite(buzzer,HIGH); // Turn on the buzzer
 delay(1000); // Wait 1 second
 digitalWrite(buzzer,LOW); // Turn off the buzzer
 score = 0; // Reset the score
 startTime = millis(); // Initialize the game start variable
 lcdUpdate(); // Update the display 
 gameStarted = true; // Set variable to determine whether game has started or not. 
}

void lcdUpdate()
{
 lcd.home(); // Move cursor
 lcd.print("Score: "); // Display score
 lcd.print(score);
 lcd.setCursor(0,1);
 lcd.print("Time Left: "); // Display the time left
 lcd.print(" ");
 lcd.setCursor(11,1);
 lcd.print((gameTime - (millis() - startTime)/1000)); //millis() returns in milliseconds. The remaining time is determined by subtracting the elapsed time from the game time. 
}

The Laser Arm –

The following code works as mentioned: every time you press the push button, the laser goes on, for a duration of 1 second. The program is set to give 10 chances to a participant, and this is displayed on the LCD which displays the counts from 10 to 0, at the rate by which the participant uses the laser shot.

#include 
#include 
#include 

#define laser 5
#define trigger 36

Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();

int ammo = 10;

void setup() {
 // put your setup code here, to run once:
 pinMode(trigger,INPUT);
 pinMode(laser,OUTPUT);

 lcd.begin(16, 2);
 lcd.setBacklight(HIGH); 
 
 lcd.print("Ammo: ");
 lcd.print(ammo);

 
}

void loop() {
 // put your main code here, to run repeatedly:
 if(!digitalRead(trigger))
 {
 if(ammo>0)
 {
 digitalWrite(laser,HIGH);
 delay (200);
 digitalWrite(laser,LOW);
 ammo--;
 lcd.clear();
 lcd.print("Ammo: ");
 lcd.print(ammo);
 delay(250);
 }
 else
 {
 lcd.clear();
 lcd.print("LOW AMMO!!");
 for (int i = 0;i<10;i++)
 {
 lcd.setBacklight(LOW);
 delay(250);
 lcd.setBacklight(HIGH);
 delay(250);
 }
 ammo = 10;
 lcd.clear();
 lcd.print("Ammo: ");
 lcd.print(ammo);
 }
 }
 else
 {

 digitalWrite(laser,LOW);
 }
}

Resources:

IRON MAN ARC REACTOR

Rashmi Menon — Tue, 19 Dec 2017 09:34:13 +0000

Ironman Arc Reactor – DIY

Programming WS2812 RGB LEDs to produce various cool patterns.

OVERVIEW

Iron Man has always been one of the most popular among heroes of Marvel, especially among Tech Geeks and has been one of the popular choices at comic cons when it comes to showing off coolness with a dash of technology. On the other hand, due to its difficulty in implementation and costs involved, not many enthusiasts are able to build their own costumes. And here we have a DIY to make it easy.

This super fun DIY project will help you replicate the famous Arc Reactor which powers this superhero, along with various cool customizable patterns of glowing LED.

All you need is a circular cardboard cutting, some double-sided tape, Velcro, addressable RGB LEDs, the Medusa Head for Sparkfun ESP32 Thing and a LiPo battery to power the project.

Components for IronMan Arc Generator Project

Additionally, you can use a switch (Medusa Push Button) for some cool custom applications.

Medusa Head for SparkFun ESP32 Thing

Medusa Addressable RGB LED

700mAh Lithium Polymer Battery

Medusa Cable 150mm

Medusa Cable 1m

Medusa Push Button

CODE

Test Setup: (to check your code and try out cool patterns of led blink)

The first step is to choose an output pin. Let’s say 25 on Medusa Head. The LEDs are daisy chained, be sure to connect the output of one to the input of the next.

The Iron Man DIY Arc Reactor Set-ups

NOTE: During wiring, ensure that the OUT of the first LED goes to the IN of the next like as shown in the image below.

Medusa Addressable RGB LED connections

We will use simple Aurdino Code to Programme the setup, which you can refer to at the end of this post.

BUILDING INSTRUCTIONS

1. The first step is to make the cardboard cutout. Click here for the sample design of cardboard cutout, use a CD or go for a pattern of your choice.

Cardboard Cutouts for Placing the Components to make DIY IronMan ARC generator

2. Take some double-sided tape and fix the LEDs.

3. Next step is to connect the Medusa Addressable RGB LED together.

For this project, we are using 2 different Medusa Cables, the 15cm & the 1-meter variant. The 15cm variant is useful for daisy chaining the LED and the 1-meter variant to connect the first Medusa Addressable RGB LED to the Medusa Head for SparkFun ESP32 Thing.

The Medusa Addressable RGB LED are allow you to daisy chain (connect one board to the next) multiple boards to create a string of RGB LEDs using just one pin of the microcontroller.

4. Using the Velcro/Double sided tape, fix the disk under your t-shirt.

5. The SparkFun ESP32 comes with an onboard LiPo charger and booster which makes it easy to power the project using a single cell LiPo battery, the lower capacity ones can even fit between the Medusa Head and the SparkFun ESP32 Thing for a compact solution. It can also be powered using a typical mobile phone power bank.

And insert the medusa head into your pocket.

SHOW OFF your IRON MAN ARC REACTOR!!!

#include 

#define PIN 25

// Parameter 1 = number of pixels in strip
// Parameter 2 = Arduino pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(5, PIN, NEO_GRB + NEO_KHZ800);

// IMPORTANT: To reduce NeoPixel burnout risk, add 1000 uF capacitor across
// pixel power leads, add 300 - 500 Ohm resistor on first pixel's data input
// and minimize distance between Arduino and first pixel.  Avoid connecting
// on a live circuit...if you must, connect GND first.

void setup() {
  // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
  #if defined (__AVR_ATtiny85__)
    if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
  #endif
  // End of trinket special code

  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  colorWipe(strip.Color(0, 0,255), 60); // Blue
  colorWipe(strip.Color(0, 0,0), 60); // Black
  delay(25);
  colorWipe(strip.Color(0, 0,255), 60); // Blue
  colorWipe(strip.Color(0, 0,0), 60); // Black
  delay(25);
  colorWipe(strip.Color(0, 0,255), 60); // Blue
  colorWipe(strip.Color(0, 0,0), 60); // Black
  delay(25);
  fadeIn();
  fadeOut();
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i=0;i--)
  {
    for(int led = 0;led

Resources:

DRV8833 DC/Stepper motor driver hookup guide

Abhishek Nair — Wed, 28 Jun 2017 06:44:55 +0000

The Edwin Robotics DRV8833 breakout board is capable of controlling up to 2 DC motors or one bi/uni-polar stepper motor a max current of 1.2A. The DRV8833 comes with 2 full H-bridges which give bi-directional control of your DC motors. It is similar to the L9110S in its voltage range ( 2.7V – 10.8V), but carrying 50% more oomph. This makes it ideal for projects where the motors will be run from a 9V battery.

The board can be powered using the provided screw terminals or through micro-USB, checkout out micro-USB to DC Jack adapter if you would like to use a standard power adapter with the board

Hardware Required

Edwin Robotics DRV8833 Motor Driver	Arduino UNO	Male-Female Jumper wires
DC Geared Motor with Wheel	9V DC Battery Snapper	microUSB to DC Jack Female Connector

Features

Dual-H-bridge motor driver: can drive two DC motors or one uni/bi-polar stepper motor
Operating voltage: 2.7‌‌ V to 10.8 V
Output current: 1.2 A continuous (2 A peak) per motor
Motor outputs can be paralleled to deliver 2.4 A continuous (4 A peak) to a single motor
Inputs are 3V- and 5V-compatible
Under-voltage lockout and protection against over-current and over-temperature
Reverse-voltage protection circuit
Current limiting can be enabled by adding sense resistors (not included)

Pinouts:

DRV8833 Motor driver pin description

Power

Vm – This is the voltage supply for the motors. Keep this voltage between 2.7V and 10.8V. This Supply Pin is not Reverse polarity protected, so care must be taken while connecting jumper wires to it.
Power Screw Terminal: The Power Screw terminal is labelled with + and -, connect your power supply according to label, this terminal is reverse polarity protected.
USB Power In: You can power the board with micro USB connector provided; this is reverse polarity protected as well.
GND – This is the shared logic and motor ground. All grounds are connected

Signals

These are all ‘2.7V or higher logic level’ inputs

AIN1, AIN2 – Two inputs to the Motor A H-bridges. Speed control supported using PWM.
BIN1, BIN2 – Two inputs to the Motor B H-bridges. Speed control supported using PWM.
FLT -This is the Fault output, which will drive low if there’s a thermal shutdown or overcurrent.
SLP – sleep pin for quickly disabling the driver. On Board 10K pullup resistor provided to keep the driver enabled.

The control inputs are pulled low internally, effectively disabling the motor driver outputs by default. See the truth tables in the DRV8833 datasheet for more information on how the inputs affect the driver outputs.

The FAULT pin is an open-drain output that is driven low by the chip whenever an over-current, over-temperature-or under-voltage condition occurs. Otherwise, it remains in a floating state, so you will need to connect an external pull-up resistor (or use a micro-controller input with its built-in pull-up enabled) if you want to monitor fault conditions on the driver.

Note: There is a misprint on Silkscreen, BIN1 is printed in place of AIN1, refer the above image for correct pinouts description.

Note: we had Provided on board power LED, which will stay on whenever board is powered. You can disable the power LED with the jumper provided on the back, refer the image below for power LED (P-LED) Jumper

Current Limiting Pins

As/ Bs: The DRV8833 can perform current limiting for each motor H-bridge by connecting a resistor between As/Bs and ground to set the Motor A/ Motor B Limit.

By default , the current limiting feature is disabled and can be enabled by modifying the jumper, refer the image below:

Current Limiting and Status LED’s Jumper Pads.

The Current limiting can be enabled by cutting out the solder joint between the jumper Pads for Asen and Bsen. Once the jumper pads are modified you can either solder SMD resistor (1206 Size) on board or you can use the AS/BS headers pin to make connection with through hole resistors. You can also totally disable current limiting whenever needed by soldering the two jumpers on the back.

The current limiting rule is: LimitCurrent (amps) = 0.2 V / RSENSE

Add 1206 resistors here to modify the current supplied to the respective motors

Connection’s

You can use any stepper motor or dc motor rated upto 10.8v with this board. We have used the following kit to get it tested:

Robotics Kit

Refer the image below for the motor connections

Motor Connections

You can power the board using phone charger (1.25~ 2.5Ampere rated) using micro usb or use the 9v battery snapper with micro usb connector as shown below:

Power Supply Connections

Now connect the following pins to your Arduino board:

DRV8833 Motor Driver Breakout Pins	Arduino Pins
AIN1	2
AIN2	3
BIN1	4
BIN2	5

Arduino DRV8833 Connections

Test Codes

Once the connections are done, upload the following code:

#define Ain1 5
#define Ain2 6
#define Bin1 9
#define Bin2 10

int speed = 0;

void setup() {
pinMode(Ain1, OUTPUT);  //Ain1
pinMode(Ain2, OUTPUT);  //Ain2
pinMode(Bin1, OUTPUT);  //Bin1
pinMode(Bin2, OUTPUT);  //Bin2

}

void loop() {

    digitalWrite(Ain1,HIGH);
    digitalWrite(Ain2,LOW);
    digitalWrite(Bin1,HIGH);
    digitalWrite(Bin2,LOW);
    delay(700);
    digitalWrite(Ain1,LOW);
    digitalWrite(Ain2,LOW);
    digitalWrite(Bin1,LOW);
    digitalWrite(Bin2,LOW);

    digitalWrite(Ain1,LOW);
    digitalWrite(Ain2,HIGH);
    digitalWrite(Bin1,LOW);
    digitalWrite(Bin2,HIGH);
    delay(700);
    digitalWrite(Ain1,LOW);
    digitalWrite(Ain2,LOW);
    digitalWrite(Bin1,LOW);
    digitalWrite(Bin2,LOW);
  
}

Download DRV8833 Datasheet

References:

Adafruit Hookup Guide

Polulu Blog

Digital AC Mains Switch Hookup Guide

Abhishek Nair — Wed, 31 May 2017 14:24:44 +0000

Digital AC Mains Switch

Product Link

Looking to control lights and bulbs with microcontroller ? then, this digital AC switch boards is suitable for your application, this board is a great alternative for the solid state relay boards. This board comes pre-assembled with everything, all you need to do is to connect supply, load and digital interface pins.

The board posses following Electrical Characteristics:

Parameter	Max	Unit
Power	1000 (Tested)	Watt
Voltage	230 (Tested)	Volt
Voltage	110 (Not Tested)	Volt
Current	5 (Tested)	Ampere
Signal	24	Volt

The board is suitable to use with 3.3, 5, 12 and 24 volt systems, thus making it ideal for any voltage, the maximum ratings are mentioned in the table above and can change based on working conditions. The board is not tested on 110v lines, but its parts are compatible to work with 110V Supply. The on-board fuse are easily replaceable, in case of any damage. The mounting holes will give you the flexibility to screw it to any surface.

Connections:

All the connections must be made via screw terminals and we will recommend you to keep ready one screw driver beside you, before making connections. There are 4 screw terminals on board, please refer the image below for better idea:

Digital AC Mains Switch Interface

Refer the below table for Silkscreen/legend description:

Symbol	Description
Gnd	Ground
S	Digital Signal (Max upto 24V)
L	Live (To connect AC Supply Input)
N	Neutral
Load	Load (Connect to device to be controlled like Light /Bulb)

So you need to use ‘S’ and ‘Gnd’ Pin to interface your Microcontroller board with this unit, there are two ‘L’ and ‘N’ screw terminals, you just need to connect supply to any one from the both, the second one is to extend the supply to other boards/ peripherals. Loads such as light/fan,etc. must be connected across “Load” and ‘N’ Pin to establish the connection of the load with the board. You can use jumper wires to to connect microcontroller board and screw the jumper wires to interface “S and GND “pins.

Connection Diagram:

Digital AC Mains Switch connections

The microcontroller interface just needs 2 Pins, we connected Arduino ground with module ground and Arduino pin A0 as digital control for module. The load will go across Screw terminal where light bulb is connected and the power supply will go into either of the one Screw terminal.

Working with AC voltages is DANGEROUS, care must be taken to prevent any short circuits or mistakes in connection. And as always, you are doing this project at your own risk and Edwin Robotics or the Author cannot be held liable for any damages.

Sample Program:

To test the connections and board functions, we will recommend you to use the Blinking LED code from the Arduino examples, make sure to change the pin number in the code as follows:

#define LOAD A0

void setup() {
// initialize digital pin LOAD as an output.
pinMode(LOAD, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
digitalWrite(LOAD, HIGH); // turn the BULB on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LOAD, LOW); // turn the BULB off by making the voltage LOW
delay(1000); // wait for a second
}

Buy this Product here

Getting Started with ESP-WROOM-02

Abhishek Nair — Sun, 26 Mar 2017 10:13:59 +0000

Welcome to our Getting started guide on ESP-WROOM-02 board. We had already introduced this board in our previous guide Introduction to ESP8266, there we had mentioned about the ESP-WROOM-02 adapter board as well. Here in this blog, we are using ESP-WROOM-02 with Adapter board, since using the adapter board will give us the flexibility to build and test circuit on a breadboard. Let us have a look at the list of items we needed for getting started with ESP-WROOM-02.

Hardware Needed:

*ESP-WROOM-02 Board*	*Breadboard*	*3.3V Voltage Regulator*	*1K Resistors*
*100uf Electrolytic Capacitor*	*7mm Tactile Switch*	*5V Power Adapter*	*10k Resistor*
*5mm LED*	*Mini USB Cable*	*USB to Serial Converter*	*Jumper Wires*
*3.3uf Electrolytic Capacitor*	*Breadboard Power Supply*	*Micro USB Pin Breakout Board*	*0.1uf Ceramic Capacitor*

You do not need all the above mentioned hardware, some of them are optional, which we had mentioned in details in various sections below.

ESP-WROOM-02 Pinouts:

It is always important to understand the board which you are working with, is capable of what all stuffs, for this we had added a graphical pinouts and description below:

ESP-Wroom-02 Graphical Description

Circuit Schematics:

The ESP-WROOM-02 boards needs few external components to get it working, we had a schematics for ESP-WROOM-02 board below:

Circuit Schematics

Now, if you notice in the schematics, we had added pullup resistors on most of the communication lines, if you are not using those pins, you can ignore those resistors. But the resistors on following lines are must to get it working, i.e GPIO0, reset and enable.

Note: The power Supply schematics is not included in the above circuit.

The power supply to the circuit must be 3.3v and you can use any option to power the circuit, like using breadboard power supply(listed in the hardware needed section) and 9v battery or you can power the board directly from USB to serial converter, make sure that converter must be 3.3v logic ones and it is capable enough to supply minimum of 500mA. We tried to power the system from Sparkfun basic 3.3v FTDI converter but we had faced issue several times, if you are looking to power from converter only, we will recommend you to use the Sparkfun beefy FTDI board. We had used 5v Power Adapter and a 3.3V voltage regulator setup on breadboard to power the system, We had added the 3.3V voltage regulator Schematics below:

3.3V Voltage Regulator Schematics

The voltage Regulator Part is really Simple, if you seen the schematics, you can notice that, we used 4 capacitor in the circuit, Cout capacitor can be replaced with 3.3uF Capacitor or some other higher value than 10uF if you have. We supplied Vin from the 5v USB power Adapter (Refer the hardware needed section), we used the Micro USB Breakout Board (Refer the hardware needed section) to breakout the power lines from USB adapter, you can use your phone chargers as well,if you have these breakout board with you.

Make sure you use the proper pins of the voltage regulator while assembling your circuit. Refer the LD33V pinouts below:

LD33V Pinouts

Now, its time to assemble all this circuit into a breadboard, make sure you follow the connections, as shown, otherwise, your circuit might not work.

Assemble the Circuit on a Breadboard:

The first thing in the breadboarding is always begin with Power supply, if you are using breadboard Power Supply module (Refer the hardware needed section) then you do not have to worry much, all you need is battery with DC Jack Male Connector or you might have power adapter with DC Male Jack on it, use it and you are ready to go. Refer the below diagram for using a breadboard power supply.

Breadboard Power Supply

But we are using Voltage regulator to build our own power supply and which we can use to fed power from standard micro USB power adapter/ Mobile Charger. Refer the Power Supply section below for better idea on this.

3.3V Breadbord Power Supply

Note: If you are using some other voltage regulator than what we mentioned, then make sure that you cross check the pinouts and connect accordingly. Refer the hardware needed section for the USB Breakout Board which you can use.

Once the power supply is done, now we will assemble the circuit for ESP-WROOM-02 Board as shown in the schematics above.

ESP-WROOM-02 Breadboard Arrangement

Now you are all done with connections, now its time to upload the code, now for this you need a USB to Serial Converter to establish a Serial communication between the WROOM board and the computer. We used the sparkfun basic ftdi board to made it work, you can use any 3.3V logic converter to do the serial communication, just make sure to make the proper connection with this WROOM board. For this we had added a simple graphical representation, where you need to make the connections, refer the image below:

ESP-WROOM-02 Serial Communication

As you can see that it is clearly labeled which connection will go where into this breadboard, all you need to do is connect jumper wires to your Serial Converter and connect it exactly at the same position, i.e RX,TX and GND , these three lines are required. There is no need to cross connect the RX TX line, since it is already been take care of while labeling, just connect straight away the converter TX pin to WROOM pin 11 and Converter RX pin to WROOM pin 12 and common ground is must between the circuits. Lets begin with programming the WROOM board.

Uploading first Program

Step 1: Put the WROOM Board in Program Download Mode:

Since you are ready with hardware, its time to put the WROOM board into UART Download mode,to do so, all you need to do is:

Press both the RESET button and PROGRAM Button together.

Leave the RESET button alone and keep Pressing the PROGRAM button for 1 more second.

Leave the PROGRAM Button, now you are in UART Download mode.

So every time, when you need to upload the code, you have to do this before uploading, this is because the “auto Program” is not implemented in the circuit we built. To do so you need to add some transistors and you need to make some more connections from the Serial Converter board, this feature is not covered in this tutorial. Refer the Reset and Program Switch in the above image.

Step 2: Set proper serial port and board in the Arduino

Once the board is in download mode. You need to Open the Arduino and install the ESP8266 Core for the Arduino, if you have this in Arduino, you can ignore this. If you don’t have any ESP8266 board present in you Arduino. You need to do the following :

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Add the above mentioned line to Arduino: File -> Preferences -> Additional Board Managers URL

If there is an entry already, add the line by inserting a comma. If you need more instruction visit this github page.

Restart the Arduino after above step and open the boards manager from tools -> boards option and install the ESP8266 Core to the boards, after installation ,restart the Arduino again and you will see a set of ESP8266 boards as follows:

ESP8266 Boards

Now if you see we had selected the board option as ThaiEasyElec’s ESPino , we tried out other boards as well and we did not had any issue with other boards as well. The common setting for most of the board is to set the frequency to 80Mhz, you can overclock the board if needed. Flash Size if available set to 2M, else leave it to defualt option. The WROOM board comes with 2MB SPI Flash with four supported SPI modes: Standard SPI, DIO (Dual I/O), DOUT (Dual Output), QIO (Quad I/O) and QOUT (Quad Output).

Refer the latest WROOM Board Datasheet here

Once the Clock and Flash is set, select the proper serial port and you are ready to upload the code.

Step 3: Upload the first program

Since you are done with everything, lets begin uploading the first code. Refer the image below:

Example Program

Upload the following code from File -> Examples -> ESP8266 -> Blink

/*
 ESP8266 Blink by Simon Peter
 Blink the blue LED on the ESP-01 module
 This example code is in the public domain
 
 The blue LED on the ESP-01 module is connected to GPIO1 
 (which is also the TXD pin; so we cannot use Serial.print() at the same time)
 
 Note that this sketch uses LED_BUILTIN to find the pin with the internal LED
*/

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);     // Initialize the LED_BUILTIN pin as an output
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, LOW);   // Turn the LED on (Note that LOW is the voltage level
                                    // but actually the LED is on; this is because 
                                    // it is acive low on the ESP-01)
  delay(1000);                      // Wait for a second
  digitalWrite(LED_BUILTIN, HIGH);  // Turn the LED off by making the voltage HIGH
  delay(2000);                      // Wait for two seconds (to demonstrate the active low LED)
}

Note: Make Sure the converter is connected and board is in program Download Mode.

Once uploaded you can see that the LED connected in the GPIO Pin 16 will start blinking. The LED_BUILTIN is defined different to other boards but for ThaiEasyElec’s ESPino board, the LED_BUILTIN is set to GPIO 16, if you still feel doubtful we will recommend you to initialize pin numbers manually with pinMode(Pin_number, INPUT/OUTPUT);

Note: If you are not able to get any blinking, try the serial window debugging and if you are getting any WDT(Watchdog Timer) related issues, try changing the power supply, since the WROOM board needs a stable power supply.

Hope you enjoyed this getting started tutorial, now its your turn to build some cool IoT Projects with this cheap and tiny little board. Do let us know, what you build with this little beast. We are happy to help if you found yourself in some sort of trouble.

MCP23S17 – Hook Up Guide

emil — Sun, 26 Mar 2017 05:51:10 +0000

Introduction

The MCP23S17 is a SPI Based Port Expander which can add 16 more digital I/O pins to your Arduino or Raspberry Pi. Thanks to the wide operating voltage of 1.8 – 5.5V, you can add 5V I/O pins to the Raspberry Pi or 3.3V based Arduino thereby avoiding a level shifter and simplifying connections.

Hardware Required:

MCP23S17 Port Expander

Breadboard

Jumper Wires

Board Overview

The board consists of 2 Port Banks (A and B), a 3-way switch, power and SPI headers

3-Way switch is used to set the address of the Port Expander, the switch positioned towards ON sets the address as ‘0’. The image above sets the address as ‘7’

INT B Interrupt output for PortB

B.0 – B.7 Bidirectional I/O

INT A Interrupt output for PortA

A.0 – A.7 Bidirectional I/O

VCC Power supply pin for the MCP23S17, connect to a voltage source between 1.8V -5V

GND connect to ground of power supply

SO, SI, SCK & CS SPI Pins

RESET connect to ground to reset the port expander

Note: The silkscreen on Port A is reversed, meaning INT A actually is A.7 and A.7 actually is INT A

Enabling SPI on the Raspberry Pi

By default the SPI peripheral is not enabled, we cannot continue unless this is done first. Have a look at the tutorial by SparkFun on how to do this.

Interfacing the MCP23S17 Port Expander with the Raspberry Pi

Interfacing the MCP23S17 to the Raspberry Pi

Connections from Raspberry Pi to MCP23S17 Port Expander

MCP23S17 Pin	Raspberry Pi GPIO Pin
VCC	5V/3.3V
GND	GND
SO	SPI_MISO / GPIO9 / Pin 21
SI	SPI_MOSI / GPIO10 / Pin 19
SCK	SPI_CLK / GPIO11 / Pin 23
CS	SPI_CE0_N / GPIO8 / Pin 24

Installing the Python Library

In order to get started the python library needs to be installed first. Run the following command in terminal to install the library

sudo pip install RPiMCP23S17

Sample Code

The below code will turn ON and OFF all the pins at an interval of 1 second.

from RPiMCP23S17.MCP23S17 import MCP23S17
import time

mcp = MCP23S17(bus=0x00, ce=0x00, deviceID=0x00)
mcp.open()

for x in range(0, 16):
    mcp.setDirection(x, mcp.DIR_OUTPUT)

print "Starting blinky on all pins (CTRL+C to quit)"
while (True):
    for x in range(0, 16):
        mcp.digitalWrite(x, MCP23S17.LEVEL_HIGH)
    time.sleep(1)
    for x in range(0, 16):
        mcp.digitalWrite(x, MCP23S17.LEVEL_LOW)
    time.sleep(1)

Introduction to ESP8266

Abhishek Nair — Wed, 22 Mar 2017 12:48:44 +0000

This quick guide will give you idea about ESP8266 and some boards based on it. The ESP8266 (presently ESP8266EX), it is a chip with which manufacturers are making wirelessly networkable micro-controller modules. More specifically, ESP8266 is a system-on-a-chip (SoC) with capabilities for 2.4 GHz Wi-Fi (802.11 b/g/n), general-purpose input/output, Inter-Integrated Circuit (I²C), analog-to-digital conversion (10-bit ADC), Serial Peripheral Interface (SPI), I²S interfaces with DMA (sharing pins with GPIO), UART and pulse-width modulation (PWM). It employs a 32-bit RISC CPU based on the Tensilica Xtensa LX106 running at 80 MHz (or overclocked to 160 MHz). It has a 64 KB boot ROM, 64 KB instruction RAM and 96 KB data RAM. External flash memory can be accessed through SPI.

The ESP8266 is an amazing chip for all your home automation & Internet of Things projects. This chip costs less and has WiFi connectivity and is compatible with the Arduino IDE.Various vendors have consequently created modules containing the ESP8266 chip at their cores. Some of these modules have specific identifiers, like “ESP-01” through “ESP-13”. ESP8266-based modules have demonstrated themselves as a capable, low-cost, networkable foundation for facilitating end-point IoT developments. Espressif’s official module is presently the ESP-WROOM-02. The AI-Thinker modules are labeled ESP-01 through ESP-13. NodeMCU boards extend upon the AI-Thinker modules. Olimex, Adafruit, Sparkfun, WeMos, ESPert (ESPresso) all make various modules as well. See this ESP8266 article for more information about popular ESP8266 modules. There are many choices available in the market, and it is easy to get lost between all of them. we do have a bunch of them in our store, check out our ESP8266 boards collection.

First, We would like to show you the basic ESP8266 module, i.e ESP-01

ESP-01 Module

ESP-01

This is the first module that came out on the market. It is the cheapest and nearly the smallest module available. It is perfectly usable with the Arduino IDE for example.However, it comes with serious disadvantages. First, you can’t plug it into a breadboard without an adapter or you need to use jumper wires. Then, you don’t have access to all the input/output pins of the ESP8266 chip, which is a problem if you have complex projects that you want to build. However, for simple projects, this is a good module to start with.

Have a look at the pinouts:

ESP-01 Pinouts

1	GND
2	GPIO1/U0TXD/SPI_CS1
3	GPIO2/U1TXD
4	CHIP_EN/CH_PD
5	GPIO0/SPI_CS2
6	RST
7	GPIO3/U0RXD
8	VCC(3.3V)

ESP-WROOM-02 Module

ESP-WROOM-02 is a low-power 32-bit MCU Wi-Fi module, based on the ESP8266 chip. TCP/IP network stacks, 10-bit ADC, and HSPI/UART/PWM/I2C/I2S interfaces are all embedded in this module.It uses a 2 MB SPI flash connected to HSPI, working as the SDIO/SPI slave with the SPI speed of up to 8 Mbps. This module can be easily integrated into space-limited devices, due to its small size of only 18mm x 20mm x 3mm.

ESP-WROOM-02

This official WROOM board is perfect option if you are planning to build something using ESP8266 Core. This module has most of the things built in, you just needs few external components to get it working. The Board comes in SMD package, thus saving the space on the mother board. Due to its tiny size its perfect for IoT applications. Following pins are accessible on the WROOM board:

ESP-WROOM-02 Pinouts

Pin Number	Pin Name	Pin Functions
1	3V3	3.3V power supply (VDD)
2	EN	Chip enable pin. Active high
3	IO14	GPIO14; HSPI_CLK
4	IO12	GPIO12; HSPI_MISO
5	IO13	GPIO13; HSPI_MOSI; UART0_CTS
6	IO15	GPIO15; MTDO; HSPICS; UART0_RTS
7	IO2	GPIO2; UART1_TXD
8	IO0	GPIO0
9	GND	GND
10	IO4	GPIO4
11	RXD	UART0_RXD; GPIO3
12	TXD	UART0_TXD; GPIO1
13	GND	GND
14	IO5	GPIO5
15	RST	Reset the module
16	TOUT	It can be used to test the power-supply voltage of VDD3P3 (Pin3 and Pin4) and the input power voltage of TOUT (Pin 6). However, these two functions cannot be used simultaneously.
17	IO16	GPIO16; can be used to wake up the chipset from deep sleep mode.
18	GND	GND

But it is very difficult to start using ESP-WROOM-02 PCB without any soldering, thus we are offering a presoldered ESP-WROOM-02 Adapter board in out store.Have a look at the adapter board below:

ESP-WROOM-02 with Adapter Baord

ESP-WROOM-02 Board with Adapter

This board is perfect to use with breadboard, you do not need any soldering, it will sit easily on the breadboard. This board will also give you the option to solder the board easily to proto boards, without any complication. The adapter board dimensions will be 25.5mm x 26mm.

We do have different types of ESP8266 boards from different manufacturers which uses ESP8266 as it core. The difference in these boards is that every manufacturer will add their own peripherals and their own standard pinouts, even some boards comes with onboard USB to Serial Converter, so it will be very easy to program those board. Have a look at the ESP8266 Boards we having with us.Below we had added the Summary table for ESP8266 modules, to get better idea and see the difference between them:

Board ID	pins	pitch	form factor	LEDs	Antenna	Ant.Socket	Shielded	dimensions mm	Flash Size (KB & Mb)
ESP-01	8	.1“	2×4 DIL	Yes	Etched-on PCB	No	No	14.3 x 24.8	512KB – 4Mb
ESP-02	8	.1”	2×4 notch	No?	None	Yes	No	14.2 x 14.2	512KB – 4Mb
ESP-03	14	2mm	2×7 notch	No	Ceramic	No	No	17.3 x 12.1	512KB – 4Mb
ESP-04	14	2mm	2×4 notch	No	None	No	No	14.7 x 12.1	512KB – 4Mb
ESP-05	5	.1“	1×5 SIL	No	None	Yes	No	14.2 x 14.2	512KB – 4Mb
ESP-06	12+GND	misc	4×3 dice	No	None	No	Yes	16.3 x 13.1	512KB – 4Mb
ESP-07	16	2mm	2×8 pinhole	Yes	Ceramic	Yes	Yes	21.2 x 16.0	1024KB – 8Mb
ESP-07S	16	2mm	2×8 pinhole	No	None	Yes	Yes	17.0 x 16.0	1024KB – 8Mb
ESP-08	14	2mm	2×7 notch	No	None	No	Yes	17.0 x 16.0
ESP-08 New	16	2mm	2×8 notch	No	None	No	Yes	18.0 x 16.0
ESP-09	12+GND	misc	4×3 dice	No	None	No	No	10.0 x 10.0
ESP-10	5	2mm	1×5 notch	No	None	No	No	14.2 x 10.0	512KB – 4Mb
ESP-11	8	1.27mm	1×8 pinhole	No	Ceramic	No	No	17.3 x 12.1	512KB – 4Mb
ESP-12	16	2mm	2×8 notch	Yes	Etched-on PCB	No	Yes	24.0 x 16.0	4096KB – 16Mb
ESP-12-F	22	2mm	2×8 notch	Yes	Etched-on PCB	No	Yes	24.0 x 16.0	4096KB – 16Mb
ESP-12-E	22	2mm	2×8 notch	Yes	Etched-on PCB	No	Yes	24.0 x 16.0	4096KB – 16Mb
ESP-12S	16	2mm	2×8 notch	Yes	Etched-on PCB	No	Yes	24.0 x 16.0	4096KB – 16Mb
ESP-13	18	1.5mm	2×9		Etched-on PCB	No	Yes	20.0 x 19.9	4096KB – 16Mb
ESP-14	22	2mm	2×8 + 6	1	Etched-on PCB	No	Yes	24.3 x 16.2
WROOM-02	18	1.5mm	2×9	No	Etched on PCB	No	Yes	20.0 x 18.0
WT8266-S1	18	1.5mm	3×6	1	Etched on PCB	No	Yes	15.0 x 18.6

Hope things are more clear to you now, before we finish with this blog, have a look at variety of projects and tutorials based on the ESP8266 boards we had added in our blog.

Learn with Edwin Robotics

DIY Remote Control Car

Introduction to Ardublockly using Medusa – Reading a digital sensor

Buzzing a Buzzer using a Digital Sensor

Resources:

Introduction to Ardublockly using Medusa – Blinking an LED

Prerequisites:

Blinking an LED

Resources:

Laser Tag

OVERVIEW:

There are 2 parts to this project:

Dartboard

Laser Tag –

Building Instructions

Dartboard

Laser Arm

ENJOY LASER TAG GAME WITH YOUR FRIENDS !!!

CODE

Resources:

IRON MAN ARC REACTOR

OVERVIEW

CODE

BUILDING INSTRUCTIONS

SHOW OFF your IRON MAN ARC REACTOR!!!

Resources:

DRV8833 DC/Stepper motor driver hookup guide

Hardware Required

Features

Pinouts:

Power

Signals

Current Limiting Pins

Connection’s

Test Codes

Download DRV8833 Datasheet

Digital AC Mains Switch Hookup Guide

Connections:

Connection Diagram:

Working with AC voltages is DANGEROUS, care must be taken to prevent any short circuits or mistakes in connection. And as always, you are doing this project at your own risk and Edwin Robotics or the Author cannot be held liable for any damages.

Sample Program:

Buy this Product here

Getting Started with ESP-WROOM-02

Hardware Needed:

ESP-WROOM-02 Pinouts:

Circuit Schematics:

Assemble the Circuit on a Breadboard:

Uploading first Program

Step 1: Put the WROOM Board in Program Download Mode:

Step 2: Set proper serial port and board in the Arduino

Step 3: Upload the first program

MCP23S17 – Hook Up Guide

Introduction

Hardware Required:

Board Overview

Enabling SPI on the Raspberry Pi

Interfacing the MCP23S17 Port Expander with the Raspberry Pi

Connections from Raspberry Pi to MCP23S17 Port Expander

Installing the Python Library

Sample Code

Further Reading

Introduction to ESP8266

ESP-01 Module

ESP-01 Pinouts

ESP-WROOM-02 Module

ESP-WROOM-02 Pinouts

ESP-WROOM-02 with Adapter Baord