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

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

Power Supply Connections

Arduino DRV8833 Connections

Test Codes

#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

Bluetooth is a wireless technology standard for exchanging data over short distances (using short-wavelength UHF radio waves in the ISM band from 2.4 to 2.485 GHz) from fixed and mobile devices, and building personal area networks (PANs). Range is approximately 10 Meters (30 feet). The Bluetooth Module Bluetooth HC-06s with Bluetooth V2.0 have proven themselves to be very reliable and easy to use module, these module uses serial interface for communication , thus very easy to interface with any microcontroller/Computer over RX/TX Lines.

You can refer the list of items we are covering in this hookup guide here:

1. Hardware Needed
2. Board Description
3. Pin Description
4. Jumper Description
5. AT Commands and Arduino Interface Code
6. Datasheets

Hardware Needed:

Edwin Robotics Bluetooth Module - HC06

Male-Female Jumper Wires

Board Description:

The HC-06 modules are based on the Cambridge Silicon Radio BC417 2.4 GHz Bluetooth Radio chip. This is a complex chip which uses an external 8 Mbit flash memory. These low-cost Bluetooth Sub-modules work well with Arduino and other Microcomputers. HC-06 is a Slave only device.The module has two modes of operation, Command Mode where we can send AT commands to it and Data Mode where it transmits and receives data to and from another Bluetooth module. By default the device was in Command mode and needs to pair with some device to get it into data mode.

Edwin Robotics Bluetooth Module – HC06

There are two LED’s on board for indication, refer the diagram below, for better idea:

LED Indication

Pins/Headers:

Board needs 4-lines to communicate most of the times, i.e Vcc, Gnd, RX and TX pin. There are two additional pin onboard, one is Key pin and the other is Reset pin, this Reset pin can be used to send reset signal from microcontroller to reset the bluetooth module. Refer the table and image below in detail:

Silkscreen

Jumper’s:

There are Jumpers provided on the bottom side of the module, refer the below image and table for better idea:

Jumper Settings

AT Commands:

The bluetooth module supports some limited commands set, which you can refer from the datasheet, we had addded the code below, to get the AT command interface working on any Arduino board. All the Supported commands are well documented in the code below, make sure of following things:

• nl/cr line endings not required in the serial window.
• AT commands are required to be in upper case
• Default Serial Communication baud rate: 9600

/**********************************************************************************
AT_Command_Interface.ino

Description:
  Sample AT Command Interface code for Arduino and HC06 Bluetooth Module

Tutorial Link:  
  learn.edwinrobotics.com/hc-06-bluetooth-module-hookup-guide

Created by:
  Abhishek Nair @ Edwin Robotics
  Feb 9th 2017

Distributed as-is; no warranty is given.   
**********************************************************************************/
#include <SoftwareSerial.h>

SoftwareSerial mySerial(2, 3); // RX, TX

void setup() {

Serial.begin(9600);
Serial.println("------------------------------------------------------------------------------------------");
Serial.println("             Edwin Robotics HC06 Bluetooth Module Serial Interface ");
Serial.println("------------------------------------------------------------------------------------------");
Serial.println("                 Connect Bluetooth Module RX -> Arduino pin 3 ");
Serial.println("                 Connect Bluetooth Module TX -> Arduino pin 2 ");
Serial.println("------------------------------------------------------------------------------------------");
Serial.println("");
Serial.println("Entered AT command Mode, please Enter AT Commands from the list of supported commands:");
Serial.println("******************************************************************************************");
Serial.println("AT              > connection test command. Returns OK");
Serial.println("");
Serial.println("AT+BAUDx        > sets the baud rate to respective board rate for entered 'x' value(refer values below) and returns OKBaud_Rate");
Serial.println("                   1: 1200  2: 2400  3: 4800  4: 9600  5: 19200  6: 38400  7: 57600  8: 115200  9: 230400  A: 460800  B: 921600  C: 1382400");
Serial.println("");
Serial.println("AT+NAME(myName) > sets the name to (myName), returns OKsetname");
Serial.println("");
Serial.println("AT+PIN9999      > changes the PIN to 9999, returns OKsetPIN");
Serial.println("");
Serial.println("AT+VERSION      > returns the firmware version : hc01.comV2.0");
Serial.println("");
Serial.println("AT+LED0         > turn off the blue LED, returns LED OFF");
Serial.println("");
Serial.println("AT+LED1         > turn on the blue LED, returns LED ON");
Serial.println("");
Serial.println("AT+PN           > sets no parity");
Serial.println("");
Serial.println("AT+PE           > sets even parity");
Serial.println("");
Serial.println("AT+PO           > sets odd parity");
Serial.println("******************************************************************************************");
Serial.println("");

mySerial.begin(9600);
delay(300);
Serial.println();
Serial.println("Note: if 'Version: hc01.comV2.0' is not printed below, make sure that your connections are correct or your module is not connected to any other device,try restarting the device/Serial Window");
Serial.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------");
Serial.print("Version: ");
mySerial.write("AT+VERSION");
}

void loop()
{
  if (mySerial.available())
    Serial.write(mySerial.read());

  if (Serial.available())
    mySerial.write(Serial.read());
}

Datasheets:

Download English Datasheet : In this datasheet, the photo would appear to be of an older version but the commands, pins and functionalities are same.
Download Chinese Datasheet

