How to use a Breadboard for Beginners? Wiring, Circuit, Arduino

A breadboard is a solderless construction base used for developing an electronic circuit and wiring for projects with microcontroller boards like Arduino. As common as it seems, it may be daunting when first getting started with using one.

Hence, with today’s breadboard tutorial, I’ll be guiding you on how to use a breadboard, alongside establishing a connection with Arduino.

Seeed also offer one free breadboard for each customer, apply the code BREADBOARD to get one free breadboard(valued $4.90) at Seeed!
Seeed also offers one free breadboard for each customer, apply the code BREADBOARD to get one free breadboard(valued $4.90) at Seeed!

Introduction to Breadboard

Before we get started with today’s tutorial, let’s learn more about breadboard, its history, and the types available.

History of Breadboard

The term “Breadboard” comes from a literal piece of wood used to cut bread, which back in the early days, people would build electronic circuits on it. A typical circuit is as seen in the picture above.

However, with the years of evolution comes design changes. Now, thanks to the invention by Ronald J. Portugal, the breadboard we know comes in a smaller, more portable white plastic and pluggable design.

What are the types of breadboards?

Types of Breadboard available at Seeed

We’ve seen the type of breadboard originating in the past, but for the modern-day solderless breadboard, it comes in different types; full-sized, Full+, half-sized, Half+, and mini.

  • With the size difference, there may be variances in how the different rows and columns of wire strips are connected though the general principle should remain the same
  • Although the main difference comes in size, there are different shapes and color options available as well.

How is a Breadboard constructed?

When you first lay your hands on a breadboard, you’ll find that there are many pinholes and start to wonder how do I start connecting things? However, before you get started, you’ll need to understand the components of a breadboard to avoid misusage.

Hence, I’ve broken down the breadboard components and features for easier understanding!

1. Bus and Terminal Strips

A breadboard consists of two areas called strips, and are often separated from the middle portion (commonly known as ravine).

  • Bus strips are mainly used for power supply connections
  • Terminal strips are mainly used for electrical components
    • Each strip consist of 5 pinholes, indicating that you only can connect up to 5 components in one particular section

Note: Although each row has 10 pinholes, you can only connect 5 components as the ravine isolates both sides of a given row. This isolation restricts electrical connection between both sides.

How to wire a breadboard

Note how the holes colored in orange are connected together. These sets of connecting holes can be called a node, where it’s possible to interconnect the node from bus strips to terminal strips with jumper wires!

2. Metal clips

Next, are metal clips; metal clips are what that goes underneath the bus and terminal strips and can be seen when a breadboard is either taken apart or has a transparent outer layer. The function of these metal clips is to grab onto an electronic component when it’s plugged into the pinhole. They are spaced 2.54mm apart as well.

*Which electronic component can you use?

  • So long as an electronic component has leads or pins, it can be used with a breadboard
    • Leads: Long metal legs protruding out the component
    • Pins: Shorter metal legs

3. How to read breadboard Row and Columns?

Now that we’ve talked about the breadboard pin functions and what goes underneath it. Its time to explain the labeling on it.

You may have spotted the numbering, letters, and signage written on a breadboard. These are written to help you locate the individual hole in the breadboard, similarly to how finding a cell in an Excel spreadsheet works.

  • The example as seen above: Hole C12 = Column C, Row 12

What do the “+” and “-” signs mean? Breadboard Power Rails

Numbering and letters aside, the positive and negative signs on both sides of the breadboard are power rails, used to power your circuit by connecting battery pack or external power supply.

There’s no physical difference between positive and negative buses, where labeling is merely for reference and better organization of circuits.

Power rail connection

However, as power rails on either side are not connected, you’ll need to connect both sides with jumper wires to establish the same power source on both sides.

  • Ensure that you connect the positive end on one side to the positive end on the other, negative side on one side to the other

4. Other features of a breadboard

The above components of a breadboard are ones commonly seen, however, there’re other features found in unique breadboards like such:

The above Grove – Breadboard has a unique feature not seen in regular breadboards and that’s an integrated printed circuit board (PCB)!

With our onboard Grove connector, you’ll be able to build your very own Grove – module.

Its Features include:

  • On-board Grove port to enable plug-and-play connectivity
  • On-board Dupont connector for easy prototyping
  • On-board resettable fuse (PTC) for protection: 500mA max current
  • On-board Power LED to show the working status
  • Standard Grove size: 40*60mm

If you’re interested to find out more on this breadboard, you can head to our product page!