Other command which we did not added in the code but can be found in the data sheet is the ROLE command:
AT+ROLE=S puts the module in to SLAVE mode, returns OK+ROLE:S
AT+ROLE=M puts the module in to MASTER mode, returns OK+ROLE:M
We did not seen any affect or usage of this command, we will update this section , if there is some information on this part from the manufacturer.

Ardublockly

Ardublockly is a visual programming language that is based on Google’s Blockly. Being a visual programming language you don’t need to worry about remembering syntaxes or missing semicolons. The Arduino code is generated when the blocks are connected to perform an action. Ardublockly also displays the actual C code that is being uploaded making it easier to understand what goes on in the background.
 

Installing & Configuring Ardublockly

Get the latest version of Ardublockly from its github page. Do ensure that you have the latest Arduino IDE installed as well, check the Arduino guide for more info on how to install Arduino.
Installing on Windows

1. Extract Ardublockly – Once you have downloaded the latest version of Ardublockly, extract it to a location of your choosing.
2. Run Ardublockly – In the Ardublockly folder run the ardublockly_run.bat. This will run Ardublockly and create the ServerCompilerSettings.ini file that we need to modify to get Ardublockly working. Once Ardublockly has successfully started you should see the Ardublockly homescreen.
   

   Ardublockly IDE

3. Close Ardublockly – Now that the ServerCompilerSettings.ini has been created, we can close Ardublockly
4. Open ServerCompilerSettings.ini file using Wordpad – The ServerCompilerSettings.ini file needs to be edited to configure the location of arduino_debug.exe
   Note: Open the file using pretty much any text editor other than notepad as notepad does not recognize the line breaks properly
5. Add location of arduino_debug.exe –   The location of arduino_debug.exe if installed via the Arduino installer, will be located at C:\Program Files (x86)\Arduino\arduino_debug.exe
   

   ServerCompilerSettings.ini configured using wordpad

6. Run Ardublockly – To test whether it has been configured properly, run ardublockly_run.bat and open the preferences ( Edit → Preferences) it should show a window like this
   

   Ardublockly Preferences

7. Select Board & Port – Next select the board that is being used, in our case it is the UNO. The available serial port will be shown only if the Arduino is connected.
8. Test Configuration – To ensure everything is all set and done click on the verify button

Ardublockly Verify

Verify Successfully

• If all goes well the Successfully Verified Sketch will be displayed, this may take 20-30 seconds on some machines.

Blinking An LED

• The first step should be to add the Arduino Run First/Arduino Loop Forever block although this is not necessary it will help keep your code clean. It can be found under the functions category

 


• This block lets define what instructions need to be run first and what needs to run forever. Most instructions will come under the latter.
• Next involves setting the digital pin onto which the LED is connected as either HIGH (ON) or LOW (OFF), this block can be found under the Input/Output category

 


• The on board LED is connected to pin 13, set the pin# to 13 to be able to turn ON the LED. Next comes the delay this will ensure that the pin stays in the HIGH (ON) state for a set period of time. This can be found under the Time category. The time is set in milliseconds, 1 second = 1000 milliseconds.

 


• These 2 steps needs to be repeated again but in the LOW state to turn off the LED. The final code will be as follows.

Blink Code

• Click the upload button to push the code to the Arduino.

Upload Button (Center Button)

• If all goes well, the LED should start blinking now.

Successful Upload

Want to check if you left your lights ON remotely, need to detect the zero crossing point for your dimming circuit or do you just need to interface a 230V signal to your Arduino? The AC Mains Detector board simplifies interfacing high voltage signals by giving a digital output when an AC voltage is detected. By disabling the on board capacitor, zero crossing detection is possible as well.

AC Line detection Module

You can buy this item from the following links:

Within GCC: Edwin Robotics

International Order: Tindie

Let us have a look at the guide contents, refer to the list below:

• Components

• Board Pinouts

• Circuit Schematics

• Interfacing with Arduino

• Zero Crossing detection using Arduino

Components

AC Line detection Module

Arduino UNO

Male-Female Jumper wires

Board Pinouts

Top Side

Bottom Side

• AC-IN – Connect the AC line that needs to be detected here.
• – (negative sign) – Connect to ground of microcontroller
• + (positive sign) – Connect to VCC of microcontroller in case external pull-up is required
• S – Connect to a digital/interrupt pin of microcontroller

Note: 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.

Circuit Schematics

The circuit consists of two main parts, first is the Bridge Rectifier (DB107) which converts the AC signal to DC and the second is the Optocoupler (LTV816), which provides isolation between High voltage(HV) side and Low Voltage (LV) Side.

A pull-up resistor is provided for use with microcontrollers (e.g. ESP8266) that do not have an internal pullup resistor.

Interfacing with Arduino

The hardware connections are pretty straightforward. On the low voltage side the + (positive symbol) goes to VCC of microcontroller, – (negative symbol) goes to GND and S goes any digital/interrupt pin. On the high voltage side, the AC lines are connected.

Arduino Connections

In this example, Pin 2 on the arduino is used in this example as it can be used as an interrupt pin as well.

Sample Code:

#define Signal_Pin 2  // Modify this pin as per your connection

void setup() {
  pinMode(Signal_Pin , INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  if ( digitalRead(Signal_Pin) == 0 )
    Serial.println (" AC Mains 230v Detected ");
}

Note: Do not touch the PCB once powered, you can get electrocuted. Keep it away from reach of humans/Animals. Make sure that there are no shorted wires, when connecting the 230v AC mains supply.

Zero Crossing Detection using Arduino

By default zero crossing detection is disabled by the use of a 2.2uF capacitor, in order to use the board for zero crossing detection the capacitor needs to be bypassed by cutting the trace shown below. It can be resoldered at any time later to disable zero crossing:

Modify the jumper

The Arduino connection will be same as before, upload the following code and view the output on Serial Monitor at 9600 baud rate:

#define Signal_Pin 2 //Use Arduino Pin 2 or pin 3, both supports hardware interrupt
int counter=0;

void setup()
{
  pinMode(Signal_Pin , INPUT_PULLUP);
  Serial.begin(9600);
  attachInterrupt(0, zero_crosss_int, RISING);  // Choose the zero cross interrupt # from the table above
}

void zero_crosss_int()  // function to be fired at the zero crossing to dim the light
{
  counter++;
}

void loop()
{
  Serial.println(counter);
}

You can see that the counter value increases with every cycle of AC line and the moment you turn off the AC line, the counter Stops as well.

References:

• DB107 Rectifier Datasheet
• LTV-816 Datasheet

To understand transistor better we will start with one of the basic component we seen in electronic circuit, its nothing but switch, refer the image below:

These switches are nothing but momentary push buttons, means when you press them then only it will be functional(i.e ON) otherwise it will remain OFF. Lets build a simple circuit on breadboard using a switch, refer the image below to build your circuit:

Note: We had Connected 5v supply and GND from Arduino board in the above image, you can use Raspberry Pi or any other boards you having with you to supply 5v and GND from the board. If you having our Raspberry Pi Electronics Starter kit with you, then you can use the RasPiO Portplus we provided with the kit, to find the 5v and GND pins on Raspberry Pi and use the Male-Female Jumper wire we provided in the Kit to Supply power to the LED-Switch Circuit on breadboard.

Now if you see, you can understand that this circuit is nothing but modification of the previous LED breadboard tutorial, here we have added one switch to the LED circuit. Care must be taken when you connect the switch. Out of four legs you will get two shorted legs, as described in the image, you refer the cut mark on the bottom of the switch to understand which sides of the switch are shorted. Make sure that the mark on the switch and the breadboard columns should match otherwise your switch will not functional properly.

When you power the above circuit, the LED won’t glow, its because the circuit is controlled by Switch now, so if you press the Switch now, you will see that the LED will remain On till the moment you press the Switch, otherwise it will remain off. The transistors works in similar fashion, its works as Switch, except that, with switch you need to use your hands to push it and made the LED glow, here with transistors you need to apply logics to turn the LED ON and OFF. Thus applying logic’s will simulate the key press in the transistor.

All the Electronic Components runs on two logic’s only 1(HIGH) and 0(LOW), When you apply Logic High to transistor the transistor will either turn ON or turn OFF depending on the transistor type. Before we see the types, we will clear you what this Logic High and Low Means. Any Electronic Machine understands only two voltages/ Logic’s and they are  Vcc/ Logic 1(High) and Gnd/ Logic 0(LOW)

Now, we will see what are types of transistor:

1. NPN
2. PNP

The NPN is nothing but N-Type transistor, which will activates when you supply a Logic High to it. Similarly, The PNP is nothing but P-Type transistor, which will activates when you supply a Logic Low to it.

Refer the two different types of circuit shown above, you will clearly understand the difference between the two types of transistors working. The P type will turn on the LED when you applied Logic low to the transistor and the N type will turn on the LED, when you apply Logic High to the transistor.

Note: The logic’s will be applied to base/gate Pin of transistors, the other two pins are emitter/drain and Collector/source.Collector/Source pin used to connect the transistor from power source and emitter/drain pin used to connect with loads.The Pin descriptions are mentioned in the datasheet of each transistor, so there is no need to worry about it as of now.

Now we will move one step further and add some sound to the project, till now when we press the switch or apply the logic’s to transistor the LED will lit up. let us add one piezo buzzer to the breadboard and see what happens when we press the switch.

Refer the schematic below to build your own circuit in a breadboard.

In the above shown example we had used Arduino as 5v power source to power the breadboard, you can use any other power source as per you convenience. Now if look at the circuit we had Used N-type(NPN) transistor, now if you google for BC547 Datasheet, you will see lots of options, open any one datasheet .pdf document, once you scan through all the pages you will notice lots of details about transistor is mentioned in it, right now we are focusing on the type, voltage and current of the transistor. If check you will see all these data  withing the first 5 pages. There its mentioned:

BC547

• NPN Epitaxial Silicon Transistor
• Vceo: 45v
• 100mA

we seen that its N-Type(NPN) and its maximum voltage is 45v which is more than enough, since we are running only on 5v. Regarding current, if we calculate the current required for the loads, the LED needs 15mA and the buzzer needs 40mA max, thus combining two, its comes under 60mA, thus we are good to go with same transistor. If your loads exceeds the rated current go for higher current transistor. Refer the image below for the Pin description of the BC547 Transistor we are using.

You can see that we are supplying High Logic from switch to transistor, so when you press the switch the Vcc(5v) will be applied to gate pin of transistor and this will activate the transistor, allowing the current to flow through LED and Buzzer and in return we can see and hear the light and sound respectively.

Note: Don’t forget to add current limiting resistor for buzzer and resistor and polarity of the buzzer must be taken care of similar to that of LED.

So, this is all about the welcome little step you made into hands on with electronics, in the next tutorial, we will show you how to use microcontrollers/Arduino to control these kind of circuits.

Breadboard is nothing but a plastic base with lots of holes in it, where you can fit in your components and wires to build your circuit. You can’t see what’s going inside the breadboard, but inside its nothing but many strips of metal that connect the rows and columns together. These metal strips are springy so that when you poke a wire or component into the hole, the clips grab onto it.

Breadboards are used for both the simplest circuit as well as very complex circuits. In case one breadboard can’t accommodate your circuit, you can snap in multiple breadboards together to make a big breadboard base. You can use breadboard to test and figure out the working of Integrated circuits (ICs).

If you refer the description in the image above you can see that the how tracks are connected inside the breadboard. Refer the Vcc and Gnd Lines in the image above, you can see these two lines are running round the borders, thus allowing us to use these lines for power supply distribution, but there is a discontinuity in Vcc and Gnd tracks as shown above(mentioned “Not Connected”), which you need to connect with jumpers to distribute the power. The center holes are column connected as shown in the picture and there is a gap in between the same columns, allowing us to fit in IC to the gap. To make things further clear, we have added the tear down image of the breadboard, refer the next diagram to get better idea of inside connections.

The image shown above is of Half sized breadboard, thus don’t be confused comparing it with previous images. Hope things are clear to this point and you understood the breadboard well, now we will move further and see how to start building basic circuits on this breadboard. We are going to start with LED circuit, which is common to all the devices, we are going to build a circuit for Power LED Indication, i.e whenever there is power in the circuit, this led will let us know about it.

If you notice the above image you will see the legs of LED mentioned with Anode and cathode and to understand how to distinguish between anode and cathode pins, we provided hints in the image, its nothing but one cut mark(Means the LED is not completely round from the bottom side) which indicates that the leg underneath it is cathode(-ve) pin and if we seen the size of the legs, the anode(+ve) pin is little longer. But most of the times you have to trim the legs of LED when you use these LED in any circuit thus making the anode pins and cathode pins indistinguishable in terms of Leg size.

The importance of anode and cathode pins in LED is that, LED will glow only is you provide +ve power supply to Anode pin and –ve power supply to Cathode Pin. But wait, you cannot straight away supply the LED with power supply because there are chances that more current will pass through LED and this will lead to damage the LED, to avoid this situation, it is strongly recommended to use the resistor along with LED.

The circuit will be something like shown above. But it is really important to use the correct resistor value in the circuit to limit the current. We will show you how to select the correct resistor value for each circuit. For this, you need to understand two necessary parameters of LED, i.e LED Current and LED Forward voltage, refer the section below, for detailed description:

LED Current:

As an example we will refer the datasheet for Basic Red 5mm LED.Starting at the top and making our way down, the first thing we encounter is this Absolute maximum ratings table:

Confused?  Questions coming that what does it all mean? right ?

So, the first row in the table indicates how much current your LED will be able to handle continuously. In this case, you can give it 20mA or less, and it will shine its brightest at 20mA. The second row tells us what the maximum peak current should be for short bursts. This LED can handle short bumps to 30mA, but you don’t want to sustain that current for too long. This datasheet is even helpful enough to suggest a stable current range (in the third row from the top) of 16-18mA. That’s a good target number to help you make the resistor calculations we talked about.

The following few rows are of less importance for the purposes of this tutorial. The reverse voltage is a diode property that you shouldn’t have to worry about in most cases. The power dissipation is the amount of power in milliWatts that the LED can use before taking damage. This should work itself out as long as you keep the LED within its suggested voltage and current ratings.

LED Forward Voltage

Now, when you check the datasheet further, you will come across the next table shown as follows:

Now,this is a useful little table! The first row tells us what the forward voltage drop across the LED will be. Forward voltage is a term that will come up a lot when working with LEDs. This number will help you decide how much voltage your circuit will need to supply to the LED.You need to follow the following formula every time you build circuits something with LED, refer the section below:

The basic ohm’s law states that:

V = I x R    or   R = V/I

where,

V = Supply Voltage

I = Current through LED

R = Circuit Resistor

Thus, applying this law for LED circuit, we will get following formula:

Where,

V_S = Source voltage (usually a battery or power supply voltage)

V_F = LED’s forward voltage

I_F = Desired current that runs through it.

For example, assume in this example you have a 9V battery to power an LED. If your LED is red, it might have a forward voltage around 1.8V. If you want to limit the current to 10mA (or 0.010A) rather than limiting it to 20mA , use a series resistor of about 720Ω.

Now, if we are going to build power supply Indicator circuit for 5v system, thus our resistor calculation will come somewhat like this:

R = (5-1.8)V ÷ 0.010A

R = 3.2V ÷ 0.010 A

R =  320 V/A

R = 320 Ω

R = 330Ω Approx (Nearest standard resistor value)

Thus if you notice in the circuit shown above, you will see that we had used 330Ω resistor in the circuit, but wait you may be confused with how the resistor shown above is 330Ω, its again you need to follow the ring colors on the resistor surface. Refer the image below for better idea:

If you notice in the image, it is well documented how the 330Ω value is calculated. Refer the formula shown on the image, which will help you to find out the resistance value of the resistor, you just need to substitute the A,B,C and D value in the formula based on the colored ring.

In our case the resistor colors are orange, orange, brown, gold in sequence, thus if we substitute the corresponding values of the colors in the formula, yow will get: 33 x 10, which is nothing but 330 with 5% tolerance, tolerance will let you know how good the resistor is?

In this case its 5% means: The resistance value is limited within the vast range [270 – (5% of 270)]  and  [270 + (5% of 270)], which is not good, the lesser the range, the more close the resistance to the desired resistance value.

Let start assembling the circuit in the breadboard, refer the image below for better idea:

Now, you can see how we utilized the breadboard columns which are internally shorted to connect the LED anode pin with resistor, similarly we used the jumper wires to connect the LED cathode pin and resistor other end. Now if you power the above shown circuit, i.e Red wire with 5v and Black with Ground supply, you will see that your LED will glow safely.

Note: We had Connected 5v supply and GND from Arduino board in the following image, you can use Raspberry Pi or any other boards you having with you to supply 5v and GND from the board. If you having our Raspberry Pi Electronics Starter kit with you, then you can use the RasPiO Portplus we provided with the kit, to find the 5v and GND pins on Raspberry Pi and use the Male-Female Jumper wire we provided in the Kit to Supply power to the LED on breadboard.

Now, we want you to build one circuit on your own with multiple LED’s in series, but before doing that, we want to clear some basics related to building such circuits. When you went through LED forward voltage section above, you seen the table with LED forward voltage, you must use that value to find out how much LED you can use in your circuit. When using multiple LED’s in series, always remember that the Forward Voltage of all of your LEDs added together can’t exceed your system voltage. This is because every component in your circuit has to share the voltage, and the amount of voltage that every part uses together will always equal the amount that’s available. This is called Kirchhoff’s Voltage Law. So if you have a 9V power supply and each of your LEDs have a forward voltage drop of 2.4V then you can’t power more than three at a time.

Kirchhoff’s Laws also come in handy when you want to approximate the voltage across a given part based on the Forward Voltage of other parts. For instance, in the example we just mentioned there’s a 9V supply and 3 LEDs with a 2.4V Forward Voltage Drop each. Of course we would want to include a current limiting resistor, right? How would you find out the voltage across that resistor? It’s easy:

9 (System Voltage) = 2.4 (LED 1) + 2.4 (LED 2) + 2.4 (LED 3) + Resistor

9 = 7.2 + Resistor

Resistor = 9 – 7.2

Resistor = 1.8

So there is 1.8V across the resistor! This is a simplified example and it isn’t always this easy, but hopefully this gives you an idea of why Forward Voltage Drop is important. Using the voltage number you derive from Kirchhoff’s Laws you can also do things like determine the current across a component using Ohm’s Law. In short, you want your system voltage equal to the expected forward voltage of your combined circuit components.

Hope the things are more clear to you now and this is the end of your first basic steps towards hands on with electronics. Refer the next tutorial for more advanced Projects.

There are cases where we cannot totally rely on WiFi network for internet connectivity with device, thus we will prefer to use wired connection in such cases, network critical applications must be provided with wireless and wired connectivity options in order to achieve greater result and to get more flexibility and reliability and this can be accomplished by integrating the Ethernet protocol, which is the basic of the communication protocol used in the internet into the embedded system. There are lots of options available in the market to get the Ethernet connectivity and one of the option to get Ethernet connectivity to your own micro controllers is by adding WIZ811MJ Ethernet module to your microcontrollers.

• Introduction to WIZ811MJ Ethernet module

• Connection reference

• Sample Code

Introduction to WIZ811MJ Ethernet module

The module we are going to use in this hookup is WIZnet W5100 Network Module with Mag Jack – WIZ811MJ. The WIZ811MJ is an ideal option for users who want a simple solution to adding TCP/IP and rapidly enabling Internet capability to their project. The WIZ811MJ network module comes with the Wiznet W5100 chip, MAG-JACK (RJ45) together with the glued logic needed to communicate with the microcontroller through the SPI or bus interface.

WIZ811MJ consists of W5100 and MAG-JACK.

• TCP/IP, MAC protocol layer: W5100
• Physical layer: Included in W5100
• Connector: MAG-JACK(RJ45 with Transformer)

We are using the version 1.1 of the WIZ811MJ module, its comes with following features:

• Supports 10/100 Base TX
• Supports half/full duplex operation
• Supports auto-negotiation and auto cross-over detection
• IEEE 802.3/802.3u Compliance
• Operates 3.3V with 5V I/O signal tolerance
• Supports network status indicator LEDs
• Includes Hardware Internet protocols: TCP, IP Ver.4, UDP, ICMP, ARP, PPPoE, IGMP
• Includes Hardware Ethernet protocols: DLC, MAC
• Supports 4 independent connections simultaneously
• Supports MCU bus Interface and SPI Interface
• Supports Direct/Indirect mode bus access
• Supports Socket API for easy application programming
• Interfaces with two 2.54mm pitch 2 x 10 header pin
• Temperature : 0 ~ 70℃ (Operation), -40 ~ 85℃ (Storage)

     Image Credit: Sparkfun

Image Credit: Sparkfun

The Wiznet 5100 based chip has the TCP/IP hardwired on it; therefore it will help developing the TCP/IP protocol stack based application much easier and could be implemented on the small RAM size microcontroller class compared to the firmware TCP/IP protocols stack based implementation approach.

Image Source: Wiznet WIZ811MJ Datasheet

We are going to use this module together with arduino to get started with it. The Arduino UNO does not have any options onboard to connect with internet, adding this module to Arduino UNO will give the Ethernet connectivity to the UNO board, thus it will provide a great option to create internet dependent applications using Arduino UNO board. You are free to use Arduino ethernet shield also (Since the ethernet sheild comes with same W5100 Chip onboard).

The Arduino can produce web pages from within the Arduino sketch or host web pages that are stored on the SD card (there is a micro SD card socket on the Arduino Ethernet shield). These web pages can be configured to control and monitor hardware from a web browser on any Ethernet network that the Arduino is connected to. The WIZ811MJ module uses SPI Protocol to communicate with other devices, thus we are going to connect the Ethernet module to the arduino using SPI lines. Use the table below to check your SPI lines (Incase you are using any other Arduino Boards)

Note that MISO, MOSI, and SCK are available in a consistent physical location on the ICSP header; this is useful, for example, in designing a shield that works on every board.

Connections

The connections between the Ethernet module and Arduino is really simple, you just need six lines to be connected to get it going. Refer the Images below to connect your circuit.

Image Credit: Sparkfun

Circuit generated Using Fritzing Software

Connect the Jumper wires as mentioned above, once done power up your arduino and connect the Ethernet cable from the router to the WIZ811MJ Module. Refer the next section to see the code used for this module.

Sample Code

We have reached the last step of this hookup guide, only thing left in this hookup guide is to upload the code to the arduino and see the output. In order to get it running we are going to use the Arduino Ethernet Library which comes by default when you install the software.

Open the example code from this mentioned path:

Arduino Examples  ->  Ethernet  ->   WebServer

or copy paste the follwing into your arduino and upload the code

/*
Web Server

A simple web server that shows the value of the analog input pins.
using an Arduino Wiznet Ethernet shield.

Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13
* Analog inputs attached to pins A0 through A5 (optional)

created 18 Dec 2009
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe

*/

#include <SPI.h>
#include <Ethernet.h>

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
};
IPAddress ip(192, 168, 1, 177);

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print(“server is at “);
Serial.println(Ethernet.localIP());
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) {
Serial.println(“new client”);
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// if you’ve gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == ‘\n’ && currentLineIsBlank) {
// send a standard http response header
client.println(“HTTP/1.1 200 OK”);
client.println(“Content-Type: text/html”);
client.println(“Connection: close”); // the connection will be closed after completion of the response
client.println(“Refresh: 5”); // refresh the page automatically every 5 sec
client.println();
client.println(“<!DOCTYPE HTML>”);
client.println(“<html>”);
// output the value of each analog input pin
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print(“analog input “);
client.print(analogChannel);
client.print(” is “);
client.print(sensorReading);
client.println(“<br />”);
}
client.println(“</html>”);
break;
}
if (c == ‘\n’) {
// you’re starting a new line
currentLineIsBlank = true;
}
else if (c != ‘\r’) {
// you’ve gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
Serial.println(“client disconnected”);
}
}