How to power a breadboard?

When it comes to powering a breadboard, there are plenty of ways in doing so. I’ll be recommending the most common ones seen below:

1. Powering a breadboard through Arduino

If you’re an avid Arduino user, this method would be the simplest for you! Since the Arduino already gets its power from a computer or external power supply, you can simply power a breadboard from “borrowing” its power supply.

Here’s how to power your breadboard through Arduino:

  • Connect Arduino GND pin with female headers to the breadboard power rails
    • Red wire from the header to the breadboard (+) power rail
    • Black wire from the Arduino GND to the breadboard (-) power rail

2. How to connect a battery to a breadboard

Breadboard diagram

The second way you can power a breadboard is of course, through a battery! With reference to the above breadboard diagram, you can simply connect a battery to a breadboard by:

  • Connect the battery pack red wire to (+) bus
  • Connect the battery pack black wire to (-) bus

3. Powering a breadboard through a dedicated power supply

Similarly to other electronic components, you can power the breadboard directly through our power supply adapter. This 5V&3.3V breadboard power supply includes a micro-USB port and power jack port, allowing the taking of direct power from a DC wall wart and outputting it in 5V and 3.3V regulated voltage!

Note: There are indeed other power supply methods such as binding posts and benchtop. However, these methods are only applicable in certain breadboards and are less commonly used compared to the above 3 ways.

Quick breadboard powering tip!

A general breadboard can handle a power of 5V at 1A but it’s recommended to keep it below 0.5A/500mA for safety purposes

  • Power limits may vary depending on the type of breadboard and its manufacturer. Do check the datasheet/specifications of the breadboard before purchasing one!

How to build a simple breadboard circuit?

Earlier we understood the principle of breadboard but now comes to the part where you start building your first breadboard circuit! I’ve provided a tutorial for both beginners and Arduino users to try!

Establishing a breadboard circuit connection

Before we move on to an actual breadboard circuit tutorial with LED, here are 3 crucial steps you need to first know in establishing a breadboard circuit connection with resistors and power supply

  • Step 1: Connect one of the power supply terminals to a hole of any section on the breadboard
  • Step 2: Connect one terminal of a resistor to the hole of that section such that both devices are connected to each other
  • Step 3: Take another resistor and connect it to the hole of another section. Connect the second power supply terminal to that same hole

Breadboard circuit tutorial

Now that you’ve understood how to establish a simple breadboard circuit connection, here’s a tutorial to help you get started with building a breadboard circuit with LEDs!

The easiest way to get started with building a breadboard circuit is by following a breadboard diagram. Here’s what you need:

  • Step 1: Connect the battery pack red lead wire to the (+) bus
  • Step 2: Connect the battery pack black lead wire to the (-) bus
  • Step 3: Connect the resistor from hole B12 to the (-) bus
  • Step 4: Insert the four pins on a pushbutton into holes E10, F10, E12, and F12
  • Step 5: Insert the LED long lead into the (+) bus and the short lead to J10 hole

An Electrical circuit should now be formed, with the LED lighting up.

Note: You can completely rearrange the layout of the circuit but following the breadboard diagram exactly is the easiest way to get started with building a breadboard circuit.

Bonus! Want to build a breadboard circuit without buying a physical product?

If you wish to learn and build your own circuits without buying an actual breadboard, you can use Fritzing, a free software program allowing you to build a breadboard circuit without physically getting one!


How to build a breadboard circuit with Arduino?

Arduino Breadboard Tutorial with LED and Water Level Sensor

For this Arduino breadboard tutorial, we’ll be sensing water level using the Seeeduino Xiao, the smallest Arduino board in the Seeeduino Family that’s packed with SAMD21G18 and applicable for breadboard usage!

Hardware components needed:

Hardware assembly and configurations:

  • Step 1: Insert Seeeduino XIAO into the breadboard, and reserve the wiring positions on both side. The row of each pin on the left and right is connected
  • Step 2: Connect the 4-pin Male Jumper to Grove 4-pin Conversion Cable with Grove – Water Lever Sensor
    • Base on the pinout above, connect the jumper side as follow:
RED5v
BLACKGND
WHITEA0
YELLOWA1

The Grove side of the cable is then connected to the Grove – Water Level Sensor

  • Step 3: Use the 4-pin male jumper to Grove 4-pin conversion cable and connect to OLED Display 0.96″. Since the Seeeduino Xiao is an I2C interface, SDA and SCL are used
    • Connect the jumper side as follow:
RED5V
BLACKGND
WHITESDA
YELLOWSCL

The Grove side of the cable is then connected to the OLED Display 0.96″

  • Step 4: Use the 4-pin Male Jumper to Grove 4-Pin conversion cable to connect LED using D2 interface but as there’s only one interface left in each row of 5V and GND, we’ll have to lead the line out so that subsequent components can be used
    • Use the Red and black wires to lead it to the position shown in the figure, with:
      • The yellow line in the fourth row are all connected to 5V
      • The jacks covered by the yellow line in the sixth row are all connected to GND

Now the lines are connected by:

RED Newly connected 5V
BLACKNewly connected GND
YELLOWD2
WHITENot Connected

The Grove side of the cable is then connected to the LED pack

  • Step 5: Use the 4-Pin Male Jumper to 4-Pin Conversion Cable to connect the Buzzer, using the A3 port

The end of the jumper wire is connected as below:

RED Newly connected 5V
BLACKNewly connected GND
YELLOWA3
WHITENot Connected

The Grove side of the cable is then connected to the Buzzer

  • Step 6: Connect the Seeeduino Xiao to your PC via a Type-C cable

Software configurations and Arduino Code:

  • Step 1: Open up Arduino IDE, copy the following code and upload the code
    • If you’re unsure on how to upload the code, refer to our guide here
#include <Wire.h>
#include <Arduino.h>
#include <U8x8lib.h>

U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(/* clock=*/ A0, /* data=*/ A1, /* reset=*/ U8X8_PIN_NONE);         // Digispark ATTiny85

#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define SERIAL SerialUSB
#else
#define SERIAL Serial
#endif

const int ledPin = 2; 
const int buzzerPin = 3; 
int value = 0;



unsigned char low_data[8] = {0};
unsigned char high_data[12] = {0};




#define NO_TOUCH       0xFE
#define THRESHOLD      100

#define ATTINY1_HIGH_ADDR   0x78
#define ATTINY2_LOW_ADDR   0x77



void getHigh12SectionValue(void)
{
  memset(high_data, 0, sizeof(high_data));
  Wire.requestFrom(ATTINY1_HIGH_ADDR, 12);
  while (12 != Wire.available());

  for (int i = 0; i < 12; i++) {
    high_data[i] = Wire.read();
  }

  delay(10);
}


void getLow8SectionValue(void)
{
  memset(low_data, 0, sizeof(low_data));
  Wire.requestFrom(ATTINY2_LOW_ADDR, 8);
  while (8 != Wire.available());

  for (int i = 0; i < 8 ; i++) {
    low_data[i] = Wire.read(); // receive a byte as character
  }


  delay(10);
}



void check()
{


  int sensorvalue_min = 250;
  int sensorvalue_max = 255;
  int low_count = 0;
  int high_count = 0;
  while (1)
  {
    uint32_t touch_val = 0;
    uint8_t trig_section = 0;
    low_count = 0;
    high_count = 0;
    getLow8SectionValue();
    getHigh12SectionValue();

    Serial.println("low 8 sections value = ");
    for (int i = 0; i < 8; i++)
    {
      Serial.print(low_data[i]);
      Serial.print(".");
      if (low_data[i] >= sensorvalue_min && low_data[i] <= sensorvalue_max)
      {
        low_count++;
      }
      if (low_count == 8)
      {
        Serial.print("      ");
        Serial.print("PASS");
      }
    }
    Serial.println("  ");
    Serial.println("  ");
    Serial.println("high 12 sections value = ");
    for (int i = 0; i < 12; i++)
    {
      Serial.print(high_data[i]);
      Serial.print(".");

      if (high_data[i] >= sensorvalue_min && high_data[i] <= sensorvalue_max)
      {
        high_count++;
      }
      if (high_count == 12)
      {
        Serial.print("      ");
        Serial.print("PASS");
      }
    }
    Serial.println("  ");
    Serial.println("  ");




    for (int i = 0 ; i < 8; i++) {
      if (low_data[i] > THRESHOLD) {
        touch_val |= 1 << i;

      }
    }
    for (int i = 0 ; i < 12; i++) {
      if (high_data[i] > THRESHOLD) {
        touch_val |= (uint32_t)1 << (8 + i);
      }
    }

    while (touch_val & 0x01)
    {
      trig_section++;
      touch_val >>= 1;
    }
    value = trig_section * 5;
    SERIAL.print("water level = ");
    SERIAL.print(value);
    SERIAL.println("% ");
    SERIAL.println(" ");
    SERIAL.println("*********************************************************");
      u8x8.setFont(u8x8_font_7x14B_1x2_r);
      u8x8.setCursor(0,1);
      u8x8.print("water level:");
      u8x8.setCursor(3,20);
      u8x8.print(value);
      u8x8.print("%        ");
      delay(50);

    if(trig_section * 5 == 100)
    { u8x8.setCursor(3,20);
      u8x8.print("overflow!");
      delay(100);
      digitalWrite(ledPin, HIGH);
      analogWrite(buzzerPin, 256);
      delay(50);
      digitalWrite(ledPin, LOW);    
      analogWrite(buzzerPin, LOW);
      delay(50);}
    else 
    {digitalWrite(ledPin, LOW);
    analogWrite(buzzerPin, LOW);}
  }
}