Once done with uploading the code, you must open the serial terminal. Now open web browser in your Computer and copy paste this IP address 192.168.1.177 to your address bar and hit enter. If some page loads up showing up values from the arduino it means your connection is established successfully. In order to  see the sensor readings on the web page, connect some sensors or potentiometer to Analog pins A0, A1, A2, A3, A4 and A5. You are able to read these values on the web page. Now try with other examples provided with Ethernet library.

 Vehicle Accident Detection System

Before we go into details of this project, I would like to give you some idea about what this project is all about. This is a DIY project suited for anyone who are interested to build a prototype using any old RC cars, but do not limit yourself just to RC cars or toys itself, You are all free to modify it as per your ideas and imagination. Beginners can give it a try for sure but there is some level of skill needed to finish this project. You are going to learn some electronics hardware interfacing in addition to programming during this project.

The objective of this project is to build a vehicle which is capable enough to inform the Emergency Service and the pre-programmed contact number about the accident. Accident detection systems help reduce fatalities stemming from car accidents by decreasing the response time of emergency responders.

Smartphones and their onboard sensors (such as GPS receivers and accelerometers) are promising platforms for constructing such systems. Thus we will try to replicate the functions of smartphones and some sensors to build this project.

I used the following components to build this project:

Components List

• Arduino UNO
• GSM Shield
• Sparkfun GPS Shield
• Sparkfun 6DOF IMU
• Sparkfun RedBot Sensor- Mechanical Bumper
• LCD 16X2
• Antenna
• Potentiometer
• DC Jack Battery Connector
• 9v Battery Snapper

Follow the Steps below to finish it without having any issues.

Collision Detection Using Mechanical Bump Sensor

Detect roll using 6DOF IMU

Display Information using 16 x 2 LCD

Tracking location using GPS

Sending Messages using GSM Module

Complete Setup

Collision Detection Using Mechanical Bump sensor

I used the Sparkfun RedBot Sensor- Mechanical Bumper to start the collision detection.

Connections to this module is very simple. You need to use jumper wires to connect GND and OUT pins (not the 5v pin). Now take out your ARDUINO UNO and connect as mentioned:

Sensor OUT                Arduino A3
Sensor GND               Arduino GND

Run the following code in your Arduino

void setup() {
Serial.begin(57600);
pinMode(A3, INPUT_PULLUP);
}

void loop() {
if(digitalRead(A3)==0){
Serial.println(“detected”);
delay(200);
}
}

Once code is uploaded, you need to open the Serial monitor at 57600 baud rate, you are able to see that whenever you press the bumper from hand, it will show the message detected.

Detect roll using 6DOF IMU

In case of accident the car will either roll or it will create a sudden jerk movement, Our job is to detect this roll and jerk from the car, for this we will use the Sparkfun 6DOF IMU

It’s a Small tiny board with Accelerometer and Gyroscope Together on the same board with six degree of freedom. The board uses I2C communication and requires 3.3v power supply.