void setup() {
  pinMode(ledPin, OUTPUT);
  SERIAL.begin(115200);
  Wire.begin();
    u8x8.begin();
    u8x8.setPowerSave(0);
}

void loop()
{
  check();
}

We’ve now completed this tutorial!

  • After uploading, you’ll see that the OLED display lights up and display the current water level, which should be 0%.
  • Try putting the water lever sensor into the water and slowly raise the water level. Once the water level reaches 100%, the LED starts to flash, with the buzzer emitting a sound, and the OLED displaying overflew!

Breadboard Arduino Tutorial 2

Is the above project too difficult and you just want to turn on an LED light with your Arduino? Not to worry, I’ve provided another Arduino breadboard tutorial here!

  • For this tutorial, we’ll be using the Seeeduino, Seeed’s very own Arduino board built with relative benefits!

Hardware connections:

  • Using the Seeeduino as power supply, connect the 5V interface and the GND interface to the breadboard
  • Connect the LED light and the resistor in turn as shown below:

You should then see the LED light up as shown:


Breadboard Arduino Project

If you would wish to follow a community project, we’ve provided one that builds a breadboard circuit to turn an LED light working as a sensor!

LED as Light Sensor

What you’ll need:

  • We’ll be using the 221-ohm resistor from the above resistor pack

Hardware configurations:

  • Step 1: Place the LED sensor in the breadboard
  • Step 2: Connect its one pin to A0 (analog pin) of Arduino, and connect its pin to GND pin of Arduino.
  • Step 3: Place another LED on a breadboard and connect a 220-ohm resistor to its Anode.
  • Step 4: Connect a wire from the resistor to pin 13 on Arduino (digital pin). Connect the Cathode of LED to GND of Arduino.

Software configurations:

  • Step 1: Install Arduino IDE if you’ve yet to
  • Step 2: Copy the code below and upload it into Arduino
/* To read values from led as a sensor. Upload the code in arduino. 
 * Connect the LED to pin A0 (analog pin) of arduino.
 * Connect second pin to GND.
 * Open serial monitor to see the values.
 *Code by Harsh Dethe.
*/

int sensor = A0;  // define analog pin A0. (input/sensor)

void setup()
{
  Serial.begin(9600); //sets serial communication between arduino and computer
  pinMode(sensor,INPUT); // sets analog pin A0 as input.
}

void loop()
{
  int value = analogRead(sensor); // sets variable "value" to store value of sensor.
  Serial.println(value); //prints values in serial monitor
  delay(500); //half a second delay
}
  • Step 3: Head to tools in Arduino IDE, and open serial monitor. Note the values in dark and value after the light is applied. These values are used to trigger the switch.
  • Step 4: If in dark the value is 100-150, and in the light, it is 50-100, the LED on pin 13 can be turned on by editing the if statement as below:
if(value > 100 ) 
{ 
    digitalWrite(led,HIGH);
}

Now the LED will turn on when in Dark and if the greater than “>” is replaced with less than “<” then the LED will turn on in the light.

Still uncertain on how it works and need a video tutorial? Thanks to WolfxPac on Hackster.io, here’s the video tutorial!

Resources and Going Further

Breadboard wires available at Seeed:

More on breadboard projects:

Getting started with breadboard on other microcontroller platforms:

Summary

That’s all for today on breadboards. I hope with today’s blog, you get a deeper understanding of how a breadboard works and how to use it with Arduino!

With breadboard able to house both simple and very complex electrical circuits, it’s not only a common but popular option for prototyping and testing out new parts!

Please follow and like us:
Wordpress Social Share Plugin powered by Ultimatelysocial