Connect the board as shown in the figure below:

You need to run the following code in the Arduino, but before that make sure you added all the necessary library for the same.

Refer this link to download the latest version of library:
http://code.bildr.org/project/6dof/Arduino

or
Visit the Following link to download the Zip File:
http://code.bildr.org/download/985.zip

Once you download the library, make sure you unzip it and copy it to Arduino libraries.
You need to restart the Arduino after this step.

Use the following code to detect the yaw, pitch and roll from the Sensor.

#include <FreeSixIMU.h>
#include <FIMU_ADXL345.h>
#include <FIMU_ITG3200.h>
#include <Wire.h>
#define limit1 165
#define limit2 165
#define limit3 165

float y_p_r[3];
boolean yaw=false, pitch=false, roll=false;

FreeSixIMU sixDOF = FreeSixIMU();

void setup() {
Wire.begin();
delay(5);
sixDOF.init(); //begin the IMU
delay(20);
}

void loop() {
sixDOF.getYawPitchRoll(y_p_r);

if( (abs(y_p_r[0]) > limit1))
yaw = true;
else
yaw = false;

if( (abs(y_p_r[1]) > limit2))
pitch = true;
else
pitch = false;

if( (abs(y_p_r[2]) > limit3))
roll = true;
else
roll = false;

if(yaw==true){
Serial.println(yaw);
yaw=false;
}

if(pitch==true){
Serial.println(pitch);
pitch=false;
}

if(roll==true){

Serial.println(roll);
roll=false;
}

}

Modify the parameter limit1,limit2 and limit3 in the code as per your requirement and make sure you are able to get the output with different orientation and tilt of the board.

Display Information using 16 x 2 LCD

Most of the Vehicle ADS have onboard display to show the various Information, In this project we will use the 16 x 2 LCD to display our information, you can use any display as per your convenience but I opt this one because it’s cheaper and you are able to get it easily from the local shop.

Refer the Diagram below to connect the LCD

To test the LCD, you just need to follow the Arduino Examples Section, there you will find LiquidCrystal, just run any of the examples sketch and check whether you are able to get any output or not. Make Sure you modify the LCD pin connections in the example Code, otherwise you will not see the desired output.

Below I have added the LCD initialization for the connections shown in the image, if you had followed the same pin structure then you just need to copy paste it in the example sketch.

LiquidCrystal lcd(6, 12, 8, 9, 10, 11);

Tracking location using GPS

Location tracking is something we have seen in several devices like mobile phones, metro trains, buses and your own vehicles and most of them uses GPS to find out the position. We will use this GPS Receiver – LS20031 to find out the current location of device.

Sparkfun has provided great tutorial on their website to get started with this device, follow the instructions here:
https://www.sparkfun.com/tutorials/176

Perform the Quick test to see the output from the GPS.

Once you done with Setting up the GPS Receiver, it is really easy to get the desired reading, all thanks to TinyGPS library, which will give you the locations in formatted manner, all you need to do is to access the position from the library function itself.

Visit this link to download the latest version of the TinyGPS library:
https://github.com/mikalhart/TinyGPS/releases/tag/v13

Or

you can download the zip file directly from this link:

https://github.com/mikalhart/TinyGPS/archive/v13.zip

Once you are done setting up the library for the Arduino, restart the Arduino software, refer the diagram below to display the GPS Location in LCD.

Note** Care must be taken while connection GPS, since its runs on 3.3v and you are interfacing it with 5v System, thus any voltage level greater than 3.3v will damage the GPS module, this is why we did not used the Rx pin on the GPS, if you need to use RX pin on 5v system, you must add logic level shifter like: https://www.sparkfun.com/products/12009  between Arduino and GPS.

Use the following code to test the GPS and LCD:

#include <TinyGPS.h>
#include <LiquidCrystal.h>

TinyGPS gps;
LiquidCrystal lcd(6, 12, 8, 9, 10, 11);

static void smartdelay(unsigned long ms);

void setup()
{
Serial.begin(57600);
lcd.begin(16, 2);
}

void loop()
{
float flat, flon;
unsigned long age;

gps.f_get_position(&flat, &flon, &age);

lcd.setCursor(0, 0);
lcd.print(“LAT:”);
delay(5);
lcd.print(flat,3);
delay(5);

lcd.setCursor(0, 1);
lcd.print(“LON:”);
delay(5);
lcd.print(flon,3);

smartdelay(1000);
}

static void smartdelay(unsigned long ms)
{
unsigned long start = millis();
do
{
while (Serial.available())
gps.encode(Serial.read());
} while (millis() – start < ms);
}

Advanced users can modify the code and connections to use any of the Arduino GPIO pin to be used as RX Pin using Software Serial Library, this is useful because while GPS Connected to RX Pin of Arduino you are not able to upload the code to the Arduino, it will give error while uploading, in case you face this issue, make sure to remove the jumper from Arduino RX pin.

Sending Messages using GSM Module

Now the most important function of this system is to deliver the alert messages to others in case of an accident, for this we will use the Arduino GSM Shield, GSM Shield has built in SIM slot, all you need to do is to insert a working SIM having some balance to send the messages.

For more advanced details refer this Link: https://www.arduino.cc/en/Guide/ArduinoGSMShield

We will try to integrate GPS and GSM together in this section, please refer the diagram below for required connections.

Now all you need to do is use the following code to see the working of the device.

#include <GSM.h>
#include <TinyGPS.h>

#define PINNUMBER “” // If your SIM has PIN, pass it as a parameter of begin() in quotes

TinyGPS gps;

boolean MessageSent = false;

// initialize the library instance
GSM gsmAccess;
GSM_SMS sms;

float flat, flon;
String txtMsg =”Owner:Abhishek\nLicense: KLNA2\nAccident Alert!!!!!!!\n”;

static void smartdelay(unsigned long ms);

void setup(){
boolean notConnected = true;
Serial.begin(57600);

while (notConnected)
{
if (gsmAccess.begin(PINNUMBER) == GSM_READY)
notConnected = false;
delay(1000);
}
}

void loop(){
char remoteNum[]=”0562xxxxx0″; // telephone number to send sms

unsigned long age;
gps.f_get_position(&flat, &flon, &age);

Serial.println(txtMsg+”LON: ” + String(flon)+ ” LAT: ” + String(flat));

if(!MessageSent){
sms.beginSMS(remoteNum);
sms.print(txtMsg+”LON: ” + String(flon)+ ” LAT: ” + String(flat));
sms.endSMS();
MessageSent = true;
}
}
static void smartdelay(unsigned long ms)
{
unsigned long start = millis();
do
{
while (Serial.available())
gps.encode(Serial.read());
} while (millis() – start < ms);
}

The above code will continuously print the GPS location in the Serial Terminal also it will send the formatted message to designated number once.

Complete Setup

This step is the most important part, here we will put things together, following all the steps one by one make sure that all the things in the project are working upto the mark, I am expecting you are able to get the desired output till step4.

We will first start with hardware Integration part, I had made things easier for you. Just refer the diagram I attached below as reference.

In the above image I had used SPST Switch in place of mechanical bump sensor since I was unable to found the part in the fritzing software, so no need to be confused with that part. Most of the sections we already tested individually. Just make sure you follow the connections exact same way, crosscheck twice or thrice before we move to software part.

I had used the Fritzing software to make my work easier, it’s really helpful tool to make connections faster in breadboard and get the schematics ready.

I had used the following program to get the final prototype ready and in working condition.

#include <FreeSixIMU.h>
#include <FIMU_ADXL345.h>
#include <FIMU_ITG3200.h>
#include <LiquidCrystal.h>
#include <Wire.h>
#include <TinyGPS.h>
#include <GSM.h>

#define limit3 165 //roll // Increasing the value can decrease the sense range of the IMU, Decreasing the value can sense the minute vibrations, tilt or accelaration, update this incase you need it

#define debounce 100
#define bumper1 A2
#define bumper2 A3

LiquidCrystal lcd(6, 12, 8, 9, 10, 11);

TinyGPS gps;

GSM gsmAccess;
GSM_SMS sms;

char remoteNum[]=”05xxxxxx74″; // telephone number to send sms “Update this part only”

float y_p_r[3];
boolean roll=false;
boolean hit=false;

FreeSixIMU sixDOF = FreeSixIMU();

void setup() {
boolean notConnected = true;

lcd.begin(16, 2);
lcd.setCursor(0,0);
lcd.print(“Please wait”);

while (notConnected)
{
if (gsmAccess.begin() == GSM_READY)
notConnected = false;
delay(1000);
}

lcd.begin(16, 2);
lcd.clear();

Serial.begin(57600);
pinMode(bumper1, INPUT);
pinMode(bumper2, INPUT);
digitalWrite(bumper1, 1);
digitalWrite(bumper2, 1);
Wire.begin();

delay(5);
sixDOF.init(); //begin the IMU
delay(1000);

lcd.clear();
lcd.print(“Setup complete “);
delay(2000);
lcd.clear();

}

void loop() {
float flat, flon;
unsigned long age;

for(int i=0; i<5; i++){
while (Serial.available())
{gps.encode(Serial.read());}
delay(100);
}

gps.f_get_position(&flat, &flon, &age);

if((digitalRead(bumper1)==0) || (digitalRead(bumper2)==0))
{
delay(debounce);
hit=true;
}

sixDOF.getYawPitchRoll(y_p_r);

if( (abs(y_p_r[0]) > limit3) ||(abs(y_p_r[1]) > limit3) ||(abs(y_p_r[2]) > limit3))
roll = true;
else
roll = false;

if(hit==true || roll ==true)
{
if((flon == 1000.000) && (flat==1000.000)){
flon=54.39;
flat=24.45;
}

lcd.setCursor(0,0);
lcd.print(“Abhi N3AB4″);
delay(2000);
lcd.clear();

String txtMsg =”Owner:Abhi \nLicense: N3BA4\nAccident Alert!!!!!!!\n”;

sms.beginSMS(remoteNum);
sms.print(txtMsg+”LON: ” + String(flon)+ ” LAT: ” + String(flat));
sms.endSMS();

hit=false;
}
}

While compiling this code you might get the message that Sketch too big, it really took some time for me to get this thing sorted out. I did modified the library files to make its size within the limit, the next part you can do is to remove or modify the string in the code and it will save you more space. I will share you the library which I modified so as to get it in working condition.

Sometimes GPS might not work inside the house and it will give you location as 1000,1000
so don’t worry with this, it’s not code issue, it’s the GPS, when you take it out under open sky, you will see the coordinates are updated and the red led on the module started blinking. Hope you enjoyed this project, expecting your valuable feedback. Will join you soon with more interesting project.