Introduction And The Big Picture

Tiny-Ciaroduino is a small-sized Development board based on the beautiful ATtiny85 chip from Atmel. Don’t get fooled by its small size, it’s powerful with great potential and well-documented resources built around it. We wanted to make a small-sized and low-cost development board that fits in any project without hesitation. You don’t need to give up your expensive Arduino or Raspberry pi board anymore to build your project. Blow up your cheap Tiny-Cairoduino board and buy another one, EASY!

There are a lot of open-source Duinos out there, I’m building one more open-source Duino-inspired board but with some addons and features that I was searching for. Tiny-Cairoduino is mainly inspired by the Digispark and the Trinket boards. Thanks to the open-source community. The main goal of the Tiny-Cairoduino board is to integrate the strength points from all the available ATTiny85 based dev boards and come out with a new beast that is easy to program and easy to play with on the hardware level too. And, totally open-source!

Our plan is to develop a whole set of shields that helps hobbyists and newbies to easily implement their hardware projects like if they are assembling lego bricks. We are currently working on that and we will be publishing these shields very soon.

I told you before, Don’t get fooled with its size! Despite being so small The Attiny85 chip has 8K bytes of flash memory and 5 I/O pins. All the 5 GPIO pins can be programmed as digital inputs or digital outputs. Including ADC(analog input) on four pins, PWM(analog outputs) on three pins -more can be achieved with software PWM-. It literally plug and play thanks to the preloaded bootloader that helps you to reprogram the board over USB like any Arduino board. Tiny-Cairoduino is also compatible with Arduino IDE. Even though you can program your Tiny-Cairoduino using the Arduino IDE, it’s not fully 100% Arduino-compatible. There are some things you trade-off for such a small and low-cost microcontroller!

• Tiny-Cairoduino does not have a Serial port connection for debugging so the serial port monitor will not be able to send/receive data. But, you still can reprogram your board through the USB connection.

Tiny-Cairoduino specifications:

1. Support for the Arduino IDE 1.0 and later (OS X, Windows, and Linux).
2. Built-in USB for programming.
3. 5 I/O pins (2 are used for USB only if your program actively communicates over USB, otherwise you can use all 5 even if you are programming via USB).
4. 8 KB flash memory (about 6 KB after bootloader),
5. I2C and SPI (vis USI).
6. PWM on 3 pins (more possible with Software PWM).
7. ADC on 4 pins.
8. On-board power indicator LED.
9. On-board WS2818B addressable RGB led (connected on pin 4).
10. Keyboard or other HID devices emulation (mouse, gamepad …).
11. Handy pinout header to easily connect your Tiny-Cairoduino with the outside world.
12. On-board RESET button.
13. A whole set of shields to maximize and expand the board functionality.
14. Four mounting holes!

Guided Tour

Let me take you a tour through your Tiny-Cairoduino development board, Each board is assembled here at Make Some Stuff with love.

• Mini-B USB: We settled on the Mini-B USB for powering the board and code uploading for many reasons. The Mini-B USB is very rigid and solid on the PCB unlike other connector types like the Micro-B connectors which can rip off the PCB easily. Also, the Mini-B USB is a proper connector type, you can grab any USB cable with any length from any hardware store. Some Attiny85 Dev. boards use a PCB that slides into a USB port to cut costs, but that makes it hard to re-program and annoying to power with an external battery pack.

• Power LED: A cool power indicator LED. It lets you know when your board is powered up by being so lit!

• Reset Push-button: An onboard reset push-button launches the bootloader program when pressed. Making it easy to reprogram the board without unplugging and replugging the board to the computer.

• External reset pin: We bring out the reset pin so you can reset your board without reaching the onboard reset button. It’s handy when your board is inside an enclosure or a box and it’s hard to reach out, you can wire up a button to this pin to reset your board on the road.

• Breadboard-friendly header: You can easily plug the board on a breadboard and have a bigger space to wire things up.

• WS2818B RGB LED: An onboard WS2818B addressable RGB LED connected on pin #4. You can easily control it to make some cool stuff according to your needs.

• AMS1117-5V regulator: An onboard 5V 1A voltage regulator. It allows you to supply voltage from 7V to 12V on the Vin pin without fearing the needed 5V for the microcontroller. It does the work for you. Making the Tiny-Cairoduino proper for DIY projects and very easy to connect to a wall adapter, power bank, battery, or any other kind of power source.

Tiny-Cairoduino Pinout

Power Pins

Let’s start with the power pins. On the top of the board, you will see three different power pins 5V pin, VIN pin, and GND pin.

• 5V pin: It’s a power positive pin connected to the output terminal of the voltage regulator and also connected to the USB 5V terminal. If you are powering your Tiny-Cairoduino board from your computer through the USB cable, you can use this pin to get 5V upto 500mA coming from your computer USB port, with it you can charge a battery, or control some output devices. If you are powering your Tiny-Cairoduino board from an external power source like a battery, power bank, or any other kind of power source through the VIN pin, you can use this pin to get 5V upto 1A coming from the onboard voltage regulator.

• VIN pin: You can use this pin to power up your Tiny-Cairoduino board from a battery, power bank, power adapter, or any other type of power source. Connect the positive terminal(+) of your power source to this pin and the ground terminal(-) to the Tiny-Cairoduino GND pin. Your power source needs to be between 7V and upto 12V.
• GND Pin: It’s the common ground pin of the Tiny-Cairoduino used for logic and power. It is connected to the USB ground and the AMS1117 voltage regulator. This is the pin you’ll want to use for any and all ground connections.

GPIO Pins

All the GPIO pins can be used as digital input or digital output pins, you can use them to read data from a sensor, control an LED, reading switch state, … They are all 5V logic pins. Each pin can provide upto 20mA of current. Don’t connect any component that draws more than 20mA directly to the GPIO pins like motors for example. You can use a transistor, relay, or motor driver instead. 

The first three GPIO pins(#0, #1, #2) are all completely free you can program them without worrying about USB communication interference.

• GPIO #0: It’s connected to the ATtiny85 PB0 pin, it can be used as an output PWM pin, also can be used as MOSI pin(SPI communication), also can be used as I2C data pin(SDA I2C Pin).
• GPIO #1: It’s connected to the ATtiny85 PB1 pin, it can be used as an output PWM pin, also can be used as MISO pin(SPI communication).
• GPIO #3: It’s connected to the ATtiny85 PB1 pin, also can be used as SCK(SPI communication clock pin), also can be used as I2C clock pin(SCL I2C pin), also can be used as an analog input pin which is known as A1.

The remaining two GPIO pins(#3, #4) are connected to the USB port for USB programming. When the board is in the bootloader mode or in the middle of a program uploading these two pins are used to send/receive data to/from the computer. So, it’s highly recommended to not use them while you are reprogramming your board. Also, it’s recommended to disconnect any connections from these pins while uploading your program.

• GPIO #3: It’s connected directly to the ATtiny85 PB3 pin, It’s also used for USB programming, it also can be used as an analog input pin which is known as A3. it also can be used as a PWM output pin.
• GPIO #4: It’s connected directly to the ATtiny85 PB4 pin, It’s also used for USB programming, it also can be used as an analog input pin which is known as A2. it also can be used as a PWM output pin. It’s also connected to the onboard WS2818B LED.

• RST: The reset pin is connected directly to the ATtiny85 reset pin and to the reset push button. It can be used to restart your board in case you want to reset it. Or to enter the bootloader mode to easily reprogram your board without unplugging and replugging the USB cable. You can wire a simple push-button from the reset pin to the ground and press it if you want to enter the bootloader mode in case the board is inside an enclosure or a box and it’s hard to reach.

Installing The Board Drivers

To be able to program your board and make it recognizable by your laptop, you need to install some drivers. MAC and Linux operating systems already have the drivers installed. So, MAC and Linux users don’t need this step. Only Windows users need to install the board drivers. 

We need to download the Digispark bootloader Windows drivers from the link down below. After extracting the .zip file, if you are using a 64-bit Windows OS you will need to use this installer “DPinst64”. And, if you are using a 32-bit Windows OS you will need to use this installer “DPinst”.

After finishing the installation process. Plug in your Cairoduino board to your laptop and open the device manager on your windows. Now you should find your Tiny-Cairoduino board listed under the “libusb-win32 devices” as “Digispark Bootloader”. 

If you did not find it. Click on the “View” tab from the top menu bar and select “Show hidden devices”. Now, you should see “Unknown device” under “Other devices”. 

Press right-click on “Unknown device” and select “Update Driver Software…”

select “Browse my computer for driver software”. Then select the location for the drivers we installed in the previous step. You can use the “Browse” button to select the drivers location.

Once you finish that and see the message “Windows has successfully updated your driver software” now unplug your board and plug it in again. You should now find your Tiny-Cairoduino board listed under the “libusb-win32 devices” as “Digispark Bootloader”.

How To Program Your Board

After installing the DigiSpark drivers, we are now ready to program our Tiny-Cairoduino board. By default, Arduino IDE does not contain the Digispark boards so we need to add these boards manually by ourselves. To do that, from the Arduino IDE top menu bar press on File > Preferences and add the link below in the Additional Boards Manager URLs then click ‘OK.

http://digistump.com/package_digistump_index.json

After that, from the Arduino IDE top menu bar press on tools > Board > Boards Manager and search by “Digistump AVR” then select “Digistump AVR Boards by Digistump” and click on install. 

After installing the board on your Arduino IDE, now you can select the “Digispark (Default 16.5MHz)” board from Tools > Board under the Digispark AVR Boards.

Now, you are ready to upload your first program to the Tiny-Cairoduino board. Copy the code down below, paste it into your Arduino IDE and press the upload button. Once you see the message “Plug in device now … (Will timeout after 60 seconds)” in the messages display place on the bottom of the Arduino IDE program, press on the reset button of the Tiny-Cairoduino board. The code will get uploaded on your Tiny-Cairoduino board and the Arduino IDE will display “Micronucleus done. Thank you!”. 

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson
// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library
#include <Adafruit_NeoPixel.h>

// Which pin on the Arduino is connected to the NeoPixels?
#define PIN            4

// How many NeoPixels are attached to the Arduino?
#define NUMPIXELS      1

// When we setup the NeoPixel library, we tell it how many pixels, and which pin to use to send signals.
// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest
// example for more information on possible values.
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800);

int delayval = 5; // delay for half a second

void setup() {
  pixels.begin(); // This initializes the NeoPixel library.
}

void loop() {
  for (int i = 0 ; i <= 255 ; i++) {
    pixels.setPixelColor(0, pixels.Color(i, 0, 0)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  delay(80);
  for (int i = 255 ; i >= 0 ; i--) {
    pixels.setPixelColor(0, pixels.Color(i, 0, 0)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  for (int i = 0 ; i <= 255 ; i++) {
    pixels.setPixelColor(0, pixels.Color(0, i, 0)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  delay(80);
  for (int i = 255 ; i >= 0 ; i--) {
    pixels.setPixelColor(0, pixels.Color(0, i, 0)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  for (int i = 0 ; i <= 255 ; i++) {
    pixels.setPixelColor(0, pixels.Color(0, 0, i)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  delay(80);
  for (int i = 255 ; i >= 0 ; i--) {
    pixels.setPixelColor(0, pixels.Color(0, 0, i)); // Moderately bright green color.
    pixels.show(); // This sends the updated pixel color to the hardware.
    delay(delayval); // Delay for a period of time (in milliseconds).
  }
  delay(100);
}

After successfully uploading the code on your Tiny-Cairoduino board, The on-board WS2818B LED should now start breathing between red, green, and blue colors. Congrats! You uploaded your first Arduino code to your Tiny-Cairoduino board.

Board Design

Before designing the schematic file, We must settle on the parts and the specific footprints that we will use to build this board. Since we want to make this board as small as possible. We decided to use only SMD parts. All the resistors and capacitors are in 1206 SMD footprint except only one capacitor in 0805 SMD footprint. To regulate the input voltage, we used an AMS1117-5V voltage regulator since it comes in a relatively small form factor but with great power. We used two Schottky diodes, one on the USB port and the other one on the voltage regulator output pin to protect them from any possible reverse current.

To identify our Tiny-Cairoduino board as a USB device to the host, we need to implement the USB communication circuit. Since, the signaling on the D+ and D− lines should be within 0V to 3.3V rails, while the host-supplied voltage is 5V. So we used two 3.3V Zener diodes on the D+ and D- lines to pull those lines two 3.3V. Ali Shtarbanov explained that part in an amazing way is this blog.

We put a 5050 SMD 5V addressable LED(WS2818B) on the board. It’s connected directly to pin #4 on the ATtniy85 chip. We used two 22uf SMD 0805 capacitors on the input and output pins of the voltage regulator to eliminate any ripples(noise) from those lines. We used one green 0805 SMD LED connected directly to the 5V line which acts as a power indicator. We used a generic two-pin SMD push button that connected to the ATtiny85 reset pin.

We love the open-source community! You can download the PCB Eagle source design files from this link

Board Fabrication

Before sending the Gerber files to PCBWay to manufacture the Tiny-Cairoduino board, I machined a test board on my Milling machine to test all the functionalities and to make sure that everything is working fine. After that, I sent the Gerber files to PCBWay who sponsors this build!

To make the PCB traces I used a 0.1mm v-bit. And, a 1.5mm 2 flutes square endmill to cut the PCB outline. 

PCBWay is a PCB manufacturer and PCB assembler based in Shenzhen. They offer a broad spectrum of PCB prototyping, assembly, design, and CNC/3D printing services across five factories that are staffed by more than 520 employees. The coolest feature I use a lot before ordering my PCBs is the instant quote tool. PCBWay’s website is well designed and convenient. You can use the online instant quote tool to get an estimated cost for your board according to the fabrication parameters you select. Which made PCB ordering very easy and fast.

Uploading the bootloader

To be able to program your Tiny-Cairoduino board directly using the USB port, there’s a special program called “Bootloader” that runs on the microcontroller once you supply power to the board. The bootloader program is responsible for making the Tiny-Cairoduino board a USB recognizable device. and taking new programs from you and flashing them on the ATtiny85 chip memory. By default, the ATtiny85 does not come with the bootloader preloaded with any bootloaders. So we need to upload the bootloader to the ATtiny85 microcontroller manually. This is a one-time process. 

We will use the same bootloader runs on the Digispark board “micronucleus tiny85” boot-loader, originally written by Bluebie. You can use any AVR programmer to upload the bootloader to the Tiny-Cairoduino board or use an Arduino UNO board which we will use in this step.

In the first step, we need to configure our Arduino UNO board as an ISP(In-System Programming) to work as an AVR programmer to the Tiny-Cairoduino board. Connect your Arduino UNO to your computer and open Arduino IDE then navigate to File > Example > ArduinoISP and upload the Arduino ISP code.

In the second step, we need to connect the Arduino UNO board to the Tiny-Cairoduino board as the wiring diagram down below. We are using a 10uf polarized capacitor on the reset and GND pin of the Arduino board.

In the third step, Connect your Arduino UNO board to your computer and open Arduino IDE. Find which port is your Arduino board connected to. In my case, my Arduino UNO board is connected to COM6 .We will need that information in the next steps

After this, download the bootloader burning files from the link down below. open the “Burn_AT85_bootloader.bat” and change the COM port number “PCOM5” with whatever COM port number your Uno is connected to. Save the changes before exiting.

Now move the edited “Burn_AT85_bootloader.bat” and “ATtiny85.hex” files into the Arduino IDE root folder (C:\Program Files (x86)\Arduino). After that right-click on the “Burn_AT85_bootloader.bat” and select “Run as administrator” it will take about 5 or 6 seconds to burn the bootloader to the Tiny-Cairoduino board. If all went well, you should receive this message “AVRdude done. Thank you. Press any key to continue…”. 

Now, your ATtiny85 chip is flashed successfully with the bootloader. You can now connect the Tiny-Cairoduino board directly to your laptop and use it like any development board.

The post Tiny-Cairoduino Open-Source DIY Kit appeared first on Make Some Stuff.

Recently, I have been using a lot of AVR chips and I faced few problems regarding burning the code on these chips using commercial AVR programmers. So, I decided why not building my own AVR programmer and get rid of all of this hassle. And, why not customize it according to my needs.

Tiny AVR Programmer Background

Today, we will take a look at how this board is designed, and I will take you on a journey on how each component is working in this design.

If you have just an AVR chip, you need something to program it. the most common way is through ICSP(In-circuit serial programmer). simply, it’s a board that has 6 pins usually a 0.1″ pitch header that can talk to your AVR chip through the SPI protocol. At the other end, it also can talk with your PC through the USB protocol. So, after compiling your C code using avr-gcc, the programmer board will take and send it to your AVR chip directly. You can think of it as a bridge between your PC and your AVR chip.

I did my research for AVR programmers and I found a lot of cool resources. this one specifically caught my eye. It’s the FabOptimus AVR programmer built by Ali Shtarbanov which built on the FabISP programmer built by prof. Neil from MIT Media Lab. the FabOptimus documentation is very good and easy to follow if you are a newbie. I decided to make a very small modification to the FabOptimus AVR programmer since it doesn’t have a power indicator LED, I wanna add one!

PCB Design And Circuit In-depth Analysis

First, we need to understand how this board is designed and how each component in this circuit is behaving.

This AVR programmer is based on the ATtiny44 AVR chip which by default it comes blank, no code or anything is uploaded to it like any microcontroller chip you buy. Since we are building an AVR programmer, we need to upload a very specific firmware to the ATtiny44 chip that tells exactly the role it should follow and execute. Simply, which is sending some hex files to other AVR microcontrollers. This firmware is called FabISP firmware(more on that later.)

So, we need to be able to upload the FabISP firmware to the programmer AVR chip then disable the possibility of reprogramming it.

To be able to upload the FabISP firmware to the programmer AVR chip we need to pull its reset pin to LOW(0 volts). and to disable the possibility of reprogramming it once it has been programmed, we need to pull its reset pin to be always HIGH(5 volts). So, we need to design the circuit in such a way that the reset pin is HIGH(5 volts) by default. But, once another programmer is connected to it, it can pull the programmer AVR chip reset pin to LOW(0 volts). That’s why we are using a 10k ohm pull-up resistor on the reset pin.

As you notice the ATtiny44 chip reset pin is connected to the RST pin on the ISP pin header through a 0 ohm resistor. after uploading the firmware to the ATtiny44 chip we will remove this zero ohm resistor to disable the possibility of reprogramming the board again.

Since we need to use our programmer board to program other AVR boards, our programmer board will need to be able to provide the reset signal to the other AVR boards that we need to program. So, we are also connecting an I/O pin from the ATtiny44 chip to the RST pin of the ISP pin header to provide the reset signal to the other AVR chips that we need to program.

To reduce any high frequency noise or any voltage drops coming from the power supply we are using 1uf decoupling capacitor between the VCC(5 volts) and GND.

We also using a 20MHz resonator as a clock source for the ATTiny44 chip instead of it’s internal clock to achieve more accuracy.

We are using two 3.3v Zener diodes as voltage clippers to regulate the voltage from 5v to 3.3v. According to the V-USB and USB specifications, the voltage on the USB data lines should not exceed 3.3v. Also, we are using a 1.5k ohm pull-up resistor on the D- pin of the USB to make it recognizable as a low-speed device on the host side.

Finally, I made a simple edit to the board. I added a power indicator LED to the board.

It’s a best practice to disconnect the VCC pin on the ISP pin header to make sure that the AVR programmer is not attempting to supply power to the board that we want to program. the board that we want to program should provide its own power. If we didn’t disconnect the VCC pin on the ISP header, the AVR programmer and the board being programmed will draw their current from the USB port(from your computer). if your USB port can’t supply that much current or at any short circuit circumstances, that may cause a huge problem to your computer.

PCB Manufacturing

As you can see, I fabricated this board using a CNC milling machine at Fab Lab Egypt. But, if you are searching for high-quality PCB manufacturing with a solder mask and silkscreen at a very fair price and fast worldwide shipping with no minimum requirements you may order as small as 10 pieces for 5$. you can order yours from PCBWay. You can also support me by just ordering this board from my link.

We love open source. You can download all the board source files from my Github repo.

PCB Soldering And Components Placings

Uploading The Firmware To The Programmer

To upload the FabISP firmware to the FabISP AVR programmer board, we need another programmer to help us upload the firmware to our FabISP board. we will use an Arduino UNO board as an ISP programmer and we will connect it to our FabISP AVR programmer board.

First, we need to upload the “ArduinoISP” sketch to the Arduino UNO board. You can find that sketch from files->Examples->ArduinoISP->ArduinoISP.

After uploading it to the Arduino UNO board. Let’s connect our FabISP AVR programmer(Target) with the Arduino UNO board(Programmer).

D10(Arduino) –> Reset (Target)
D11(Arduino) –> MOSI (Target)
D12(Arduino) –> MISO (Target)
D13(Arduino) –> SCK (Target)
GND(Arduino) –> GND (Target)

As you can notice we are connecting a 10uf capacitor between the Reset and the GND pin of the Arduino UBO board. As you notice, we are not providing power to our target board directly from the Arduino board. We are providing power to the FabISP AVR programmer board(target) by connecting it separately to the laptop through the USB port. And don’t forget to make a common GND between the two boards by connecting the GND of the FabISP AVR programmer board(target) board to the GND of the Arduino UNO(programmer).

After connecting the Arduino UNO board(Programmer) To the FabISP board(Target) we need to compile the FabISP firmware and upload it to the FabISP board. The Arduino UNO board will act as a bridge between my Laptop and the FabISP board. Since I’m using a Mac machine, I will download AVR CrossPack. CrossPack is a development environment for Atmel’s AVR® microcontrollers running on Apple’s Mac OS X, similar to AVR Studio on Windows. It consists of the GNU compiler suite, a C library for the AVR, the AVRDUDE uploader, and several other useful tools.” After heading to the AVR CrossPack website, click the “Download” button and install the .dmg file. That’s it!

Then we need to download the FabISP firmware from the link below. The Makefile which is inside the original firmware folder is ready to use with the avrisp2 or the usbtiny, if you will use a different programmer from these two options it will not work. So, I made some tweaks to that Makefile to make it compatible with the Arduino Uno that I use as a programmer. And it’s now ready to use with your Arduino UNO as a programmer you can download it from the link down below.

Now, we will open the terminal and navigate to the firmware folder. Then, clean any previously compiled files by writing make clean. Then we need to generate a new .hex that meets our new MakeFile. We will use the make hex command.

Then we need to write the make fuse command to set the fuses so the board will use the external clock. You should see a response like the one in the first image. Lastly, use the command make program to burn our firmware to the board to work as an AVR Programmer.

FabISP AVR Programmer Testing

After finishing the previous steps, your computer should now recognize the board as an ISP. Since i’m using a MAC machine, click on the Apple logo, then click in “About This MAC”, then “System Report”.

Then from the left side menu under the “Hardware” section click on “USB”. your programmer should be recognized by your computer with the name FabISB. Which means your AVR ISP is now ready to work!

FabISP AVR Programmer 3d Printed Enclosure

I designed an enclosure for the Tiny AVR programmer you can download it from the links down below. I 3d printed these parts with 20% infill without supports.

Here comes the end of the tutorial, thanks for your patience and check our upcoming tutorials on how to use this Tiny AVR programmer and how to program your own circuit boards. Don’t hesitate to drop down any question you want!

The post How I Made My Tiny AVR Programmer appeared first on Make Some Stuff.

For someone who loves to shoot some random hobbyist videos, it’s somehow expensive to buy a motorized camera slider. So, I built my own. In this tutorial, we will go through each step to build your own Bluetooth-controlled motorized camera slider.

Hardware Components

Used Software

Project Overview

Today we will build a motorized camera slider that we can control it wirelessly over Bluetooth from a custom-made android mobile app. I used the “MIT App inventor” tool to make the app which gives us the ability to control a lot of stuff like the slider movement speed, traveling distance, acceleration/deceleration rate and a lot more. The mobile app is very robust, inside the app you can set your camera slider length which you are using. which means, you are free to build your actual camera slider with any length up to 10 meters without worrying about the app.

We used a NEMA17 stepper motor as an actuator so we can control how many steps do we need the camera slider to move. To control a stepper motor using the Arduino board, we need a translator that takes commands from the Arduino board and translate it to the language that the stepper motor understands. Here comes the A4988 Pololu stepper motor driver role, which gives us five different microstep resolutions (down to 1/16 step) to achieve the maximum moving accuracy and movement smoothness.

This project Designed with makeability in a fablab/makerspace/hackerspace in mind.

CAD And 3d Modeling

We used Fusion360 to design the camera slider, we chose to use very well-known, easy-to-find mechanical components that you can buy easily from almost any online or offline store no matter where you live.

We are using Openbuilds hardware to build the mechanical structure, the V-slot 2040 linear rail as a guide for the camera to move on. Two pulleys, one on the stepper motor shaft. And the other one, on an 8mm linear rail shaft on the opposite side of the slider with an open timing belt between them to convert from the stepper motor rotary motion to linear motion.

The 8mm linear rail shaft is installed between two Self-aligning Pillow Flange Block Bearings that are installed on the top and bottom plate by four M5 screws.

We are using four Delrin V-Slot solid wheels they ride down in the V-groove of the V-Slot rail to make the camera movement extremely smooth. The middle of the camera plate has a 1/4 inch diameter hole for a standard tripod screw so you can mount your camera easily.

Lastly, an enclosure for the electronics, All the camera slider parts are fixed together by m3*16mm screws and nuts.

Digital Fabrication (3d Printing)

All of the camera slider body is 3D-printed with 0.2 layer height, 20% infill, except the Camera slider left and right leg, which are printed with 0.2 layer height, 50% infill.

You can download the STL files from this link.

V-Wheel Kit Assembly

The assembly process is very easy man, come on! In the first step, we need to assemble the four Solid V-Wheels. The solid V-wheel kit comes with a rubber wheel, two bearings, two percision shims, and a lock nut.

Insert the bearing from one side of the rubber wheel and flip the wheel around, then insert one precision shim inside the rubber wheel, lastly insert the second bearing from the second face side.

Camera Slider Mechanical Assembly

First, We need to assemble the camera plate and the four solid V-Wheels. using the 9mm aluminum spacer, the precision shim, and the lock nut.

We are going to repeat the previous step with the other three wheels. in the two right wheels we’re going to use the 9mm spacer. And the other two left wheels we’re going to use the eccentric spacer with a 3mm spacer instead of the 9mm spacer.

Now, insert the camera holder plate in the V-slot profile. If you found that the plate is loose and wiggling, you can tighten the Eccentric nut until you get a solid plate.

Let’s insert two drop-in tee nuts in each end of the V-slot profile. we need to connect the V-slot profile with the right and left legs of the camera slider.

Get the two camera slider legs and push them into the V-slot profile.

bring four M5X10mm screws, and fix the two legs with the V-slot profile.

We need to install the NEMA 17 stepper motor on its plate. then, using four M3X16mm screws we are gonna fix the motor in place.

On the left leg, insert two nuts inside the left leg top nuts place.

Bring the NEMA 17 motor plate ad fix it on the top of the left leg. and, using two M3X16mm screws we are gonna fix the plate on the left leg.

To be able to convert the stepper motor rotational movement into linear movement, we need to install a GT2 Bore 5mm pulley on the motor shaft. and using the Allen key, tighten the pulley set screw to keep it in place.

Let’s go to the camera slider right leg, insert four M3 nuts in the leg nuts place.

Then, put the right leg bearings two plates on the top of the camera slider right leg.

Using four M3X16mm screws, fix the two plates on the camera slider right leg to keep them in place.

Bring one of the 8mm flange block bearings and install it on the top right leg plate. using two M5X20mm screws and two M5 nuts.

We need to repeat the previous step with the second 8mm flange bearing block to fix it on the camera slider right leg bottom plate.

Insert the 8mm linear rail shaft in the 8mm flange bearing block from it’s bottom side, ad push it to the top. Then, insert the 8mm bore pulley into the linear rail shaft and fix it by tightening the pulley’s set screw.

Checkpoint, Now we assembled all the camera slider mechanism except one thing. the timing belt. Let’s do it.

rotate the 6mm timing belt on the NEMA17 motor 5mm bore pulley. Also, on the right leg 8mm bore pulley. Lastly, tighten the belt with the camera plate.

It’s time to assemble the control board. insert the Cairo Camera Slider Arduino shield on the top of the Arduino board.

Insert the Arduino board and the Cairo Camera Slider shield inside the control board enclosure.

insert two M3 nuts inside the left leg nuts place.

install the control board enclosure to the Cairo Camera Slider left leg with M3X16mm screws.

close the enclosure box top face with two M3 screws and nuts, and that’s it!

Stepper Motor Test Control

After assembling all the parts together, We need to test it to make sure that everything is installed in its place correctly. Now, we need to connect the stepper motor with the Arduino board through the A4988 stepper motor driver and write some code to run that thing.

A4988 stepper motor driver

To control any stepper motor using the Arduino board or any microcontroller, you will need a stepper motor driver which works as a translator, takes commands from the Arduino board and translate it to the language that the motor understands.

there are a lot of stepper motor drivers out there but we will use the A4988 driver. This driver allows us to control one bipolar motor at up to 2A output current per coil, it’s very simple to interface with the Arduino board you only need two digital pins to fully control your motor step and direction, which allows you to control the maximum current output easily with an onboard potentiometer, and gives you a micro-step resolution down to 1/16 micro-step.

VMOT, GND: It’s the power connection pins for the stepper motor itself, it can be 8V-35V. In our case, we are connecting a 12V 3A power source on those pins with a 100uf decoupling capacitor to protect the A4998 board from any power spikes.

2B, 2A: the output pins for the stepper motor first coil which can deliver up to 2A.

1A, 1B: the output pins for the stepper motor second coil which can deliver up to 2A as well.

VDD, GND: Used for driving the internal logic circuitry, it can be 3V to 5.5V. It’s totally isolated from the VMOT pin.

EN: Stands for “Enable” it’s an active LOW(0V) input pin, which means when this pin pulled LOW(0V) the A4988 chip is enabled. And when pulled HIGH(5V) the A4988 chip is disabled. By default, this pin is pulled LOW(0V) . So, the chip is always enabled unless you pull it HIGH(5V).

MS1, MS2, MS3: Through these pins, you can select your motor microstepping resolution(step size). The A4988 gives you five different microstep resolutions (full step, half step, quarter step, Eighth step, Sixteenth step). By applying appropriate logic levels to these three pins we can set the motors to one of the five step resolutions.

By default, the MS1, MS2, MS3 pins have internal pull-down resistors. So leaving these three microstep selection pins disconnected results in full-step mode.

RST, SLP: The “Reset” pin is an active LOW(0V) input pin, which means when it pulled LOW(0V), all the step inputs are ignored it also resets the translator itself until you pull it HIGH(5V). The “Sleep” pin also an active LOW pin, pulling it LOW, puts the driver in the sleep mode minimizing the power consumption. By default, the “Sleep” pin is pulled HIGH(5V).

STP, DIR: The “Step” pin is responsible for controlling the number of steps that the motor is rotating, each pulse to the “Step” pin corresponds for one microstep in the direction selected by the “Direction” pin, the faster the pulses, the faster the motor will rotate. By applying logic value HIGH(5V) on the “Direction” pin it makes the motor rotate clockwise, by applying LOW(0V) it makes the motor rotate counterclockwise(it may differs from one to another according to your motor wiring with the driver).

NEMA17 Stepper Motor

Stepper motors are DC motors that can rotate in precise increments, they are used in many applications like 3D printers to align the printhead and CNC machines to control the movement of the cutting tool and this is because they are very accurate and precise.

Unlike DC motors, stepper motors are controlled by applying DC electrical pulses to their internal coils. Each pulse makes the shaft advance by one step or a fraction of step which is called “Microstepping”. So, you can control precisely how many steps or even fraction steps you want the motor shaft to move. Another great advantage of using stepper motors is that it can move very precisely and accurately at very slow speeds without even stalling.

The type of motor we are using in this project is the NEMA 17 Bipolar stepper motor. The bipolar stepper motor has two internal coils and it usually has four wires, two wires per coil. unlike the Bipolar stepper motor which has five wires. The “Step Angle” of the motor is 1.8° which indicates how much the shaft advances in each full step, the motor works on 9V but if you want to get the maximum power of it use a 12V power source.

So, by connecting the stepper motor with the A4988 stepper motor driver, we can control how many steps we need the motor to move and in what direction. Also, we can set the “microstep” mode is it full step, half step, quarter step, ….. Let’s take a look at the wiring diagram.

Wiring Diagram

As we stated before, we need to make a small check to make sure that everything we assembled before is right in its place and moving properly. Now, we will wire all the hardware together, the NEMA 17 stepper motor with the A4988 stepper motor driver to the brain, the Arduino board. And using a 12V 3A Lithium-Ion battery to feed the motors with the power it needs.

Arduino Code

AccelStepper Library Installation

The Installation is pretty simple, we need to open Arduino IDE. From the “Sketch” menu select Include Library –> Manage Libraries…

A new window should appear, search for “AccelStepper” and install the library made by “Mike McCauley”. Easy right!

After installing the AccelStepper library, you should see it in the examples menu.

I wanna make sure that the AccelStepper library is installed correctly and my stepper motor connection with the A4988 motor driver is right and my power management is fine. So, let’s write some lines of code to run our stepper motor forward and backward.

// Bounce stepper test program
// Make a single stepper bounce from one limit to another
// Copyright (C) 2020 makesomestuff.org

#include <AccelStepper.h>

#define stepPin 2
#define dirPin 3

// Define a stepper and the pins it will use
AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);       //create an object. the pin "2" is the step pin, "3" is the direction pin.

void setup()
{  
  // Change these to suit your stepper if you want
  stepper.setMaxSpeed(100);
  stepper.setAcceleration(20);
  stepper.moveTo(500);
}

void loop()
{
    // If at the end of travel go to the other end
    if (stepper.distanceToGo() == 0)
      stepper.moveTo(-stepper.currentPosition());

    stepper.run();
}

The code logic is pretty straightforward, we initialized an object from the AccelStepper library, we defined two constants (stepPin, dirPin) that two digital pins is used by the A4988 stepper motor driver to control the movement of the motor itself.

#include <AccelStepper.h>

#define stepPin 2
#define dirPin 3

// Define a stepper and the pins it will use
AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);       //create an object. the pin "2" is the step pin, "3" is the direction pin.

Inside the void setup function, we set the Max. speed of the stepper motor to 100 steps/sec. Also, we set the acceleration/deceleration rate to 20 steps/sec. lastly, we used the moveTo() function to tell the motor to move 500 steps.

void setup()
{  
  // Change these to suit your stepper if you want
  stepper.setMaxSpeed(100);
  stepper.setAcceleration(20);
  stepper.moveTo(500);
}

Inside the void loop function, we are checking if the motor reached it’s position or not. If it reached the position, it will bounce back. and if it didn’t reach it’s position yet, it will keep running.

void loop()
{
    // If at the end of travel go to the other end
    if (stepper.distanceToGo() == 0)
      stepper.moveTo(-stepper.currentPosition());

    stepper.run();
}

Camera Slider Full Wireless Control

We have done great things so far. Let’s continue! The next step after testing everything is to work on the mobile app that we will use to control the camera slider movement and send the orders to it. Also, we need to work on the Arduino code that will receive the data from the mobile app and according to these data, it will take some actions like moving the motor, changing speed, acceleration, and so on…

Building The Mobile App

To build the mobile app, I used the MIT App inventor tool that allows you to create mobile apps that run on any Android smartphone. The tool is pretty simple since you only drag and drop some pre-made code blocks to build the logic of your program, also you use some premade blocks to build the app user interface. You can access the source of the mobile app from the link down below. Feel free to edit and share, it’s open-source.

The image down below, a brief explanation for each button function and how it works.

That mobile app will communicate with the Cairo camera slider wirelessly over Bluetooth communication. So, the next step is to connect a Bluetooth module to the last circuit we built before and upload some lines of code to the Arduino board to be able to establish the communication between the mobile app and the Cairo camera slider.

Wiring Diagram

It’s time to connect all things together, previously we connected the stepper motor, stepper motor driver, Arduino UNO, and the battery together and tested the circuit and it worked fine. Now, and after building the mobile app, we need to connect the HC-05 Bluetooth module to our circuit.

To make it wireless we will use the HC-05 Bluetooth module which has wide use, it can be set as slave or master as well (unlike the HC-06 module which can work only as a slave) which means that you can make a Bluetooth connection between two different Arduino boards. the HC-05 Bluetooth module is an SPP (Serial Port Protocol) module, which means that it communicates with the Arduino board via Serial communication. You only need to connect the Tx and the Rx pins between the HC-05 module and the Arduino UNO board.

Schematic and PCB Fabrication

Man! I don’t like breadboarding a big circuit like this. So, I designed a super pretty Arduino UNO shield PCB board that keeps all my components in place without worrying about the jumper wires or even the connections. All you need to do is to place your component on the Arduino shield PCB, insert the HC-05 Bluetooth module, A4988 stepper motor driver, and the battery in their places. and install the shield on top of the Arduino board. that’s it!

I fabricated my PCB at PCBWay the quality was very good, in a few days the package arrived in Egypt safely. and I paid just 5$ for the fabrication which is amazing. The coolest thing was that I was able to check the order fabrication and processing status online on my account panel and track everything happening to my baby board like I was there inside the factory.

you can download the PCB design source files or even order the Cairo Camera Slider Arduino Shield PCB from the PCBWay website.

Arduino Code And Bluetooth Communication

#include <MultiStepper.h>
#include <AccelStepper.h>

#define stepPin 2
#define dirPin 3

bool homingPositionFlag = false;
int startupSetupFlag = 0;
bool delayedStart = false;

int incomingData = 0;
int movementDistance = 50;
long steps = 0;       //50cm rail by default @1/8 microstepping.
int microStepResolution = 0;    //4  or  16
long railLength = 0;
int sliderSpeed = 10;

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);       //create an object. the pin "2" is the step pin, "3" is the direction pin.

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  Serial.begin(9600);

  stepper.setMaxSpeed(10.00);        //The fastest motor speed that can be reliably supported is about 4000 steps per second at a clock frequency of 16 MHz on Arduino such as Uno
  stepper.setAcceleration(500.00);     //1600 (40%) (Medium Acceleration rate)

  while (startupSetupFlag < 3) {
    if (Serial.available() > 1) {
      unsigned int dataOne = Serial.read();
      unsigned int dataOne1 = Serial.read();
      unsigned int incomingData = (dataOne1 * 256) + dataOne;

      //**************************************************************Motor Homing Part**************************************************
      if (incomingData == 16) {      //left end homing position.
        stepper.setCurrentPosition(steps);
        homingPositionFlag = false;
        startupSetupFlag++;
      } else if (incomingData == 17) {    //right end homing position.
        stepper.setCurrentPosition(-(steps));
        homingPositionFlag = true;
        startupSetupFlag++;
      }
      //**************************************************************microstep resolution Part**************************************************
      if (incomingData == 18) {
        microStepResolution = 4;                   //50cm rail length @1/4 microstep resolution.
        startupSetupFlag++;
      } else if (incomingData == 19) {
        microStepResolution = 16;                  //50cm rail length @1/16 microstep resolution.
        startupSetupFlag++;
      }

      if (incomingData >= 1301 && incomingData <= 2300) {
        railLength = incomingData - 1300; //from raw data to cm.
        if (microStepResolution == 4) {
          steps = ((6100L * railLength) / 50L);
          startupSetupFlag++;
        }
        else if (microStepResolution == 16) {
          steps = ((25000L * railLength) / 50L);
          startupSetupFlag++;
        }
      }
    }
    //Serial.println(startupSetupFlag);
  }
  /*
   * *********** *********** **********For Debugging Purposes* *********** *********** **********
    Serial.print("rail length: ");
    Serial.print(railLength);
    Serial.print("    number of steps:  ");
    Serial.print(steps);
    Serial.print("    Homing position: ");
    Serial.print(stepper.currentPosition());
    Serial.print("    microstep resolution: ");
    Serial.println(microStepResolution);*/
}

void loop() {

  if (Serial.available() > 1) {

    unsigned int dataOne = Serial.read();
    unsigned int dataOne1 = Serial.read();
    unsigned int incomingData = (dataOne1 * 256) + dataOne;
    //Serial.print("raw data:     ");
    //Serial.println(incomingData);

    //**************************************************************Motor Control Part**************************************************
    if (incomingData == 1 && stepper.isRunning() == false && stepper.currentPosition() != 6050 && homingPositionFlag == true) {
      if (delayedStart == true) { //use millis to delay 15 seconds.
        delay(15000);     //wait 15 seconds.
      }
      stepper.setCurrentPosition(0);
      stepper.moveTo(steps);             //from end to end (@ 1/4 step).
      homingPositionFlag = false;

      /*Serial.print("rail length: ");
        Serial.print(railLength);
        Serial.print("    number of steps:  ");
        Serial.print(steps);
        Serial.print("    Homing position: ");
        Serial.print(stepper.currentPosition());
        Serial.print("    microstep resolution: ");
        Serial.println(microStepResolution);*/
    }

    else if (incomingData == 2 && stepper.isRunning() == false && stepper.currentPosition() != -6050 && homingPositionFlag == false) {
      if (delayedStart == true) { //use millis to delay 15 seconds.
        delay(15000);     //wait 15 seconds.
      }
      stepper.setCurrentPosition(0);
      stepper.moveTo(-(steps));             //from end to end (@ 1/4 step).
      homingPositionFlag = true;

      /*Serial.print("rail length: ");
        Serial.print(railLength);
        Serial.print("    number of steps:  ");
        Serial.print(steps);
        Serial.print("    Homing position: ");
        Serial.print(stepper.currentPosition());
        Serial.print("    microstep resolution: ");
        Serial.println(microStepResolution);*/
    }

    else if (incomingData == 3 && stepper.isRunning() == true) {
      homing();
    }

    //**************************************************************Set Max. Speed Part**************************************************
    else if (incomingData >= 5001 && incomingData <= 9000) {
      sliderSpeed = incomingData - 5000;
      stepper.setMaxSpeed(sliderSpeed);
    }

    //**************************************************************Set Delayed Start Part**************************************************
    else if (incomingData == 7) {   //delayed start (15 seconds) is checked "true"
      delayedStart = true;
    }
    else if (incomingData == 8) {   //delayed start (15 seconds) is not checked "false"
      delayedStart = false;
    }

    //**************************************************************Set movement distance Part**************************************************
    else if (incomingData >= 201 && incomingData <= 1200) {  //convertin from rail length into number of steps. (upto 10 meters)
      movementDistance = incomingData - 200; //from raw data to cm.
      if (microStepResolution == 4) {
        steps = ((6100L * movementDistance) / 50L);
      }
      else if (microStepResolution == 16) {
        steps = ((25000L * movementDistance) / 50L);
      }
      /*Serial.print("rail length:  ");
        Serial.print(movementDistance);
        Serial.print("      number of steps:  ");
        Serial.println(steps);*/
    }

    //**************************************************************Set Acceleration Part**************************************************
    else if (incomingData == 11 && stepper.isRunning() == false) {          //HIGH
      stepper.setAcceleration(3000);
    }

    else if (incomingData == 12 && stepper.isRunning() == false) {          //Medium
      stepper.setAcceleration(1000);
    }

    else if (incomingData == 13 && stepper.isRunning() == false) {          //Low
      stepper.setAcceleration(500);
    }

    else if (incomingData == 14 && stepper.isRunning() == false) {          //Very High
      stepper.setAcceleration(4000);
    }

    else if (incomingData == 15 && stepper.isRunning() == false) {          //Very Low
      stepper.setAcceleration(10);
    }
  }
  stepper.run();
}

void homing() {
  if (stepper.currentPosition() > 0) {
    homingPositionFlag = true;
  } else {
    homingPositionFlag = false;
  }
  stepper.moveTo(0);
}

Code Logic

We’re using the amazing AccelStepper Arduino library that provides an object-oriented interface for 2, 3, 4 pins stepper motors to control it’s movement precisely.

#define stepPin 2
#define dirPin 3

bool homingPositionFlag = false;
int startupSetupFlag = 0;
bool delayedStart = false;

int incomingData = 0;
int movementDistance = 50;
long steps = 0;       //50cm rail by default @1/8 microstepping.
int microStepResolution = 0;    //4  or  16
long railLength = 0;
int sliderSpeed = 10;

AccelStepper stepper(AccelStepper::DRIVER, stepPin, dirPin);       //create an object. the pin "2" is the step pin, "3" is the direction pin.

when you open the mobile app and get connected to the Cairo camera slider it will ask you about the micro-stepping mode that you set the A4988 motor driver to work at. it’s very important to choose the correct micro-stepping mode. The Cairo camera slider only supports the 1/4 and 1/16 micro-step resolution. If you chose a wrong micro-step mode it will affect the distance calculations causing the camera carriage to hit the slider limits. So, be careful!

      //**************************************************************microstep resolution Part**************************************************
      if (incomingData == 18) {
        microStepResolution = 4;                   //50cm rail length @1/4 microstep resolution.
        startupSetupFlag++;
      } else if (incomingData == 19) {
        microStepResolution = 16;                  //50cm rail length @1/16 microstep resolution.
        startupSetupFlag++;
      }

It sets the camera slider homing if it’s left or right side homing. the homing position, once you click on right or left side homing a specific piece of data will get sent from the mobile app to the Arduino board according to the homing position that you have chosen.

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  Serial.begin(9600);

  stepper.setMaxSpeed(10.00);        //The fastest motor speed that can be reliably supported is about 4000 steps per second at a clock frequency of 16 MHz on Arduino such as Uno
  stepper.setAcceleration(500.00);     //1600 (40%) (Medium Acceleration rate)

  while (startupSetupFlag < 3) {
    if (Serial.available() > 1) {
      unsigned int dataOne = Serial.read();
      unsigned int dataOne1 = Serial.read();
      unsigned int incomingData = (dataOne1 * 256) + dataOne;

      //**************************************************************Motor Homing Part**************************************************
      if (incomingData == 16) {      //left end homing position.
        stepper.setCurrentPosition(steps);
        homingPositionFlag = false;
        startupSetupFlag++;
      } else if (incomingData == 17) {    //right end homing position.
        stepper.setCurrentPosition(-(steps));
        homingPositionFlag = true;
        startupSetupFlag++;
      }

now it sets how many steps should the stepper motor moves without hitting the camera carriage with the camera slider right or left legs. it reads and saves the rail length according to the value that the user enters in the mobile app. So, depending on the micro-step resolution that the user selected before, and the rail length I can calculate the number of steps that the motor should rotate to reach the limits of the slider rail without hitting the right or left legs.

if (incomingData >= 1301 && incomingData <= 2300) {
        railLength = incomingData - 1300; //from raw data to cm.
        if (microStepResolution == 4) {
          steps = ((6100L * railLength) / 50L);
          startupSetupFlag++;
        }
        else if (microStepResolution == 16) {
          steps = ((25000L * railLength) / 50L);
          startupSetupFlag++;
        }
      }
    }
    //Serial.println(startupSetupFlag);
  }

inside the loop function, it reads the mobile app incoming data and according to these data it takes different actions, like moving the stepper motor clockwise, moving anti-clockwise, stop and return back to the starting point, and changing the travelling speed, so on…

void loop() {

  if (Serial.available() > 1) {

    unsigned int dataOne = Serial.read();
    unsigned int dataOne1 = Serial.read();
    unsigned int incomingData = (dataOne1 * 256) + dataOne;
    //Serial.print("raw data:     ");
    //Serial.println(incomingData);

    //**************************************************************Motor Control Part**************************************************
    if (incomingData == 1 && stepper.isRunning() == false && stepper.currentPosition() != 6050 && homingPositionFlag == true) {
      if (delayedStart == true) { //use millis to delay 15 seconds.
        delay(15000);     //wait 15 seconds.
      }
      stepper.setCurrentPosition(0);
      stepper.moveTo(steps);             //from end to end (@ 1/4 step).
      homingPositionFlag = false;

      /*Serial.print("rail length: ");
        Serial.print(railLength);
        Serial.print("    number of steps:  ");
        Serial.print(steps);
        Serial.print("    Homing position: ");
        Serial.print(stepper.currentPosition());
        Serial.print("    microstep resolution: ");
        Serial.println(microStepResolution);*/
    }

    else if (incomingData == 2 && stepper.isRunning() == false && stepper.currentPosition() != -6050 && homingPositionFlag == false) {
      if (delayedStart == true) { //use millis to delay 15 seconds.
        delay(15000);     //wait 15 seconds.
      }
      stepper.setCurrentPosition(0);
      stepper.moveTo(-(steps));             //from end to end (@ 1/4 step).
      homingPositionFlag = true;

      /*Serial.print("rail length: ");
        Serial.print(railLength);
        Serial.print("    number of steps:  ");
        Serial.print(steps);
        Serial.print("    Homing position: ");
        Serial.print(stepper.currentPosition());
        Serial.print("    microstep resolution: ");
        Serial.println(microStepResolution);*/
    }

    else if (incomingData == 3 && stepper.isRunning() == true) {
      homing();
    }

    //**************************************************************Set Max. Speed Part**************************************************
    else if (incomingData >= 5001 && incomingData <= 9000) {
      sliderSpeed = incomingData - 5000;
      stepper.setMaxSpeed(sliderSpeed);
    }

    //**************************************************************Set Delayed Start Part**************************************************
    else if (incomingData == 7) {   //delayed start (15 seconds) is checked "true"
      delayedStart = true;
    }
    else if (incomingData == 8) {   //delayed start (15 seconds) is not checked "false"
      delayedStart = false;
    }

    //**************************************************************Set movement distance Part**************************************************
    else if (incomingData >= 201 && incomingData <= 1200) {  //convertin from rail length into number of steps. (upto 10 meters)
      movementDistance = incomingData - 200; //from raw data to cm.
      if (microStepResolution == 4) {
        steps = ((6100L * movementDistance) / 50L);
      }
      else if (microStepResolution == 16) {
        steps = ((25000L * movementDistance) / 50L);
      }
      /*Serial.print("rail length:  ");
        Serial.print(movementDistance);
        Serial.print("      number of steps:  ");
        Serial.println(steps);*/
    }

    //**************************************************************Set Acceleration Part**************************************************
    else if (incomingData == 11 && stepper.isRunning() == false) {          //HIGH
      stepper.setAcceleration(3000);
    }

    else if (incomingData == 12 && stepper.isRunning() == false) {          //Medium
      stepper.setAcceleration(1000);
    }

    else if (incomingData == 13 && stepper.isRunning() == false) {          //Low
      stepper.setAcceleration(500);
    }

    else if (incomingData == 14 && stepper.isRunning() == false) {          //Very High
      stepper.setAcceleration(4000);
    }

    else if (incomingData == 15 && stepper.isRunning() == false) {          //Very Low
      stepper.setAcceleration(10);
    }
  }
  stepper.run();
}

void homing() {
  if (stepper.currentPosition() > 0) {
    homingPositionFlag = true;
  } else {
    homingPositionFlag = false;
  }
  stepper.moveTo(0);
}

Cairo Camera Slider User Guide & troubleshooting

After connecting the 12V power source to the Arduino UNO board that distributes power to the Cairo camera slider Arduino shield as well, turn on the Bluetooth on your mobile, search for new devices, pair with the HC-05 device, and open the mobile app then press on the “Press here to connect with Cairo camera slider” button. It will show up the menu of the paired Bluetooth devices, select the HC-05 Bluetooth device.

After connecting successfully with the Control board, the mobile app will ask you some questions to set up some parameters. The first question will ask you about the micro-step resolution of the stepper motor driver if it’s smooth(1/4 micro-step), or very smooth(1/16 micro-step). select the mode According to the micro-stepping resolution mode that you set the A4988 driver at. If you selected a wrong mode The Cairo camera slider will not work correctly.

Then, it will ask you about the aluminum rail length that you are using in your camera slider. Enter the distance in CM. in my case I’m using a 50cm rail length.

Lastly, it will ask you about the camera carriage homing position, It’s very important to place the camera carriage on one of the two rail ends, the right end or the left end. In my case, the camera carriage is on the left end. So, I selected the left end homing.

If you started the Cairo camera slider and the camera carriage is on the middle of the rail or not on one of the two rail ends it will cause the carriage to hit the limits when it moves.

After you finish the set-up process, It will show you the parameters that you have set. And once you click OK, you will be ready to play around with your lovely Cairo camera slider.

Cairo Camera Slider In-Action

The post Arduino Motorized Camera Slider appeared first on Make Some Stuff.

Today we will learn how to build a standalone ATmega328p board. The same chip used in the Arduino UNO board. It’s Arduino UNO compatible which means that you can program it from the Arduino IDE without any hustle.

Used Components

ATmega328P Bare minimum configuration

Before building our standalone ATmega328P chip Arduino compatible board, let’s take a look at the awesome Arduino UNO board and see the main components that used to build that beautiful thing.

The first main component is the ATmega328P chip which is the brain of the board. A Voltage regulator that regulates the input voltage to a 5V clean output which gets used mainly by the ATmega320p chip. The 16MHz crystal oscillator, that creates an electric signal with a given frequency. Simply it counts the seconds so you don’t have to. Some LEDs to make you sure that the board is running smoothly and still alive. DC Plug allows you to connect the board to a DC power source. USB Port allows you to connect the board to your computer. Some pin headers to interface it with the external world(sensors, motors, LEDs, ..) through some jumper wires.

After knowing the main components used in the Arduino UNO board, we can make one using the same main components that we stated before which is called the ATmega328P bare minimum configuration.

Schematic

Wiring Diagram

As you can see, the bare minimum configuration means using the smallest possible quantity of components that makes that thing runs without problems. but later on, we will add some more components like LEDs, buttons, pin headers, .. to spice things up.

the ATmega328P works at 5V that must be well regulated without any spikes that’s why we are using a 10microfarad capacitor between the 5V power line. in order to make the ATmega328p runs, you have to apply a HIGH logic value “5V” on the “reset” pin.

Usually, the ATmega328P chip works on a 16MHz crystal oscillator placed on the pins 9 and 10 but in order to make it oscillate it needs two 22Picofarad capacitors connected to the GND.

But we want to spice things up, let us add some more components to give the board more features and make it more user-friendly.

Schematic

Cairoduino V1.0 Board

We added some new components to the bare minimum configuration that we discussed before to add more features to the board and make it more simple to use like a very normal Arduino UNO board.

1. DC Power plug to make connecting the board to a power source easy and fast.
2. L7805 voltage regulator, so you can plug it to any power source ranged between 7V-12V and the L7805 chip will regulate that voltage and give the ATmega328p chip a well-regulated 5V. The difference between the input voltage and the output voltage will go in a form of heat.
3. Reset button, to be able to reset the board easily in case of any misbehaving.
4. power LED as an indicator that tells the user if the board is connected to the power source or not.
5. On&Off switch.
6. pin headers to allow the user to connect any electronic components like sensors, LEDs, switches, … to the board easily using some jumpers, like any Arduino board.
7. FTDI breakout board, to be able to connect the board to the laptop so you can program and upload the code to it easily without removing the ATmega chip itself.

PCB Manufacturing

This board is designed on Eagle from Autodesk. You don’t have to be a PCB design expert to make or own this board because it’s fully open-source you can download the whole project from this link.

If you need this eagle project as a template so you can customize it according to your needs, you are very welcome to do anything you want to the project.

You can order your own Cairoduino board from PCBWay in just Two clicks. from this link.

From my point of view, PCBWay has the most user-friendly web-based interaction design in the industry! You can instantly get the quotation of your PCB, you can also check the order fabrication and processing status online in your account panel, After your PCBs are sent out to your address, you can track your order shipping status online and a lot more.

Uploading the bootloader to the chip

To be able to use the Arduino IDE to program the chip, we need to burn the bootloader to the Atmega chip. At this step, we need an Arduino UNO board we will use it as a programmer by connecting the MOSI, MISO, SCK pins between the ATmega328p chip and the Arduino UNO board.

If you already have an ATmega chip with the Arduino bootloader pre-loaded you don’t need to do these steps.

After connecting the ATmega chip with the Arduino board, we need to open the Arduino IDE –> File –> Examples –> ArduinoISP –> ArduinoISP

Then, set the Programmer to Arduino as ISP. Tools –> Programmer –> Arduino as ISP.

Now, it’s the time to burn the bootloader, Tools –> Burn Bootloader.

FTDI breakout board

As we stated before, we are using the FTDI module to connect the Cairoduino board to the laptop so we can program and upload the code to it, also you can send, read some stuff back and forth to the serial monitor through the established serial communication.

LED Blinking

Let’s try to upload a hello world code to the board to see if it behaving as expected or not. open Arduino IDE –> Examples –> Basics –> Blink

after connecting the board to your laptop and hitting the upload button, you should see the built-in LED which is connected to pin 13 blinking every 1 second. if you want to know more details about how LED blinking works you can check this tutorial which we published before.

The post ATmega328P Standalone Board appeared first on Make Some Stuff.

Makers always look at the simplest and shortest way to get things done. So, today we will learn how to control our home light switch in the simplest and quickest way.

Hardware Components

Introduction

Today, we will learn how to control home light switches by just hand-clapping, Cool ha! to build that project we will use some new electronic components like the decade counter CD4017 IC and the UA741 op-amp, and a condenser MIC as a sound sensor. So, let’s do it

Working Scenario

• Sensing

The main part of the project is sensing the hand-clap, we used an electret condenser MIC to do that job. which converts sound energy into electrical energy. this electrical signal will be an input signal to the UA741 IC. that electret MIC is very sensitive, easy to use, and cheap.

• Triggering

After sensing the hand-clap, the generated electrical signal will go to the input pin of the UA741 op-amp which works in this project as a comparator, the UA741 IC will compare the MIC input signal with a specific reference voltage if the input signal is higher than that reference voltage it will output logic value “HIGH”. And will output “LOW” when the reference voltage is higher than the input voltage.

We are using a potentiometer connected with the UA741 chip to adjust the reference voltage, which works just as setting the sensitivity of the circuit.

The UA741 IC output value goes to the “Clock” pin of the counter 4017 IC to turn on and off the relay.

• Driving high voltage/current load

You know, we are building this circuit to control AC high voltage loads. So, we used a 5VDC relay to make our small poor circuit able to communicate with that beefy AC high voltage load.

UA741 op-amp works as a comparator

The typical use of the UA741 IC is to amplify a specific signal. Essentially it takes an input voltage, amplifies it by a specific gain, then outputs an amplified voltage. That’s it. It’s mostly used in the speaker circuits to amplify the input signal to make the sound loud and clear.

But today, we will use the UA741 op-amp as a comparator, not as an amplifier.

As you can see, there’s a positive pin called “non-inverting terminal” and the negative pin called “inverting terminal”. these two pins are the input voltage pins. Also, there’s the voltage output “Vo” pin, and obviously the two power supply pins VCC, and GND.

Since the gain naturally of the op-amp is very huge, then what happens when we feed the op-amp two input pins?

If the input voltage on the positive terminal“Non-inverting pin” is higher than the input voltage on the negative terminal “Inverting pin” Even by a tiny amount. the op-amp will try to amplify the difference between those two inputs by a huge gain and the output voltage from the op-amp will equal (the difference between the two input voltages * the huge gain) which is a very large amount like hundred and hundred thousands of volts or something. But it can’t do it since you are powering your circuit by a 12V or 5V or even 15V.

As a result, it will saturate at the amount of voltage which you are powering your op-amp with. Which is the VCC.

Vice versa, if the input voltage on the negative pin “inverting terminal” is higher than the input voltage on the positive pin “non-inverting terminal” even by a tiny amount, the output voltage will equal the -VCC (GND).

UA741 Op-amp Pinout

• Pin 1 and 5 (Offset null)

We can set the op-amp gain value by connecting a capacitor on pins 1 and 5 but we don’t have to use those pins in this application, we will keep them unconnected.

• Pin 2 and 3 (Inputs)

Voltage input pins. We are connecting a potentiometer on the negative terminal (Inverting pin) to adjust the sound sensor sensitivity (Reference voltage). So, you can make the sensor very sensitive and feel the hand-clap from a long distance. Or decrease the sensitivity if there’s a lot of noise around you or something.

• Pins 4 and 7 (GND, VCC)

Easy! it’s the power supply pins. Pin 7 is VCC and 4 is GND. This chip can handle an input voltage from 5V to 15V.

• Pin 6 (Output)

The voltage output pin.

• Pin 8 (Not Connected)

Pin 8 is unconnected.

CD4017 IC Decade Counter

Each output of this chip will turn on, one at a time, sequentially or in succession. For example, let’s say that we are connecting ten LEDs with the chip. Each LED is connected on a different output pin, each LED will light, one at a time unless all have been turned on at the same time. After it reaches the last output pin(Q9) it will start over again and repeats and repeats infinitely.

This counting behavior is working by a command from the 4017 IC “Clock” pin which plays a big role in 4017 chip, without this pin the chip will not work at all. Once the “Clock” pin goes from LOW to HIGH, at this point the chip knows that it is the time to turn off the current output and turn on the next output. So, it knows when to act based on the clock signal.

CD4017 IC Pinout

• Pins 1,2,3,4,5,6,7,9,10,11

It’s the output pins where we place the load which we need to control. The outputs are numbered from Q0 to Q9. In our case, we will use only two output pins (Q0, Q1) to turn on and off the relay, the transistor which controls the relay state will be connected on Q0, and a normal LED on Q1 to indicate that the relay state is off.

• Pins 8 and 16 (GND, VDD)

Power supply pins, this chip can handle an input voltage from 3.3V to 18V.

• Pin 15 (Reset)

It resets the count back down to output 0 (Q0), normally it’s grounded. This means when it brought to a HIGH logic level it will reset the count down back to output 0 (Q0).

• Pin 14 (CLK)

As we stated before, It’s the pin that tells the chip when to start/stop counting.

• Pin 13 (EN)

The enable pin is an active low pin, which means it will normally be connected to the ground to make the chip active and operating properly, once it is brought to a HIGH logic level, the chip will stop operating.

• Pin 12 (CO)

The carry-out pin remains HIGH as long as the counting is on the first half(Q0 – Q4) and it turns LOW when the counter reaches the second half(Q5 – Q9).

Control high voltage appliances

Relay is an electromagnetic switch that turns on/off a circuit with a low power signal. Like in our case we need to drive a 220VAC load. But, our circuit can’t do that on its own so we added a relay to switch the AC on/off by the CD4017 output signal.

It’s very important to add a diode to protect your controller or your IC from any back-EMF.

We a re using a 5VDC relay which has 5 pins as shown in the figure below.

The “COM” is the contact that closes or opens the load circuit based on the coil state, is it energized or not?

The “Normally Closed” (NC)” is the pin that is closed by default when there is no current flowing through the coil, it will get disconnected from the COM pin only when current flows through the coil. “Normally Open” (NO) is the pin that is opened by default when there’s no current flowing through the coil, it will get connected with the COM pin only when current flows through the coil.

Schematic

This circuit works on 12V, not 9V.

PCB Manufacturing

I designed this circuit using Autodesk Eagle software. all the PCB files are open-source you can access it from the following link. Because we love open source.

You can order your own PCB From PCBWay company these guys have a very good reputation in this field and they ship to more than 170 countries around the world with reasonable prices. all you have to do is to open the project PCB files link and press “Add to cart”. That’s it!

Final

I will assume that you built it and you are happy now. CONGRATS FAM! in this tutorial we learned how does the CD4017 decade decoder IC work, also we learned how to use the UA741 op-amp as a comparator, and how to drive an AC voltage load using a simple relay. Lastly, we build a hand-clap AC control switch which is dope!

The post Custom-Made Handclap AC Switch Control Board appeared first on Make Some Stuff.

Today we will learn one of the most basic concepts in the Arduino world, digital outputs, and how to apply that concept on a very cool LED.

Hardware Components

Introduction

Today we will cover the very first concept that any Arduino beginner must have to know, we will talk about Arduino digital output pins, what does digital output signal mean? and lastly, we will apply those concepts to a very cool LED blinking application.

LED! What’s it?

LED stands for “Light Emitting Diode” which is a very easy-to-use component, it’ has two terminals, lights when a specific voltage is applied across its terminals. you can use the LED as a light indicator that lights when some event happens and more

Today we will use the most common 5mm LED, there’s a lot of LED sizes like the 3mm, 5mm, 10mm this number refers to the diameter of the LED, also it has many colors like red, green, yellow, blue,…

The LED is polarized, which means that it requires a specific way of wiring to work properly.

• Long terminal: is the positive lead, should get connected to the power source positive lead
• short terminal: is the negative lead, should get connected to the power source negative lead

The Current Limiting Resistor

Resistors all its job in life is to resist the flow of electrons “current” in the circuit, you can tell that from its name.

the higher the value of the resistor the less current will flow through it, and vice versa.

the LED is actually a simple diode which after a certain amount of voltage drop on its terminals will allow all the available current (unlimited) to flow through it which is not a good idea at all. Here comes the current limiting resistor job is to choke that current flow.

There is a simple formula V = IR, where V is voltage, I is current, R is resistance. this formula is called ohm’s law. We will use this formula to get out the right resistor value, but to get the right resistor value we need to know the right V and I value to put it in the formula to get the right resistor value. To get the V value we need to know two things, the voltage source and the forward voltage (voltage drop) on the LED.

So to Let’s say that we are using a 5V power source with a red LED connected in series with it. LEDs have a characteristic called forward voltage “Vf” which means the amount of voltage that got lost across the LED terminals. when operated at a certain current which is usually 2omA. Vf primarily depends on the LED color, for example, red, orange, the yellow LED Vf is around 1.8V while green, blue, white, and UV LEDs have a Vf of about 3.3 V. So, the forward voltage “Vf” on our red LED is 1.8V.

so by subtracting the LED forward voltage “Vf”(1.8V) from the power source voltage(5V) you will get the voltage drop across the resistor that we need to calculate its resistance. and that’s exactly what we need.

Now, we need to get the I value that we will use in the formula, which is the amount of current that we need it to flow through the LED to light properly without killing it. in any LED datasheet you find a characteristic called If or Imax which is the maximum continuous current rating this often around 25mA or 30mA, which means the typical current rating is around 20mA

After getting the formula’s V and I values. Now, we are ready to calculate the resistor value easily.

Now, the 160Ω resistor value will allow 20mA of current to flow through the LED at 5V which is exactly what we need.

Wiring Diagram

The wiring is pretty straightforward, we are connecting the long leg of the LED to the Arduino digital pin 7 through a resistor, and the LED short leg to the GND. That’s it!

Arduino Code

const int redLED = 7; 			//initialize a constant named "redLED" it's value 7 which refers to the pin number which the red LED is connected to.

void setup()
{
  pinMode(redLED, OUTPUT);	    //set the GPIO pin 7 as an output pin.
}

void loop()
{
  digitalWrite(redLED, HIGH);	//output a logic level "HIGH" which means 5V on the digital pin number 7 to turn the LED ON. 
  delay(1000); 					// Wait for 1000 millisecond(s).
  digitalWrite(redLED, LOW);	//output a logic level "LOW" which means 0V on the digital pin number 7 to turn the LED OFF.
  delay(1000); 					// Wait for 1000 millisecond(s).
}

Code Explanation

const int redLED = 7;

initializing a constant named “redLED” with a value 7 that refers to the Arduino pin number 7 which the LED is connected to.

void setup()
{
  pinMode(redLED, OUTPUT);
}

the setup() function is called once at the beginning of the program when the sketch starts or after the reset of the board, we use it to initialize variables, constants, take library objects, or to write some actions that we need to execute only once at the beginning of the program.

inside the setup() function, we set the Arduino pin number 7 as an output pin, which means that we are telling the Arduino board “Yo, make the pin number 7 ready to write a 5V or 0V output at any time.”

void loop()
{
  digitalWrite(redLED, HIGH);
  delay(1000);
  digitalWrite(redLED, LOW);
  delay(1000);
}

After creating the setup() function which initializes and sets the initial values, the loop() function does precisely what its name suggests, inside the loop() function you write the main program that you need to get executed over and over again until you force shutdown your Arduino board.

inside the loop() function, we are telling the Arduino pin number 7 to write a logic level HIGH which means output 5V to the LED to light it.

Then wait 1 sec.

In the Next line, we are telling the Arduino pin number 7 to write a logic level LOW which means output 0V (GND) to the LED to turn it off.

Then wait another 1 sec. before it returns back to the first line inside the loop() function.

Troubleshooting

If your LED doesn’t take any actions:

• Make sure that your LED wiring polarity is correct, LED long lead with the positive and the short one with the negative.
• make sure that you are connecting a current limiting resistor that more than 160Ω
• Make sure that you uploaded the Arduino code to the board Successfully.

Final

CONGRATS on your very first Arduino project fam! Today we have learned how to connect an LED on the Arduino board, and how to use it. Then we blinked an LED by writing some lines of code.

The post Arduino LED Blinking Hello, World appeared first on Make Some Stuff.

Ever asked how to control your home light system wirelessly over the Internet from any place in the world?! in this step-by-step tutorial we will learn how to do that.

Used Components

Used Software

• Autodesk Eaglecad (Optional).
• Firebase Database.
• Python Editor (Any Editor will work fine).

Introduction

Today, we will learn how to control any RGB LED Strip ambient light wirelessly over Wifi using a custom-built Andoird application connected with the awesome Raspberry Pi board through the Firebase database.

To build this project we need to deal with some stuff like how to build an android mobile app, how to build a firebase database server, how to connect the raspberry pi and the android app together through firebase, how to take different actions based on the incoming data, some power management, electronics Wiring, …
But yo hold on! Don’t worry we will cover all these topics in detail in today’s tutorial. So, bear with me and I promise it will be worth it.

Project Overview/Features

Simply, today we will build a smart device that allows the user to control his/her home ambient lighting system wirelessly over Wifi using any android smartphone, our project is divided into four main parts

• Android mobile application.
  the mobile app is the control panel which the user will interact with to send his/her commands to the lighting system.
• Database.
  is the global server which acts as a postman who takes mails from one person to deliver it to someone else. Firebase database will receive some data from the mobile app and send it to the raspberry pi to take some actions like changing the LED strip light intensity or light color, and other many stuff.
• Electronic and control circuit.
  the control circuit will be based on the raspberry pi board which running a python script reading the incoming data from the firebase database and according to these data will take some different actions.
• Power management.
  it’s the most crucial part, it’s the part which responsible for providing the device with the necessary power to operate properly without damages.

How does the project work?

Simply, the mobile app and the raspberry pi board are connected to the same firebase database. this database saves the data which comes from the mobile app and syncs it with the raspberry pi board in milliseconds, according to these data the raspberry pi board will take some specific actions like turning on the light, changing its brightness, and so on.

Control Three LEDs brightness using GPIO PWM

To control the RGB LED Strip light brightness you need to be familiar with the PWM technique in the raspberry pi world and how to use it. So, let’s start by a simple one and start controlling some normal 5mm LEDs brightness to get familiar with the PWM technique. As I promised you at the beginning of the tutorial, we will start it from scratch to understand every part of the project.

PWM stands for “Pulse Width Modulation” which is used to generate analog values using a digital technique. PWM is usually used to control LEDs brightness, DC Motor speed control, Servo motor rotation angle and that happens by outputting some variable voltage level.

But as we all know that the RPi and any computer is entirely digital system. But at the same time, we need to generate some analog signals from it. So, we need to find a way to convert that digital output signal to an analog output signal. Here comes the PWM technique!

Most of the devices around us are responding relatively in the world of electronics slowly to the signal that they are getting. So, let’s take a normal DC motor as an example, let’s say that we need to run this DC motor at its half speed. So, we need to give it half of its voltage to run at half of its speed. Basically, we are only capable of giving a 3.3V(logic 1) or 0V (logic 0) we can’t give value in between because it’s a digital system as we said before. But here comes the PWM role to modulate the signal up(3.3V) for half the time and down(0V) for half the time with a square wave which is called the duty cycle. that process happens very very rapidly and the motor can’t respond instantaneously to the change of the voltage so it takes some time to accelerate and decelerate which results, the motor averaging the voltage to something near 1.6V and will run at half of its speed. And you can change the motor speed by changing the duty cycle value.

If we take a normal LED as an example we will do the same previous process applying PWM, but because the LED is a simple diode it responds fairly quickly (faster than the motor) to the change of the signal, so your eyes as a human will make the averaging thing. As a result, you will see the LED changing its brightness.

• Period: It’s the sum of the HIGH(3.3V) time and the LOW(0V) time.
• Duty Cycle: Its the percentage of time where the signal was HIGH(3.3V) during the time of period.

Enough Theory! Let’s make some stuff. Let’s take a look at the wiring diagram.

Wiring Diagram

The wiring diagram is very simple, connect each LED on a different PWM pin

The raspberry pi has two different schemes in numbering its GPIO pins. you can use either pin numbers(BOARD) or the Broadcom GPIO pin numbers(BCM). You can only use one numbering scheme in each program.

GPIO Board: Referring to the pin by its number of the plug, the pin number on the physical board which printed on it. Example: PIN#1, PIN#2, …..
GPIO BCM: Referring to the pin by its “Broadcom SOC Channel” number, these are the numbers after the GPIO word. Example: GPIO12, GPIO19, ….

Neither way is wrong, both ways are good and work well without any differences. You have to pick the one which you feel comfortable more with.

The Raspberry Pi 3 Model B has two PWM channels (PWM0, PWM1) each channel has two different GPIO PWM pins available for use.

These three PWM pins GPIO12, GPIO 13, GPIO19 are used by the A/V output audio jack. So, if you don’t need to use the A/V audio jack in your project, these three GPIO PWM pins will be free and available to get used. But you can’t use the A/V output Audio jack and these PWM pins at the same time. In today’s project, we don’t need to use the A/V audio jack so all the PWM pins will be free and available for us to use.

Code

import RPi.GPIO as GPIO             #import the raspberry pi GPIO library, to be able to use them.
from time import sleep              #import the sleep library, which responsible to do the timing stuff.


redLED = 18				#red LED connected on PWM pin GPIO18
blueLED = 12            #blue LED connected on PWM pin GPIO12
greenLED = 19           #green LED connected on PWM pin GPIO19

GPIO.setwarnings(False)			#disable warnings
GPIO.setmode(GPIO.BCM)	        #set pin numbering system to the (Broadcom chip channel numbering).

GPIO.setup(redLED,GPIO.OUT)     #set the red LED pin(GPIO18) to an output pin.
GPIO.setup(blueLED,GPIO.OUT)    #set the blue LED pin(GPIO12) to an output pin.
GPIO.setup(greenLED,GPIO.OUT)   #set the green LED pin(GPIO19) to an output pin.

red_pwm = GPIO.PWM(redLED,1000)	       	      #create PWM instance with 1000Hz frequency.
blue_pwm = GPIO.PWM(blueLED,1000)             #create PWM instance with 1000Hz frequency.
green_pwm = GPIO.PWM(greenLED,1000)           #create PWM instance with 1000Hz frequency.

red_pwm.start(0)				              #start red LED PWM pin with 0% initial Duty Cycle (OFF).
blue_pwm.start(0)                             #start blue LED PWM pin with 0% initial Duty Cycle (OFF).
green_pwm.start(0)                            #start green LED PWM pin with 0% initial Duty Cycle (OFF).

print("AH Shit! Here we go again! Press CTRL+C to exit")    #Take Care, Meme LORD.

try:
    while True:                                         #the start of the actual program.
        for duty in range(0,101,1):                     #imolement a "for loop" responsible for increasing the red LED light brightness.
            red_pwm.ChangeDutyCycle(duty)               #provide duty cycle in the range 0-100.
            sleep(0.01)                                 #wait 0.01 sec. between each iteration.
        sleep(0.5)                                      #wait 0.5 sec. after the "for loop" is done.

        for duty in range(100,-1,-1):                   #implement a "for loop" responsible for decreasing the red LED light brightness.
            red_pwm.ChangeDutyCycle(duty)               #provide duty cycle in the range 100-0.
            sleep(0.01)                                 #wait 0.01 sec. between each iteration.
        sleep(0.5)                                      #wait 0.5 sec. after the "for loop" is done.
		
        for duty in range (0, 101, 1):                  #repeat the previous logic but this time with the blue LED.
            blue_pwm.ChangeDutyCycle(duty)
            sleep(0.01)
        sleep(0.5)

        for duty in range (100, -1, -1):                #repeat the previous logic but this time with the blue LED.
            blue_pwm.ChangeDutyCycle(duty)
            sleep(0.01)
        sleep(0.5)

        for duty in range(0,101,1):                     #repeat the previous logic but this time with the green LED.
            green_pwm.ChangeDutyCycle(duty)
            sleep(0.01)
        sleep(0.5)

        for duty in range(100,-1,-1):                   #repeat the previous logic but this time with the green LED.
            green_pwm.ChangeDutyCycle(duty)
            sleep(0.01)
        sleep(0.5)

except KeyboardInterrupt: 		# If CTRL+C is pressed, exit cleanly:
    red_pwm.stop() 			    # stop red PWM
    blue_pwm.stop()             # stop blue PWM
    green_pwm.stop()            # stop green  PWM
    GPIO.cleanup() 	            # cleanup all GPIO

Code Explanation

The code is pretty simple and straightforward, first, we need to import two important modules to allow us to use the raspberry pi GPIO pins. Also, import the time module that will make the timing work for us. without importing this module you will not be able to use the sleep() method.

import RPi.GPIO as GPIO
from time import sleep

then we need to initialize three variables called redLED, blueLED, greenLED referring to the three PWM pins that we will use to control our LEDs. Yeah as you noticed we are using the GPIO BCM numbering scheme.

redLED = 18
blueLED = 12
greenLED = 19

Then we need to set the numbering scheme of raspberry pi pins to “GPIO BCM”, then set all the three pins as output pins.

GPIO.setmode(GPIO.BCM)

GPIO.setup(redLED,GPIO.OUT)
GPIO.setup(blueLED,GPIO.OUT)
GPIO.setup(greenLED,GPIO.OUT)

create three PWM instances(instance for each pin) red_pwm, blue_pwm, green_pwm with 1000Hz frequency that will help us to generate the PWM signal. After that, we need to set the initial state of these pins to 0% duty cycle which means that the three pins will be OFF at the beginning of the program.

red_pwm = GPIO.PWM(redLED,1000)
blue_pwm = GPIO.PWM(blueLED,1000)
green_pwm = GPIO.PWM(greenLED,1000)

red_pwm.start(0)
blue_pwm.start(0)
green_pwm.start(0)

Here is the fun part! inside the while loop we write the set of commands(program) that we need to keep executing forever until we force-stop it.

inside the while loop implement a “for loop” it’s initial value 0, at every iteration it will increment by 1 until it reaches 100. This for loop responsible for increasing the red LED light brightness.

while True:                                       
    for duty in range(0,101,1):
        red_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.5)

The second for loop it’s initial value 100, at every iteration will decrease by 1 until it reaches 0. this for loop is responsible for decreasing the red LED light brightness.

    for duty in range(100,-1,-1):
        red_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.5)

then repeat the previous logic with the remaining two LEDs. After finishing your code, close and save it, run it by writing python fileName.py in the terminal.

After running it, It’s expected to see this sentence got printed on the terminal AH Shit! Here we go again! Press CTRL+C to exit then the three LEDs light brightness will start to increase and decrease.

I will assume that you did that and it’s working fine with you. VOILA! Officially you are now promoted to the next level. Let’s make it more interesting and control the beefy RGB LED Strip.

Control RGB LED Strip Lighting

Actually, controlling an RGB LED it’s not very different from controlling a normal LED. RGB LED means red, green and blue LED which combines all these three LEDs in one combo. with these three different colors, you can produce almost any color by mixing them with different intensities. To adjust LED intensity we use the PWM technique.

For example, to generate a pure red color, we need to set the red LED to the highest intensity and the green, blue to the lowest intensity. To generate a white color we have to set all the three LEDs to the highest intensity. And By adjusting the intensity of each LED you will generate a new color.

RGB LED Strip pinout

There are two main types of RGB LED strips. The common anode, and the common cathode. In the common anode RGB LED strip, the three LEDs share the same positive lead (Anode), and in the common cathode RGB LED strip, the three LEDs share the same negative lead (Cathode). As a result of that, the RGB LED strip has four leads, one for each LED (red, green, blue) and one common anode or common cathode.

The RGB LED strip that we will use today is Common Anode.

Power Management

Before we connect the RGB LED strip with raspberry pi we need to ask ourselves, Does the raspberry pi board able to provide the beefy RGB LED strip with the needed power to operate properly? The short answer is, of course not.

If you are a math nerd let’s do some calculations. we need to know how much current our RGB LED Strip is going to draw. each RGB cell contains three LEDs(red, green, blue) each LED in the cell draws 20mA at full intensity. So, each RGB cell will draw a current of total 60mA at full intensity, the RGB LED Strip that we are using today contains 20 cells/one meter, and we have a 4-meter long strip. So, Which means that the total drawn current at maximum intensity is equal to:
4(Meter)*20(cell/meter)*60(mA) = 4800MA.

this amount of drawn current will vary depending on the intensity of the LED brightness that you are working with, but we made the calculations at the highest values to work freely and be on the safe side. Now we need a power source that can provide us with those 4.8A at 12V.

The best option I found for that job, is a power supply/converter that converts an AC power to DC, the power supply/converter that we will use today offers 5A at 12VDC which is exactly what we need.

The Power Supply Connections

A power supply is an electrical device that converts one type of electrical type to another. In our case, we will convert a 220VAC to 12VDC.

From the left side, the first three terminals are the input from the AC power source:

• L: life.
• N: neutral.
• GND: earth.

The last four terminals are the 12VDC output, the first two terminals are the GND and the second two terminals are positive.

• V-: GND.
• V+: positive.

And we connect them as follow:

• Brown wire (AC Power source): L (Power supply).
• Blue wire (AC Power source): N (Power supply).
• Green wire (AC Power source): Earth (Power supply).

And the red, and the black wire are the 12VDC output:

• Red Wire: 12VDC Output (V+).
• Black Wire: GND Output (V-).

Wiring Diagram

As we stated before, the RGB LED strip needs 4.8A at 12VDC to operate properly. But at the same time, the Raspberry pi board can’t provide all that power to the RGB LED strip. So, we need a component that can take orders from the Raspberry pi board but provide power from the external 12VDC power supply.

Here comes the TIP122 Darlington transistor, this transistor can drive high power loads by using a small amount of current and voltage.

The TIP122 transistor can handle current up to 5A(Continous) and 8A(Peak) which satisfies our needs.

TIP122 Transistor Pinout

TIP122 Transistor acts like a switch that can drive loads with higher electrical requirements, so by a small amount of current and voltage can drive a high power load, at this example we gonna use the TIP122 which completes the LED strip circuit with the 12-volt power supply, the TIP122 has three legs(base, collector, emitter). The collector will get connected to the load(LED strip), and the emitter will get connected to the ground. And by a small amount of current on the base pin, will close the circuit between the collector and the emitter.

Make it More Professional

What about transferring our breadboard circuit to a professional printed circuit board (PCB) to make our project more rigid and solid.

Raspberry Pi HAT files (PCB)

I designed the project circuit using Autodesk Eagle software. all the PCB files are open-source you can access it from that link. We love open source

You can order your own PCB From PCBWay company these guys have a very good reputation in this field and they ship to more than 170 countries around the world with reasonable prices. all you have to do is to open the project PCB files link and click “Add to cart”. That’s it!

This PCB can get mounted over the Raspberry pi board easily as a normal raspberry pi HAT, it will organize your wiring and will make your project easier to debug.

With that slide switch, you can turn on and off the RGB LED Strip power.

Raspberry Pi Enclosure

I designed a laser cutting enclosure using Autodesk fusion 360, feel free to download the DXF files from that link.

Code

#We will use the same previous Code without any changes.

Code Explanation

The same previous explanation since we are using the same code with the same logic.

After finishing the wiring and your code, close and save it, Run your program by writing python fileName.py in your terminal. Like the last example, After running your program, It’s expected to see this sentence got printed on the terminal AH Shit! Here we go again! Press CTRL+C to exit then the three LEDs light brightness will start to increase and decrease.

After getting sure that everything is working as expected, let’s level it up and build our firebase database.

Building The Firebase Database

The Firebase Realtime Database is a cloud-hosted database. Data is stored as JSON and synchronized in realtime to every connected client. If you want to know more check out this link.

As we stated before, the realtime database will receive some data from the mobile app based on the user interaction and will sync it with the raspberry pi in milliseconds. So, to be able to use firebase you need to sign in using your normal Gmail account. then go to your project console to create a new project.

First things first, you need to create a new project in your console.

Then, give a name to your project

We don’t need to set up google analytics now

After creating your project successfully, your project overview page should look something like this. From the left menu, We need to select “Database”

We will choose “Realtime database” and click the “Create Database” button

After that, select “Test Mode” and click “Enable”

Now, your Realtime database should look something like this.

After building the Realtime Database, we need to build the mobile app that will send the data to the firebase database.

Building The Android Mobile APP

Now we need to build the mobile app that the user will use to control the RGB LED Strip from, we used the amazing tool the “MIT APP Inventor” to build it. It’s fast and very easy to use.

App inventor lets you develop android mobile applications using a web browser and a physical mobile phone or just the emulator, the MIT app inventor saves your projects in their clouds to keep tracking your work

First, you need to go to the MIT app inventor official website and login with your Gmail account, then press on the “create apps” button, then start building your mobile app. Easy HA!

To build your mobile app using the app inventor tool, you should deal with two main parts

• The design of the app.
• The programming of the app.

The App Design

The mobile application consists of Six buttons to control the lighting mode(Mode One, Mode Two, …), three sliders to control each LED color lighting intensity, and a button named “power button” to control the state of the LEDs(turning it ON or OFF). The most important part here is to add the “firebaseDB” client components to the app to allow us sending data to our firebase database project that we created before.

After adding the “FirebaseDB” component to the app, we need to put our created Firebase database URL to the mobile application “FirebaseDB” component to specify where does the data will get saved, the Firebase database URL can be found here.

The Programming Of The App

After designing the interface of our app we need to give it life, adding some functionality to each button and slider.

Let’s take the “Mode One” button as an example to see how the logic works. When the user clicks on the “Mode One” button it will send the value “mode1” with the tag “lightMode” to the firebase database project that we created before. and if we opened the firebase database dashboard page we will see that new entry got added to our database. Congrats!

But, when the user clicks the “Mode Two” button the “lightMode” tag value will get updated to the new value which in this case will be “mode2”.

The same logic applies to the remaining buttons, when the user clicks on a button, a specific piece of data will get sent to the database depending on what button the user clicked.

Building the app APK file

download the following .aia file and import it to your “MIT app inventor” account projects dashboard, it will open up the project source, don’t forget to update the “FirebaseURL” to your firebase project database URL.

You can download the .aia source file from that link.

Then build the app APK file and download it to your computer, then send the APK file to your mobile and install it.

Programming The Raspberry Pi

After building the mobile app and sending data successfully from it to the database, the raspberry pi will read that data from the “firebase database” and according to the read data, it will take different actions like changing the lighting mode or increasing the brightness and so on.

Installing The Pyrebase Module

Before we start writing any code, we need to install the “Pyrebase” python module on the raspberry pi board to allow us to communicate with the “Firebase Database” servers. Because by default the “Firebase” doesn’t support the “Python Programming Language” So, some cool guys wrote a python module to allow the python developers to use “Firebase” easily. If you are a Python NERD you can check out the module documentation on their Github page.

We will use “pip” to install the “Pyrebase” module. So, check to see if you currently have pip installed by running the command in the terminal.

pip --version

If it is not currently installed, you can install pip by running the following command

curl https://bootstrap.pypa.io/get-pip.py | python

After getting sure that we have “pip” on our raspberry pi board, we will start installing “Pyrebase” by running this command, and don’t worry if it takes some time.

sudo pip3 install Pyrebase

After finishing installing the “Pyrebase” module, we are now ready to write the final python script that will read data from the “Firebase database” to take some different actions according to that data.

Code

#OK!
#Author: Ahmed Ibrahim
#Date: 2/10/2019
#Website: makesomestuff.org

import RPi.GPIO as GPIO                                                                         #import the RPi.GPIO module to allow us use the board GPIO pins.
import pyrebase                                                                                 #import the pyrebase module which allows us to communicate with the firebase servers.
from time import sleep                                                                          #import the time modulde to allow us do the delay stuff.

config = {                                                              #define a dictionary named config with several key-value pairs that configure the connection to the database.
  "apiKey": "ENTER YOUR API KEY",
  "authDomain": "ENTER YOUR AUTH DOMAIN URL",
  "databaseURL": "ENTER YOUR DATABASE URL",
  "storageBucket": "ENTER YOUR STORAGE BUGET URL"
}

firebase = pyrebase.initialize_app(config)                              #initialize the communication with the "firebase" servers using the previous config data.

redLED = 12                                                                                    #the "redLED" variable refers to the GPIO pin 12 which the red LED is connected on.
blueLED = 19                                                                                   #the "blueLED" variable refers to the GPIO pin 19 which the blue LED is connected on.
greenLED = 18                                                                                  #the "greenLED" variable refers to the GPIO pin 18 which the green LED is connected on.

GPIO.setmode(GPIO.BCM)                                                                         #Set the GPIO Scheme numbering system to the BCM mode.
GPIO.setwarnings(False)                                                                        #disable warnings

GPIO.setup(redLED,GPIO.OUT)                                                                    #set the "redLED" variable pin (12) as an output pin.
GPIO.setup(blueLED,GPIO.OUT)                                                                   #set the "blueLED" variable pin (19) as an output pin.
GPIO.setup(greenLED,GPIO.OUT)                                                                  #set the "greenLED" variable pin (18) as an output pin.

red_pwm = GPIO.PWM(redLED,1000)                                                                #create PWM instance named "red_pwm" with frequency 1000.
blue_pwm = GPIO.PWM(blueLED,1000)                                                              #create PWM instance named "blue_pwm" with frequency 1000.
green_pwm = GPIO.PWM(greenLED,1000)                                                            #create PWM instance named "green_pwm" with frequency 1000.

red_pwm.start(0)                                                                               #start the program with 0% duty cycle (red LED will be OFF).
blue_pwm.start(0)                                                                              #start the program with 0% duty cycle (blue LED will be OFF).
green_pwm.start(0)                                                                             #start the program with 0% duty cycle (green LED will be OFF).

print("AH Shit! Here we go again! Press CTRL+C to exit")                                       #print "AH Shit! Here we go again! Press CTRL+C to exit" at the beginning of the program.

# function name: mode6
# arguments:
#   redIntensity: the brightness intensity of the red LED.
#   greenIntensity: the brightness intensity of the green LED.
#   blueIntensity: the brightness intensity of the blue LED.
# return: this funtion return nothing.
# this function is responsible for the pattern of the lighting mode. Feel free to change the lighting pattern as you want.
def mode6 (redIntensity, greenIntensity, blueIntensity):
    for duty in range (0, redIntensity, 1):
        red_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.3)
    for duty in range (redIntensity - 1, -1, -1):
        red_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.3)
    for duty in range (0, blueIntensity, 1):
        blue_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.3)
    for duty in range (blueIntensity - 1, -1, -1):
        blue_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.3)
    for duty in range (0, greenIntensity, 1):
        green_pwm.ChangeDutyCycle(duty)              #provide duty cycle in the range 0-100.
        sleep(0.01)
    sleep(0.3)
    for duty in range (greenIntensity - 1, -1 ,-1):
       green_pwm.ChangeDutyCycle(duty)               #provide duty cycle in the range 0-100
       sleep(0.01)
    sleep(0.3)

# function name: mode5
# arguments:
#   redIntensity: the brightness intensity of the red LED.
#   greenIntensity: the brightness intensity of the green LED.
#   blueIntensity: the brightness intensity of the blue LED.
# return: this funtion return nothing.
# this function is responsible for the pattern of the lighting mode. Feel free to change the lighting pattern as you want.
def mode5(redIntensity, greenIntensity, blueIntensity):
    for duty in range (0, redIntensity, 1):
        red_pwm.ChangeDutyCycle(duty)
        sleep(0.001)
    sleep(0.3)
    for duty in range (redIntensity - 1, -1, -1):
        red_pwm.ChangeDutyCycle(duty)
        sleep(0.001)
    sleep(0.3)
    for duty in range (0, blueIntensity, 1):
        blue_pwm.ChangeDutyCycle(duty)
        sleep(0.001)
    sleep(0.3)
    for duty in range (blueIntensity - 1 , -1, -1):
        blue_pwm.ChangeDutyCycle(duty)
        sleep(0.001)
    sleep(0.3)
    for duty in range (0, greenIntensity, 1):
        green_pwm.ChangeDutyCycle(duty)              #provide duty cycle in the range 0-100.
        sleep(0.001)
    sleep(0.3)
    for duty in range (greenIntensity - 1 , -1, -1):
       green_pwm.ChangeDutyCycle(duty)               #provide duty cycle in the range 0-100
       sleep(0.001)
    sleep(0.3)

# function name: mode4
# arguments:
#   redIntensity: the brightness intensity of the red LED.
#   greenIntensity: the brightness intensity of the green LED.
#   blueIntensity: the brightness intensity of the blue LED.
# return: this funtion return nothing.
# this function is responsible for the pattern of the lighting mode. Feel free to change the lighting pattern as you want.
def mode4(redIntensity, greenIntensity, blueIntensity):
    for duty in range (0, redIntensity, 1):
        red_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.5)
    green_pwm.ChangeDutyCycle(0)
    sleep(0.2)
    green_pwm.ChangeDutyCycle(greenIntensity - 1)

    for duty in range (0, blueIntensity, 1):
        blue_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.5)
    blue_pwm.ChangeDutyCycle(0)
    sleep(0.2)
    blue_pwm.ChangeDutyCycle(blueIntensity - 1)

    for duty in range (0,greenIntensity,1):
        green_pwm.ChangeDutyCycle(duty)
        sleep(0.01)
    sleep(0.5)
    red_pwm.ChangeDutyCycle(0)
    sleep(0.2)
    red_pwm.ChangeDutyCycle(redIntensity - 1)

    red_pwm.ChangeDutyCycle(0)
    green_pwm.ChangeDutyCycle(0)
    blue_pwm.ChangeDutyCycle(0)

# function name: mode3
# arguments:
#   redIntensity: the brightness intensity of the red LED.
#   greenIntensity: the brightness intensity of the green LED.
#   blueIntensity: the brightness intensity of the blue LED.
# return: this funtion return nothing.
# this function is responsible for the pattern of the lighting mode. Feel free to change the lighting pattern as you want.
def mode3(redIntensity, greenIntensity, blueIntensity):
    red_pwm.ChangeDutyCycle(0)
    green_pwm.ChangeDutyCycle(0)
    blue_pwm.ChangeDutyCycle(0)

    red_pwm.ChangeDutyCycle(redIntensity - 1)
    blue_pwm.ChangeDutyCycle(blueIntensity - 1)
    green_pwm.ChangeDutyCycle(greenIntensity - 1)

# function name: mode2
# arguments:
#   redIntensity: the brightness intensity of the red LED.
#   greenIntensity: the brightness intensity of the green LED.
#   blueIntensity: the brightness intensity of the blue LED.
# return: this funtion return nothing.
# this function is responsible for the pattern of the lighting mode. Feel free to change the lighting pattern as you want.
def mode2(redIntensity, greenIntensity, blueIntensity):
    red_pwm.ChangeDutyCycle(0)
    green_pwm.ChangeDutyCycle(0)
    blue_pwm.ChangeDutyCycle(0)

    blue_pwm.ChangeDutyCycle(blueIntensity - 1)
    sleep(0.1)
    blue_pwm.ChangeDutyCycle(0)
    sleep(0.1)
    green_pwm.ChangeDutyCycle(greenIntensity - 1)
    sleep(0.1)
    green_pwm.ChangeDutyCycle(0)
    sleep(0.1)
    red_pwm.ChangeDutyCycle(redIntensity - 1)
    sleep(0.1)
    red_pwm.ChangeDutyCycle(0)
    sleep(0.1)

# function name: mode1
# arguments:
#   redIntensity: the brightness intensity of the red LED.
#   greenIntensity: the brightness intensity of the green LED.
#   blueIntensity: the brightness intensity of the blue LED.
# return: this funtion return nothing.
# this function is responsible for the pattern of the lighting mode. Feel free to change the lighting pattern as you want.
def mode1(redIntensity, greenIntensity, blueIntensity):
    red_pwm.ChangeDutyCycle(redIntensity - 1)
    sleep(0.02)
    red_pwm.ChangeDutyCycle(0)
    sleep(0.02)
    red_pwm.ChangeDutyCycle(redIntensity - 1)
    sleep(0.02)
    red_pwm.ChangeDutyCycle(0)
    sleep(0.02)

    green_pwm.ChangeDutyCycle(greenIntensity - 1)
    sleep(0.02)
    green_pwm.ChangeDutyCycle(0)
    sleep(0.02)
    green_pwm.ChangeDutyCycle(greenIntensity - 1)
    sleep(0.02)
    green_pwm.ChangeDutyCycle(0)
    sleep(0.02)

    blue_pwm.ChangeDutyCycle(blueIntensity - 1)
    sleep(0.02)
    blue_pwm.ChangeDutyCycle(0)
    sleep(0.02)
    blue_pwm.ChangeDutyCycle(blueIntensity - 1)
    sleep(0.02)
    blue_pwm.ChangeDutyCycle(0)
    sleep(0.02)

try:
    while True:                                                                              #the beginning of the main program.

        database = firebase.database()                                             #take an instance from the firebase database which is pointing to the root directory of your database.
        RGBControlBucket = database.child("RGBControl")                            #get the child "RGBControl" path in your database and store it inside the "RGBControlBucket" variable.
        powerState = RGBControlBucket.child("powerState").get().val()                        #read the power state value from the tag "powerState" which is a node inside the database.
#        print("power state is: " + str(powerState))

                                                                                             # if the "powerState" variable value is equal to "true"
        if "true" in powerState.lower():
            database = firebase.database()                                         #take an instance from the firebase database which is pointing to the root directory of your database.
            RGBControlBucket = database.child("RGBControl")                        #get the child "RGBControl" path in your database and store it inside the "RGBControlBucket" variable.
            redLightIntensity = RGBControlBucket.child("redLightIntensity").get().val()  #read the red LED intensity value from the tag "redLightIntensity" which is a node inside the database then store that value inside the "redLightIntensity" variable.
            
#            print("red Light Intensity is: " + str(redLightIntensity))

            database = firebase.database()                                         #take an instance from the firebase database which is pointing to the root directory of your database.
            RGBControlBucket = database.child("RGBControl")                        #get the child "RGBControl" path in your database and store it inside the "RGBControlBucket" variable.
            blueLightIntensity = RGBControlBucket.child("blueLightIntensity").get().val()  #read the blue LED intensity value from the tag "blueLightIntensity" which is a node inside the database then store that value inside the "blueLightIntensity" variable.
            
#            print("blue Light Intensity is: " + str(blueLightIntensity))

            database = firebase.database()                                         #take an instance from the firebase database which is pointing to the root directory of your database.
            RGBControlBucket = database.child("RGBControl")                        #get the child "RGBControl" path in your database and store it inside the "RGBControlBucket" variable.
            greenLightIntensity = RGBControlBucket.child("greenLightIntensity").get().val()  #read the green LED intensity value from the tag "greenLightIntensity" which is a node inside the database then store that value inside the "greenLightIntensity" variable.
            
#            print("green Light Intensity is: " + str(greenLightIntensity))

            database = firebase.database()                                         #take an instance from the firebase database which is pointing to the root directory of your database.
            RGBControlBucket = database.child("RGBControl")                        #get the child "RGBControl" path in your database and store it inside the "RGBControlBucket" variable.
            lightPresetMode = RGBControlBucket.child("lightMode").get().val()  #read the light preset mode value from the tag "lightMode" which is a node inside the database then store that value inside the "lightPresetMode" variable.
            
#            print("light preset mode is: " + str(lightPresetMode))
            #           if the variable "lightPresetMode" value is equal to "mode6", call the mode6 function.
            if "mode6" in lightPresetMode.lower():
                mode6(int(redLightIntensity), int(greenLightIntensity), int(blueLightIntensity))
            #           if the variable "lightPresetMode" value is equal to "mode5", call the mode5 function.
            elif "mode5" in lightPresetMode.lower():
                mode5(int(redLightIntensity), int(greenLightIntensity), int(blueLightIntensity))
            #           if the variable "lightPresetMode" value is equal to "mode4", call the mode4 function.
            elif "mode4" in lightPresetMode.lower():
                mode4(int(redLightIntensity), int(greenLightIntensity), int(blueLightIntensity))
            #           if the variable "lightPresetMode" value is equal to "mode3", call the mode3 function.
            elif "mode3" in lightPresetMode.lower():
                mode3(int(redLightIntensity), int(greenLightIntensity), int(blueLightIntensity))
            #           if the variable "lightPresetMode" value is equal to "mode2", call the mode2 function.
            elif "mode2" in lightPresetMode.lower():
                mode2(int(redLightIntensity), int(greenLightIntensity), int(blueLightIntensity))
            #           if the variable "lightPresetMode" value is equal to "mode1", call the mode1 function.
            elif "mode1" in lightPresetMode.lower():
                mode1(int(redLightIntensity), int(greenLightIntensity), int(blueLightIntensity))
    #                   if the variable "lightPresetMode" value is not equal to any of the above values, print "DAMN, the power state is: false" on the terminal for debugging purposes.
        else:
            print("DAMN, the power state is: " + powerState)


except KeyboardInterrupt: # If CTRL+C is pressed, exit cleanly:
    red_pwm.stop() # stop red PWM
    blue_pwm.stop() # stop blue PWM
    green_pwm.stop() # stop green PWM
    GPIO.cleanup() # cleanup all GPIO

Code Explanation

the most important part here is to connect your python script to the “Firebase database” servers to be able to read the data from it. We define a dictionary named config with several key-value pairs that configure the connection to the database. The apiKey, authDomain, databaseUrl, and storageBucket values needed to connect to your database can be found in the Firebase console.

config = {                                                              #define a dictionary named config with several key-value pairs that configure the connection to the database.
  "apiKey": "ENTER YOUR PROJECT API KEY",
  "authDomain": "ENTER YOUR AUTH DOMAIN URL",       # "projectId.firebaseapp.com"
  "databaseURL": "ENTER YOUR DATABASE URL",         # "https://databaseName.firebaseio.com"
  "storageBucket": "ENTER YOUR STORAGE BUGET URL"   # "projectId.appspot.com"
}

To find the “API Key”, “authDomain”, “databaseURL”, “storageBucket” values, go to your database dashboard click on the gear icon, then “Project settings”.

Then you will find your project API key. Copy and paste it inside your python script. To find the “authDomain” you need to get the project ID, after getting your Project ID your “authDomain” will be like this “projectId.firebaseapp.com”.
your “storageBucket” will be like this “projectId.appspot.com”.

and to get your “databaseURL” go to your project database dashboard and copy that URL. That’s It!

If you want more code explanation, please read the code comments it’s well documented.

How does It Work?

After finishing the wiring and your code, close and save it, Run your program by writing python3 fileName.py in your terminal.
Like the last example, After running your program, It’s expected to see this sentence got printed on the terminal AH Shit! Here we go again! Press CTRL+C to exit then you will be able to control the LED Strip from your mobile app, Voila!

Note: You must run your program using python3, because the “pyrebase” module only works with python3 any other python version will not work.

Troubleshooting

If you see that error message when you run your program

don’t worry open your terminal and execute that commands

pip install --upgrade pyasn1-modules

this command will install your missing modules.

Running The Program Automatically On Startup

We don’t need to run the program manually by ourselves every time we boot up our raspberry pi board, it will be a good idea if we get our program to run automatically whenever the raspberry pi boots.

After the desktop environment starts (LXDE-pi, in this case), it runs whatever commands it finds in the profile’s autostart script, which is located at /home/pi/.config/lxsession/LXDE-pi/autostart for our Raspberry Pi.

First, we need to create a .desktop File, Open a terminal, and execute the following commands to create an autostart directory (if one does not already exist) and edit a .desktop file for our project code

mkdir /home/pi/.config/autostart
nano /home/pi/.config/autostart/IoTUsingRaspberryPi.desktop

Copy in the following text into the “IoTUsingRaspberryPi.desktop” file. Feel free to change the Name and Exec variables to your particular application.

[Desktop Entry]
Type=Application
Name=IoTUsingRaspberryPiAndFirebase
Exec=/usr/bin/python3 /your program absolute path/programName.py

That’s it! Now, at every time you boot up your raspberry pi, the program will start running automatically.

Troubleshooting

 your script does not run as soon as you see the desktop?!

there could be several issues. First, make sure that you have logged in (autostart does not start until you have logged in). You could also try enabling auto-login in raspi-config. Second, make sure you are using the absolute directory path (e.g. /home/pi/IoTUsingRaspberryPi.py). Third, make sure that you are using the python version 3 not anything else.

My Setup

Final

We are done! in today’s tutorial, we learned how to build a simple mobile app using MIT App inventor. Also, we learned how to control RGD LED strips using the raspberry pi board, and how to communicate with the firebase database servers through a python script. Lastly, how to control an RGB LED strip wirelessly from anywhere in the world.

Lastly, if you have any questions drop it in the comments section below, I will be more than happy to hear from you

The post IoT Using Raspberry Pi and Firebase and Android appeared first on Make Some Stuff.

Ever asked how to control your home appliances from any place in the world? In this step by step tutorial, we will learn how to control things wirelessly through the internet using our Awesome Arduino board.

Hardware

1. Arduino Nano
2. ESP8266-01
3. Two-channel Relay
4. any AC load.
5. Two LEDs.
6. Breadboard.
7. Bunch of resistors (1K, 2.2K).
8. Bunch of jumpers (Male-female, male-male).

Used Software

1. Arduino IDE.
2. Visual Studio Code (optional).
3. Autodesk Eagle (Optional).
4. Any web Browser.

Introduction

Today, we will build a device that connects to the internet and allow the user to control his/her home remotely over wifi. we will use the Arduino board(any model will do the job well) with the ESP8266-01 wifi module to make this device. Let’s get started!

What’s a smart home?

Smart home technology uses devices such as linking sensors, features and other appliances connected to the internet of things (IoT) that can be remotely monitored, controlled or accessed and provide services that respond to the needs of the users.

Wikipedia

Working Scenario

The Control Panel

We will build a simple web page that will work as a control panel for the user allows him to control any home appliance connected to our system. To build the web page we will use:

• HTML
• CSS
• Jquery

The Embedded Hardware

the web page sends some orders to the ESP8266-01 which is working as a web server connected to the Arduino board. And according to the incoming data, the Arduino board will take some actions like turning on the bulb, turning off the TV and in this part, we will use:

• Arduino
• ESP8266-01

Getting Started with the ESP8266-01

As we stated before, we need our Arduino board to get connected to the Internet but the Arduino Nano the version which we are using today doesn’t have that feature. So, we will use the ESP8266-01 wifi module to add the wifi feature to our tiny Arduino board.

there are a lot of ESP wifi modules models out there, which one should I choose?! Well, almost all the ESP family wifi modules out there will do the job well but each one has its own features and specifications. I encourage you to look at each one specifications and features to choose the most suitable one for your needs.

According to my needs, I found the ESP8266-01 is the most suitable one and that’s for many reasons. It’s very famous in the makers community. As a result, it got a very solid online community that you can find an answer to almost any question or problem you face with this awesome small module. Also, its price is very cheap(around 1.5$). Also, it’s very easy to use with the Arduino board since its a Serial wifi module it can communicate with the Arduino board over the serial communication. It has a built-in Microcontroller which means that you can use it as a standalone microcontroller and wifi module in one combo which is super cool. It has built-in two GPIOs. Only with 1.5$, you will get all of these features which is super cool, actually.
let’s get a closer look at this module.

ESP8266-01 Pinout

• VCC: connect to +3.3V power source. don’t connect it with a 5V source it will get damaged.
• GND: -ve pin, connect it to the ground of your circuit.
• CH_PD: chip enables pin – Active HIGH. connect it to a logic value HIGH to allow the module to boot up.
• RST: Chip Reset pin – Active LOW, when it pulled LOW it Resets the module.
• GPIO0, GPIO2: General purpose input/output pins.
• Tx: connect to the Rx of the microcontroller(Arduino) to establish serial communication.
• Rx: connect to the Tx of the microcontroller(Arduino) to establish serial communication.

ESP8266-01 Configuration

As we stated before the ESP8266-01 module communicates with the Arduino board over the Serial communication, which means that we need to connect it with the Arduino’s Serial pins 0, 1(Tx, Rx). But the problem here is that these pins will be busy because we will use the Arduino Serial monitor alongside the ESP8266-01 for debugging purposes. So, we need to find another two Serial communication pins to use them with the ESP8266-01.

Fortunately, Arduino made this easy. There’s a library called “SoftwareSerial” which was developed to allow serial communication on other digital pins of the Arduino, using software to replicate the functionality. For example, by using this library I can set the pins 2, 3(SoftwareSerial) as Rx and Tx alongside the pins 0, 1(Hardware Serial).

“SoftwareSerial” library works great as long as the transmission speed is less than 19,200 baud. But, there’s a small problem here! the ESP8266-01 wifi module comes from the factory programmed to communicate at speed 115,200 baud which is somehow hard at the “SoftwareSerial” library to communicate at. So, we need to reprogram our wifi module to set the communication speed to 9600 baud which works pretty good with the “SoftwareSerial” library. To do that we will use some “AT Commands”.

Changing the ESP8266-01 communication speed

First step: Upload an empty program to the Arduino board

At this step, we are uploading an empty code to the Arduino board. Just to be sure that there’s nothing is Executing in the background by the Arduino board.

Second Step: Wiring the ESP8266-01 with the Arduino board

To Reconfigure the ESP8266-01 and change the communication speed(baud rate) we use the AT-commands. Simply, AT commands are some instructions used to control modems, mobile phones, Bluetooth modules, wifi modules, GSM Modules, … with these commands we can get basic information about our mobile phone or GSM Modules like the name of the manufacturer, model number, IMEI and so on.

“AT” is an abbreviation for “ATtention” and it’s called AT-commands because every command starts with “AT”. the “AT” prefix is not a part of the commands itself it just tells the module the start of the commands.

Some Important AT Commands

Command number “4” depends on your ESP8266-01 firmware version, if this command doesn’t work with you AT+CIOBAUD=<baud> Try this one AT+UART_DEF=<baud>,8,1,0,0

Step 1: Open the Serial Monitor

Step 2: Set the Communication speed to 115,200 baud

As we stated before, the ESP comes from the manufacturer programmed to communicate at speed 115,200 baud. So we need to set the Arduino communication speed to 115,200 too for the first time only then we will change that later.

Also, you should select “Both NL & CR”.

Step 3: Send “AT” and wait for the response to be sure that the ESP module is hearing you.

Step 4: Now, change the ESP8266-01 communication speed

My ESP8266-01 module loaded firmware is 1.6. and this command AT+UART_DEF=<baud>,8,1,0,0 works well for me. If it doesn’t work with you, try this AT+CIOBAUD=<baud> .

If it responds with “OK” now your ESP module communication baud rate changed from 115,200 baud to 9600 baud. CONGRATS!

Let’s change the Serial monitor communication speed back to 9600 and send “AT” again to see if the ESP module can hear us at the new Speed(9600) or not.

LOOK! it’s working. the ESP8266-01 now can communicate with the Arduino board at 9600 baud rate instead of 115,200 baud rate.

Now, let’s try to connect with the Wifi network

Once you press enter, the ESP8266-01 will search for this network and connect with it. If the process succeeds it will return this
WIFI CONNECTED
WIFI GOT IP

At this point, we successfully changed the ESP8266-01 communication speed from 115,200 baud to 9600 baud. Now, we need to build the control panel(Web Page) which the user will use to control his home appliances. So, let’s build it!

What’s the Internet?

Actually, the internet is a wire buried under the ground it can be fiber optics, copper, or even a satellite but the internet is simply a wire.
Any two computers connected to that wire can communicate. If the computer is connected directly to that wire it’s called a server and if it is not connected directly to that wire it’s called a client.

Server: is a special computer that runs a specific Operating system like Apache, this special computer saves some web pages, files, databases on its disk drive. any server connected to the internet has a unique IP Address like 172.217.171.228, the IP address is just like a phone number that helps people to find each other easily. Since that IP Address is not very easy for humans to remember. So, we just gave it a name like: google.com(Domain name).

Client: it’s a computer like what you and I are using every day, it’s connected indirectly to the internet through an internet service provider(ISP) and it also has a unique IP address.

Working Scenario

Simply, it starts with a request sent from a web browser(Client) like google chrome, firefox and ends with the response received from the webserver.

You entered the website URL makesomestuff.org in a browser from a computer(client), then this browser sends a request to the webserver that hosts the website, the webserver then returns a response containing HTML page or any other document format to the browser to display it.

Exactly, that’s what we need to do today in our project. We need to send a request from the web browser(Client) to the ESP8266-01(Webserver) which both of them are connected to the same local network. This request contains some data which tells the Arduino what to do turn on or off a light bulb. So, let’s build the web page!

Building The Web Page

To build our web page we have to deal with HTML, CSS, Javascript. if you never heard about these names before, don’t worry I got you.

HTML: Stands for “HyperText markup language” we use it to build any web page main structure. Like adding some buttons, images, paragraphs, headers, tables, and many more elements. it consists of a series of elements that tell the browser how to display the web page content. these elements represent by something called tags.

CSS: It stands for cascading style sheet. After building the web page main structure, you need to make this structure looks nice here comes CSS to make some styling. it’s a language that describes the style of an HTML element. it consists of some selectors and deceleration blocks.

Javascript: it’s a programming language that we will use to make the web page more interactive like adding some animations, maps and it allows us to make some complex things on the web page. Mainly, we will use it today to send an HTTP request from the client(web browser) to the webserver(ESP8266-01) to take some actions like turning on or off a light bulb.

Build The Web Page Structure

To easily understand the upcoming explanation, I recommend Reading this cool HTML intro.

As we see our control panel is very simple, it contains two headers each one has a different size, one image, and two buttons one for turning on an LED and the second one for turning it off.

Code

<!DOCTYPE html>
<html>

<head>
    <title>Smart Home System</title>
</head>

<body>

    <h1> Smart Home Control Panel</h1>                               
    <h4>Sorry But I'm a Meme Addict!</h4>
    <img src="dogMeme.jpg" width="400px" height="400px">
    <br>
    <button id="111" class="button">LAMP ON</button>
    <br>
    <button id="110" class="button">LAMP OFF</button>
</body>

</html>

Code Explanation

• <!DOCTYPE html>: declaration defines that this document is an HMTL5 document.
• <html>: the root element of an HTML page.
• <head>: contains meta-information about the page.
• <title>: specifies the title of the document. this title appears on the web page browser tab.
• <body>: contains the visible web page content.
• <h1>: defines a large element.
• <h4>: defines a smaller header. when the header value decreases the font decreases.
• <img>: adds an image to the web page. the image that you want to display should be in the same project folder.
• <br>: advance the cursor to a new line.
• <button>: adds a button to the page content.

Each button is our web page has very important two attributes the id, and the class attributes. we will talk about why we assigned these two values to the buttons in the Jquery code explanation.

Styling The Web Page

To easily understand the upcoming explanation, I recommend Reading this cool CSS intro.

Now, the web page looks nicer (NOT TOO MUCH xD) we gave it a cool green background color, we make the page content centered aligned, and we change the headers font color and font family which made the web page more alive. We used CSS to do all of this styling stuff.

Code

<!DOCTYPE html>
<html>

<head>
    <title>Smart Home System</title>
</head>

<body style="background-color: seagreen; color: seashell; text-align: center;">

    <h1> Smart Home Control Panel</h1>                               
    <h4>Sorry But I'm a Meme Addict!</h4>
    <img src="dogMeme.jpg" width="400px" height="400px">
    <br>
    <button style="margin: 10px;" id="111" class="button">LAMP ON</button>
    <br>
    <button style="margin:10px;" id="110" class="button"> LAMP OFF</button>
</body>

</html>

Code Explanation

We added some few lines of code to make our web page looks nicer. We added style="background-color: seagreen; color: seashell; text-align: center;" inside the body tag to make all the web page content in the center of the page and to set the background color to seagreen also to set the font color to seashell.

Also, we added style="margin: 10px;" inside the two button tags to set a margin of 10 pixels around the four sides of each button.

Sending a Request To The Webserver

To easily understand the upcoming explanation, I recommend Reading this cool Jquery intro.

Now, after building our web page structure and styling it we need to add some functionality to the two buttons which we added earlier in the web page. we need when the user clicks the “LAMP ON” button his/her browser sends a request contains some unique data to the server(ESP8266-01) this unique data tells the Arduino to turn on the lamp. The same thing with the second button “LAMP OFF” when the user clicks it, the browser will send a request contains some unique data to the server(ESP8266-01) this unique data tells the Arduino to turn off the lamp. Let’s take a look at the code.

<!DOCTYPE html>
<html>

<head>
    <title>Smart Home System</title>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
</head>

<body style="background-color: seagreen; color: seashell; text-align: center;">

    <h1> Smart Home Control Panel</h1>                               
    <h4>Sorry But I'm a Meme Addict!</h4>
    <img src="dogMeme.jpg" width="400px" height="400px">
    <br>
    <button style="margin: 10px;" id="111" class="button">LAMP ON</button>
    <br>
    <button style="margin:10px;" id="110" class="button"> LAMP OFF</button>
        <script>                                                        //starting Javascript.
        $(".button").click(function () {                            //if any button from the ".button" class is clicked
            var p = $(this).attr('id');                             //get this button id and store it inside the "p" variable.
            pin: p                                                  //a dictionary contains the button id to get sent to the web server.
            $.get("http://192.168.1.4:80/", {                      //then send a get request to the web server"http://192.168.1.4:80/" (":80" means port number 80) with some data in a form of dictionary {pin: p} which is the butoon id. IMPORTANT NOTE: DON'T FORGET TO CHANGE THE IP ADDRESS WITH YOUR ESP8266 NEW IP ADDRESS.
            pin: p
            });
        });
    </script>
</body>

</html>

Code Explanation

First Things First, we need to import the Jquery library in our code. So, we added this line in the head tag.
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>

All the magic happens in this interesting part.

    <script>                                                        //starting Javascript.
        $(".button").click(function () {                            //if any button from the ".button" class is clicked
            var p = $(this).attr('id');                             //get this button id and store it inside the "p" variable.
            pin: p                                                  //a dictionary contains the button id to get sent to the web server.
            $.get("http://192.168.1.4:80/", {                      //then send a get request to the web server"http://192.168.1.4:80/" (":80" means port number 80) with some data in a form of dictionary {pin: p} which is the butoon id. IMPORTANT NOTE: DON'T FORGET TO CHANGE THE IP ADDRESS WITH YOUR ESP8266 NEW IP ADDRESS.
            pin: p
            });
        });
    </script>

$(".button").click(function () {
When the user clicks on any button associated with the class “button”, trigger the following function.

var p = $(this).attr('id');
Get the value of the clicked button attribute “id” and store it inside the “p” variable.

pin: p
Put the variable “p” value in a dictionary (key-value) it’s key is “pin” and the value is “p” variable value.

$.get("http://172.20.10.11:80/", { pin: p });});
Then, send a GET request to the webserver which it’s IP address is “172.20.10.11”. this GET request contains the value of the attribute id pressed button.

In case the user pressed the “LAMP ON” button this id value will be 111, so the GET request header will contain some data like this pin=111. look at the next figure!

At the opposite side, if the user pressed “LAMP OFF” button the request will contain this data pin=110.

Code Logic

I know you asking now why the heck did he choose 111 and 110 specifically? Ok, Lemme answer you fam. Actually, the number 111 and 110 divides into two parts.

• Part one: is the first two numbers which are in both cases will be “11”, it refers to the Arduino pin number which the load I need to control is connected on.
• Part two: is the third number which changes between 1 and 0 depending on the clicked button. And it refers to the pin state(ON or OFF).

In the Arduino code, we will receive this data and separate these two parts from each other and save each part in a different variable, part one in variable pinNumber and the second part in variable pinState, then we will write this simple line of code to control the connected load
digitalWrite(pinNumber, pinState);

Connecting The Load

Now, we need to connect the load with the Arduino board to control it. Before connecting any high voltage device like the air conditioner or even the TV, we need to test our circuit and the code with some low voltage stuff like LEDs only to make sure that everything is working well. Here’s the wiring diagram

The wiring is pretty simple, we are connecting the LED positive leg to the Arduino digital pin 11, and the negative leg to the GND through a 1k ohm resistor.

Arduino Code

#include <SoftwareSerial.h>                         //including the SoftwareSerial library will allow you to use the pin no. 2,3 as Rx, Tx.
SoftwareSerial esp8266(2,3);                        //set the Rx ==> Pin 2; TX ==> Pin3.

#define serialCommunicationSpeed 9600               // <========= define a constant named "serialCommunicationSpeed" with a value 9600. it referes to the Software and hardware serial communication speed(baud rate).
#define DEBUG true                                  //make a constant named "DEBUG" and it's value true. we will use it later.

int redLED =12;                                     //assign a variable named "redLED" with an integer value 12, it refers to the pin which the red LED is connected on.
int blueLED =11;                                    //assign a variable named "blueLED" with an integer value 11, it refers to the pin which the blue LED is connected on.


void setup()

{
  pinMode(redLED,OUTPUT);                           //set the pin number 12 as an output pin.
  pinMode(blueLED,OUTPUT);                          //set the pin number 11 as an output pin.
  
  digitalWrite(redLED,LOW);                         //turn the red LED off at the beginning of the program.
  digitalWrite(blueLED,HIGH);                       //turn the blue LED on at the beginning of the program.

  Serial.begin(serialCommunicationSpeed);           //begin the Hardware serial communication (0, 1) at speed 9600.
  esp8266.begin(serialCommunicationSpeed);          //begin the software serial communication (2, 3) at speed 9600.

  InitWifiModule();                                 //call this user-defined function "InitWifiModule()" to initialize a communication between the ESP8266 and your access point (Home Router or even your mobile hotspot).

  digitalWrite(blueLED,LOW);                        //after finishing the initialization successfully, turn off the blue LED (just an indicator).
}

void loop()                                                         //our main program, some fun are about to start)
{

  if(esp8266.available())                                           //if there's any data received and stored in the serial receive buffer, go and excute the if-condition body. If not, dont excute the if-condition body at all.
  {
    if(esp8266.find("+IPD,"))                                       //search for the "+IPD," string in the incoming data. if it exists the ".find()" returns true and if not it returns false.
    {
      delay(1000);                                                  //wait 1 second to fill up the buffer with the data.
      int connectionId = esp8266.read()-48;                         //Subtract 48 because the read() function returns the ASCII decimal value. And 0 (the first decimal number) starts at 48. We use it to convert from ASCI decimal value to a character value.
      esp8266.find("pin=");                                         //Advance the cursor to the "pin=" part in the request header to read the incoming bytes after the "pin=" part which is the pinNumer and it's state.
      int pinNumber = (esp8266.read()-48)*10;                       //read the first Byte from the Arduino input buffer(i.e. if the pin 12 then the 1st number is 1) then multiply this number by 10. So, the final value of the "pinNumber" variable will be 10.
      pinNumber = pinNumber + (esp8266.read()-48);                  //read the second Byte from the Arduino input buffer(i.e. if the pin number is 12 then the 2nd number is 2) then add this number to the first number. So, the final value of the "pinNumber" variable will be 12.
      int statusLed =(esp8266.read()-48);                           //read the third byte from the Arduino input buffer. then save it inside the "statusLed" variable. At any case, it will be 1 or 0.

      digitalWrite(pinNumber, statusLed);                           //then turn the LED at "pinNumber" on or off depending on the "statusLed" variable value.

      Serial.println(connectionId);                                 //print the "connectionId" value on the serial monitor for debugging purposes.
      Serial.print(pinNumber);                                      //print the "pinNumber" value on the serial monitor for debugging purposes.
      Serial.print("      ");                                       //print some spaces on the serial monitor to make it more readable.
      Serial.println(statusLed);                                    //print the "statusLed" value on the serial monitor for debugging purposes.

      String closeCommand = "AT+CIPCLOSE=";                         //close the TCP/IP connection.
      closeCommand+=connectionId;                                   //append the "connectionId" value to the string.
      closeCommand+="\r\n";                                         //append the "\r\n" to the string. it simulates the keyboard enter press.
      sendData(closeCommand,1000,DEBUG);                            //then send this command to the ESP8266 module to excute it.
      
    }
  }
}

/******************************************************************************************************************************************************************************************
* Name: sendData
* Description: this Function regulates how the AT Commands will ge sent to the ESP8266.
* 
* Params: command - the AT Command to send 
*                 - timeout - the time to wait for a response 
*                 - debug - print to Serial window?(true = yes, false = no)
*                 
* Returns: The response from the esp8266 (if there is a reponse)
*/
String sendData(String command, const int timeout, boolean debug)
{
    String response = "";                                             //initialize a String variable named "response". we will use it later.
    
    esp8266.print(command);                                           //send the AT command to the esp8266 (from ARDUINO to ESP8266).
    long int time = millis();                                         //get the operating time at this specific moment and save it inside the "time" variable.
    while( (time+timeout) > millis())                                 //excute only whitin 1 second.
    {      
      while(esp8266.available())                                      //is there any response came from the ESP8266 and saved in the Arduino input buffer?
      {
        char c = esp8266.read();                                      //if yes, read the next character from the input buffer and save it in the "response" String variable.
        response+=c;                                                  //append the next character to the response variabl. at the end we will get a string(array of characters) contains the response.
      }  
    }    
    if(debug)                                                         //if the "debug" variable value is TRUE, print the response on the Serial monitor.
    {
      Serial.print(response);
    }    
    return response;                                                  //return the String response.
}



/******************************************************************************************************************************************************************************************
* Name: InitWifiModule
* Description: this Function gives the commands that we need to send to the sendData() function to send it.
* 
* Params: Nothing.
*                 
* Returns: Nothing (void).
*/
void InitWifiModule()
{
  sendData("AT+RST\r\n", 2000, DEBUG);                                                  //reset the ESP8266 module.
  //delay(1000);
  sendData("AT+CWJAP=\"PUT YOUR SSID\",\"PUT YOUR PASSWORD\"\r\n", 2000, DEBUG);        //connect to the WiFi network.
  delay (3000);
  sendData("AT+CWMODE=1\r\n", 1500, DEBUG);                                             //set the ESP8266 WiFi mode to station mode.
  delay (1000);
  sendData("AT+CIFSR\r\n", 1500, DEBUG);                                                //Show IP Address, and the MAC Address.
  delay (1000);
  sendData("AT+CIPMUX=1\r\n", 1500, DEBUG);                                             //Multiple conections.
  delay (1000);
  sendData("AT+CIPSERVER=1,80\r\n", 1500, DEBUG);                                       //start the communication at port 80, port 80 used to communicate with the web servers through the http requests.
}

code explanation

the code is pretty straightforward, we implemented two different functions InitWifiModule() and sendData()

the sendData() function job is regulating how the AT commands will get sent to the ESP8266-01 module.
the InitWifiModule() function job is to provide the sendData() function the AT commands that we need to send to the ESP8266-01.

in the loop() function we read the income HTTP request header and search for the “+IPD,” which means that the request has successfully arrived, then we read the pin value which it will be “111” if the user clicked the “LAMP ON” button and “110” if the user clicked “LAMP OFF” button.

don’t forget to put your wifi SSID and Password in the Arduino code line no. 103
sendData("AT+CWJAP=\"PUT YOUR SSID\",\"PUT YOUR PASSWORD\"\r\n", 2000, DEBUG); //connect to the WiFi network.

for more code explanayion please read the comments in the code, it’s well documented

How It Works

After uploading the code to the Arduino board, open the Serial monitor and read the responses that the ESP module is sending.

at the beginning of the program, if you see something like the previous figure with “OK” at the end of the page, it means that the ESP8266-01 module is successfully connected to your wifi (Access point) and got an IP and MAC address . Now, you can open your fancy web page and try to control some stuff

But, if you see something like the previous figure with a “FAIL” or “ERROR” at the end of the page, it means that your ESP module cant connect to your wifi (Access point) for some reasons, try to check if entered the right SSID and password for your network.

Adding a High Voltage Load

After we tested our code and got sure that everything is working like a charm, we need to replace this boring LED with a High volage load like an air conditioner, TV or a light bulb. But to control all of these high voltage appliances we have to deal with relays.

What’s and why relay? Ok, the relay is a mechanical switch, which is toggled on or off by energizing a coil. it’s mainly used to control a high powered circuit using a low power signal (5V or 0V). So we can control a high powered device like an air conditioner or an AC lamp turning it on or off only by a 5V or 0V signal. Which is amazing!

The Two-channel relay module has two control pins(IN1, IN2) these pins should get connected to two Arduino digital pins to control the state of the two coils, closes or opens the load circuit.

At the opposite side of the relay module, the COM(common) should get connected to one end of the load. the other end of the load is either connected to the NC(Normally Close) or NO(Normally open), if connected to the NO the load remains Disconnected before trigger and vice versa.

Wiring Diagram

As you see, we are using a two-channel relay module that gives us the ability to control two different AC loads. We are connecting the first relay at digital output pin 11(Arduino) and the second relay to digital output pin 12(Arduino)

We will make a small modification to our web page, we will add another two buttons(ON and OFF) to control the second connected load.

<!DOCTYPE html>
<html>

<head>
    <title>Smart Home System</title>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
</head>

<body style="background-color: seagreen; color: seashell; text-align: center;">

    <h1> Smart Home Control Panel</h1>                               
    <h4>Sorry But I'm a Meme Addict!</h4>
    <img src="dogMeme.jpg" width="400px" height="400px">
    <br>
    <button style="margin: 10px;" id="111" class="button">Blue LED ON</button>
    <button id="110" class="button">Blue LED OFF</button>
    <br>
    <button style="margin:10px;" id="121" class="button"> Red LED ON</button>
    <button id="120" class="button">Red LED OFF</button>
    <script>                                                        //starting Javascript.
        $(".button").click(function () {                            //if any button from the ".button" class is clicked
            var p = $(this).attr('id');                             //get this button id and store it inside the "p" variable.
            pin: p                                                  //a dictionary contains the button id to get sent to the web server.
            $.get("http://192.168.1.4:80/", {                       //then send a get request to the web server"http://192.168.1.4:80/" (":80" means port number 80) with some data in a form of dictionary {pin: p} which is the butoon id. IMPORTANT NOTE: DON'T FORGET TO CHANGE THE IP ADDRESS WITH YOUR ESP8266 NEW IP ADDRESS.
            pin: p
            });
        });
    </script>
</body>

</html>

How It Works

Just like the last trial, You upload the Arduino code to the board (if not uploaded yet) and open the serial monitor and make sure that your ESP module is connected successfully to your access point and got an IP and MAC address.

Then open your fancy web page and start controlling your stuff

Make it more professional!

What about transferring our breadboard circuit to a professional printed circuit board (PCB) to make our project more rigid and solid, I designed the project circuit using Autodesk Eagle software. all the PCB files are open-source you can access it from the following link. we love open source

You can order your own PCB From PCBWay company these guys have a very good reputation in this field and they ship to more than 170 countries around the world with reasonable prices. all you have to do is to open the project PCB files link and press “Add to cart”. That’s it!

Troubleshooting

• if your ESP Module is successfully connected to your access point but there is no action happens when you click the web page buttons
  • make sure that your PC or Laptop and the ESP module is connected to the same Access point.
  • In Jquery code, make sure that you wrote the right ESP module IP address.
  • make sure that you are sending the request from your web browser from port 80(HTTP). example: $.get("http://192.168.1.4:80/"
  • Make sure that you are connecting the load at Arduino digital pins 11 and 12.

Don’t forget to save the Web page code file after any change or modification, and reload the web page in the web browser after any code modification to take effect.

Final

We are done! in today’s tutorial, we learned how to build a simple web page using HTML, CSS, and jquery. Also, we learned how to control an AC load wirelessly from a web-based control panel, and how to use the awesome ESP8266-01 Wifi module with the Arduino board.

Lastly, if you have any questions drop it in the comments section below, I will be more than happy to hear from you

The post IoT Using ESP8266-01 and Arduino appeared first on Make Some Stuff.

Wanna Control your Robot wirelessly through your laptop?! We gonna do that in this step-by-step tutorial Using the awesome Arduino board and Processing.

Hardware Components

1. Arduino Uno
2. 2WD Robot Chassis Kit (Includes Two DC Motors).
3. L298N Dual H-bridge Motor Driver
4. 7.4V 1500mAh Rechargeable battery

Used Software

• Arduino IDE
• Processing IDE

Introduction

In this tutorial, we gonna build a 2WD Robot controlled wirelessly from your laptop or PC through a simple GUI built on Processing IDE. We gonna divide this tutorial into two main parts:

Control the Two DC Motors from the Arduino Serial Monitor

• How Does DC Motors Work?
• What is the H-bridge circuit and why we need it?
• what’s the L298N motor driver module and how to use it with the Arduino board.
• What’s the Arduino Serial Monitor.
• code explanation.

Control the Two DC Motors from the Processing Control Panel GUI

• How to build our User Interface using Processing IDE.
• What’s the HC-05 Bluetooth module and how to use it with Arduino.
• code modification explanation.

First Part: Control the Two DC Motors from the Arduino Serial Monitor

Working Scenario

the user will control the two DC Motors from the Arduino serial monitor according to the characters he/she send.

• by sending the char ‘f’, the two motors will rotate FORWARD.
• sending the char ‘b’, the two motors will rotate BACKWARD.
• by sending the char ‘r’, the left motor will rotate FORWARD and the right motor will rotate BACKWARD.
• sending the char ‘l’, the right motor will rotate FORWARD and the left motor will rotate BACKWARD.
• by sending the char ‘s’, the two motors will STOP rotating.

How DC Motor Works?

Simply, DC motor is a component that converts electrical energy into mechanical energy. we will not dive deep into that Electromagnetism, induction, and magnetic field stuff. actually, I don’t care about that, what I care about is how to drive this dc motor thing.

The DC motor will start rotating only when a current flow through it, the motor rotation direction depends on the current flow direction. (See Fig 1) By changing the polarity of the power source with the motor, motor rotation direction will get reversed. (NOTE: DC motors have no polarity).

How to drive the DC motor from the Awesome Arduino board?

Actually, DC motors draw a large amount of current while rotating up to 500mA each (500mA in our case. but actually, it depends on the motor size and its power rating), but our Arduino board only can provide 40mA at 5V on its digital pins. so we need to use an external power source(battery) to provide the motors with the required power to operate properly without damaging the Arduino board. Also, we need to separate that power circuit(External power source) from the control circuit(Arduino Board).

• We will use a 7.4V 1.5Ah battery as a power source to provide the required power to our motors. (power circuit)
• and of course, the Arduino UNO board to control the Motors. (Control circuit)

we can use a BJT Transistor like the 2N2222a NPN Transistor to separate the power circuit from the control circuit. Some 2N2222a Specs before using it:

• Collector-Emitter Voltage is 30V.
• The continuous collector current is 800mA.
• Base current is 5mA max.

In the Above circuit, We are using the transistor as a switch, when the voltage across the Base-emitter transistor is HIGH (5V) it will close the connection between the collector and the emitter. So, the current will flow through the motor which will make it rotates.

if the voltage across the Base-emitter transistor is LOW (0V) it will open the connection between the transistor collector and emitter and the motor will stop rotating.

don’t forget to use a current limiting resistor on the transistor base pin (1k Ohm) to prevent it from damaging. Also, use a diode in parallel with your motor to protect your Arduino from any back EMF returning from the motor.

But this circuit will allow us to only control one direction of the motor ON and OFF. So, what if we want to control its rotation direction? we will need an H-bridge circuit.

Simply, the H-bridge circuit inverts the direction of the current flow through the motor. this circuit contains four switching elements(transistors in our case) by activating two particular switches at the same time we can change the direction of the current flow thus change the motor rotation direction. for example:

• when Q1 & Q4 are activated and the Q2 & Q3 are deactivated, the current will flow from the VCC of the power source passing through the Q1 then to the motor(from the left terminal to the right terminal) then to Q4 then to the GND. which will make the motor to rotate in the clockwise direction.
• when Q2 & Q3 are activated and the Q1 & Q4 are deactivated, the current will flow from the VCC of the power source passing through the Q3 then to the motor(from the right terminal to the left terminal) then to Q2 then to the GND. which will make the motor to rotate in the anti-clockwise direction.

So, using only two output pins(A, B) from the Arduino board you can control the state of the four switching elements(transistors) thus controlling the motor rotation direction.

• ‘A’ pin Controls transistor Q1, and Q4.
• ‘B’ pin Controls transistor Q2, and Q3.

GUESS WHAT! I have some good news for you, you don’t need to build this H-bridge circuit from scratch. we will use the L298N H-bridge Motor driver module which gives us all these functionalities.

Simply, the L298N Motor driver module is a dual H-bridge circuit that allows you to feed the motors with the needed power from an external power source, also allows you to control the motors rotation direction from your Arduino board.

the L298N Motor driver module is a two-channel driver which means that you can connect two different DC motors and control each one independently. the L298N Module can drive DC motors that have a voltage between 5-35V with 2A peak current at each channel.

• Motor A –> First Motor Terminal.
• Motor B –> Second Motor Terminal.
• 12V jumper –> if your using a power source more than 12V remove this jumper to not damage the onboard voltage regulator.
• pin (Vs) –> is the pin where the motor power source is connected to, the input voltage should be between 5V and 35V.
• Pin(GND) –> is the pin where both the GND of the battery and the GND of the Arduino board is connected on.
• Power pin(5V IN/OUT) –> you can source 5V from this pin only if the 12V jumper is connected. but if the 12V jumper is disconnected you should feed the L298N IC with 5V input to operate properly.
• Enable pins(Enable A) –> by sending a PWM signal from your Arduino PWM Output pin you can control the speed of motor A.
• Enable pins(Enable B) –> by sending a PWM signal from your Arduino PWM Output pin you can control the speed of motor B.
• Logic pins(input1 & input2) –> by sending a digital signal from your Arduino digital Output pin you can control the rotation direction of the Motor A.
• Logic pins(input3 & input4) –> by sending a digital signal from your Arduino digital Output pin you can control the rotation direction of the Motor B.

L298N Motor Driver Module Wiring With Arduino

• connecting the four logic input pins(L298n Module logical pins) with any four Arduino digital output pins to control the motors rotation direction.
• connecting the two enable pins with any two Arduino PWM output pins to control the motors rotation speed. (0 for lowest speed and 255 for highest speed).
• Connect the +VE terminal of the battery to the +12V pin of the L298N Module, also connect the -VE terminal of the battery to the GND pin of the L298N module. Don’t forget to connect the Arduino GND pin as well to the L298N Module GND Pin.

Sending/Receiving Data between the laptop and the Arduino board.

Serial communication is the process of sending data one bit at a time, sequentially, over a communication channel or computer bus. Source: Wikipedia.com

Let’s give an example, imagine that you have an Ultrasonic sensor(it’s a sensor that measures the distance between it and an object.) and you want to send this distance value to your computer to do some further actions. one simple solution is to connect your Arduino board with your computer via USB and send that data using Serial communication. And fortunately, that Arduino already has built-in functions to communicate with the serial port. You may also want to control your RC car motors remotely. in this case, you need to send your orders from your laptop or smartphone to the Arduino board also over the Serial communication.

To use Arduino serial port, you need to set the speed at which your computer will communicate with the Arduino board(it’s called baud rate). in your program inside the void setup() function, use the .begin function with the builtin object Serial to set that speed. to see the valid baud rate values and for more details see the Arduino reference.

Serial.begin(9600);

Some methods you need to know more about:

• Serial.available() –> Get the number of bytes (characters) available for reading from the serial port
• Serial.read() –> Reads incoming serial data.
• Serial.println() –> prints data to the serial port as human-readable text with a line break at the end.
• Serial.print() –> same as the Serial.println() but without a line break at the end.
• Serial.write() –> Writes binary data to the serial port. This data is sent as a byte or series of bytes.

Source Code

#define in1 4                                                           //defining const. variable named "in1" with value 0, which refers to the PICO D0.                
#define in2 5                                                           //defining const. variable named "in2" with value 1, which refers to the PICO D1.                
#define in3 7                                                           //defining const. variable named "in3" with value 2, which refers to the PICO D2.                
#define in4 8                                                           //defining const. variable named "in4" with value 3, which refers to the PICO D3.                
#define motorASpeedPin 9                
#define motorBSpeedPin 3                
char val;            
              
/*                
  forward function takes four arguments x, y, motorSpeed, speedPin.                
  this function returns nothing.                
  responsible for running motor A forward by a specific speed.                
*/             
             
void forward(int x, int y, int motorSpeed, int speedPin) {                
 digitalWrite(x, HIGH);                
 digitalWrite(y, LOW);                
 analogWrite(speedPin, motorSpeed);                
}           
               
/*                
  backward function takes four arguments x, y, motorSpeed, speedPin.                
  this function returns nothing.                
  responsible for running motor B backward with a specific speed.                
*/             
             
void backward(int x, int y, int motorSpeed, int speedPin) {                
 digitalWrite(x, LOW);                
 digitalWrite(y, HIGH);                
 analogWrite(speedPin, motorSpeed);                
}                
          
void right(int motorSpeed) {                
 forward(in1, in2, motorSpeed, motorASpeedPin);                
 backward(in3, in4, motorSpeed, motorBSpeedPin);                
}             
             
void left(int motorSpeed) {                
 forward(in3, in4, motorSpeed, motorBSpeedPin);                
 backward(in1, in2, motorSpeed, motorASpeedPin);                
}             
             
void stopAll() {                
 digitalWrite(in1, LOW);                
 digitalWrite(in2, LOW);                
 digitalWrite(in3, LOW);                
 digitalWrite(in4, LOW);                
}               
           
void setup() {                
 for (int i = 3 ; i <= 5 ; i++) {                
   pinMode(i, OUTPUT);                
 }                
 for (int i = 7 ; i <= 9 ; i++) {                
   pinMode(i, OUTPUT);                
 }                
 Serial.begin(9600);                
 Serial.println("Please enter 'f' to run the motor FORWARD, or 'b' to run the motor BACKWARD");                
 Serial.println("or 'r' to run the motor RIGHT, or 'l' to run the motor LEFT, or 's' to STOP all motors. ");                
}               
           
void loop() {                
 if (Serial.available() > 0) {                
   val = Serial.read();                
 }                
 if (val == 'f') {                
   forward(in1, in2, 255, motorASpeedPin);                
   forward(in3, in4, 255, motorBSpeedPin);                
   Serial.println("forward");                
 }                
 if (val == 'b') {                
   backward(in1, in2, 255, motorASpeedPin);                
   backward(in3, in4, 255, motorBSpeedPin);                
   Serial.println("backward");                
 }                
 if (val == 'r') {                
   right(255);                
   Serial.println("right");                
 }                
 if (val == 'l') {                
   left(255);                
   Serial.println("left");                
 }                
 if (val == 's') {                
   stopAll();                
   Serial.println("stopAll");                
 }                
}                

Code Logic

inside the setup() function where we set up our program,

• set the pins 3, 4, 5, 7, 8, 9 as output pins.
• then start the Serial Communication between the Arduino and our computer at baud rate 9600 using the .begin() function.
• then print this sentence one the Serial monitor is opened “Please enter ‘f’ to run the motor FORWARD, or ‘b’ to run the motor BACKWARD or ‘r’ to run the motor RIGHT, or ‘l’ to run the motor LEFT, or ‘s’ to STOP all motors.“

void setup() {                
 for (int i = 3 ; i <= 5 ; i++) {                
   pinMode(i, OUTPUT);                
 }                
 for (int i = 7 ; i <= 9 ; i++) {                
   pinMode(i, OUTPUT);                
 }                
 Serial.begin(9600);                
 Serial.println("Please enter 'f' to run the motor FORWARD, or 'b' to run the motor BACKWARD");                
 Serial.println("or 'r' to run the motor RIGHT, or 'l' to run the motor LEFT, or 's' to STOP all motors. ");                
}               

Inside the loop() function, which is going to repeat over and over as long as our program is running. we just need to read the data coming from the Serial monitor if there’s any. Then store it inside the “val” variable which we created earlier.

if (Serial.available() > 0) {                
   val = Serial.read();                
 }   

after reading the data,

• if the received character is ‘f‘. call the forward function and print “forward” on the serial monitor to make the debugging process easier.
• the received character is ‘r‘ call the right function and print “right” on the serial monitor to make the debugging process easier.
• if the received character is ‘l‘ call the left function and print “left” on the serial monitor to make the debugging process easier.
• the received character is ‘s‘ call the stopAll function and print “stopAll” on the serial monitor to make the debugging process easier.
• if the received character is ‘b‘ call the backward function and print “backward” on the serial monitor to make the debugging process easier.

if (val == 'f') {                
   forward(in1, in2, 255, motorASpeedPin);                
   forward(in3, in4, 255, motorBSpeedPin);                
   Serial.println("forward");                
 }                
 if (val == 'b') {                
   backward(in1, in2, 255, motorASpeedPin);                
   backward(in3, in4, 255, motorBSpeedPin);                
   Serial.println("backward");                
 }                
 if (val == 'r') {                
   right(255);                
   Serial.println("right");                
 }                
 if (val == 'l') {                
   left(255);                
   Serial.println("left");                
 }                
 if (val == 's') {                
   stopAll();                
   Serial.println("stopAll");                
 }                
}                

After Uploading and Running the Code, you have to open the Arduino Serial Monitor from this pin.

Now, you should see this window

Now, type ‘f’ in the upper bar and press the ‘send’ button or just press enter. you will notice that your motors are now running forward.

CONGRATS! now you are able to control your motors from the serial monitor. Let’s go to the second step!

Second Part: Control the Two DC Motors from the Processing Control Panel GUI

Working Scenario

We will build a GUI control panel using Processing IDE to control the motors from it instead of the Serial Monitor. the way of communication between the Processing IDE and the Serial port(Arduino IDE) is also a Serial Communication. So, we will build our logic upon the same concepts that we discussed in part one. Luckily, Processing comes with a Serial library designed for just this kind of thing!

to be able to use the Serial communication on processing you have to set the speed at which your computer will communicate with the Serial port(Arduino IDE) which is called the baud rate. Remember how we set Serial.begin(9600) in Arduino? we will do the same thing with processing but with a little change in the syntax.

• First things first, you have to import the Serial library.

You should now see at the top of your sketch a line like

import processing.serial.*;

• The next line we need to take an object from the Serial class, i will name it “port” (you can name it as you want) this Serial object allows you to listen to any Serial communication incoming data.

Serial port;

For our setup() method in Processing, we’re going to find the Serial port our Arduino is connected to and set up our Serial object to listen to that port.

just like Arduino has setup() and loop(), processing has setup() and draw() (instead of loop)

For windows users, it will look something like this. you just have to change the “COM6” value according to your Arduino Serial port.

port = new Serial(this, "COM6", 9600);

How to know my Arduino Serial port?

For macOS or Linux users, it will look something like this. you just have to change the “/dev/tty.usbmodem143101” value according to your Arduino Serial port.

port = new Serial(this, "/dev/tty.usbmodem143101", 9600);

How to know my Arduino Serial port?

GUI: Working Scenario

Building the App GUI is pretty simple, we gonna divide it into three main parts to make it clear.

• Build the App Window.

Building the App Window means Defining the dimension of the display window width and height in units of pixels and setting its color. Also, we will create a simple text to place it on the top of the window as a title.

• Placing the buttons on the window.

After building the App window, we need to create five buttons and position them on the App window to allow the user to interact with the app easily, each button is responsible for sending a specific order to the Arduino board. For example, when the user presses the “forward” button the Processing IDE will send a specific character to the Arduino port via the Serial Communication. And according to this character, Arduino IDE will trigger a specific event (Rotating the motors forward).

• Buttons Functionality.

After placing the buttons correctly on the App Window, we need to give each button a functionality. which means a specific event will get triggered according to which button is clicked. enough talking, let’s build some stuff!

Build the App Window

void setup() {              
 size(500, 300);              
}              
void draw() {              
 background(150, 0, 150);              
 fill(255);              
 text("Motor Control GUI", 195, 30);              
}   

inside the setup() function

• We used the size(500, 300); Method to create the App Window with 500px width and 300px height.

inside the draw() function

• we used the background(150, 0, 150); method with these RGB values to set the background color of the Processing window, This method is typically used within the draw() function to clear the display window at the beginning of each frame.
• then we used the fill(255); method to set the color of any subsequent component to the white color.
• then we used the text("Motor Control GUI", 195, 30); method to create a text on the X-coordinate 195 and the Y-coordinate 30.

the coordinate system for pixels in a computer window, however, is reversed along the y-axis. (0,0) can be found at the top left with the positive direction to the right horizontally and down vertically. (See the next Figure)

Placing the buttons on the window

import controlP5.*;                  //import ControlP5 library              
              
ControlP5 cp5;                       //create ControlP5 object              
              
void setup() {              
 size(500, 300);              
 cp5 = new ControlP5(this);          //take an object from the ControlP5 Class            
              
 cp5.addButton("forward")            //add new button            
   .setPosition(190, 50)              
   .setSize(120, 70)                    
   ;                 
 cp5.addButton("backward")           //add new button                    
   .setPosition(190, 210)              
   .setSize(120, 70)                    
   ;              
 cp5.addButton("right")              //add new button                  
   .setPosition(350, 130)            
   .setSize(120, 70)            
   ;              
 cp5.addButton("left")               //add new button             
   .setPosition(30, 130)                
   .setSize(120, 70)                   
   ;              
 cp5.addButton("stop")               //add new button                 
   .setPosition(190, 130)                
   .setSize(120, 70)             
   ;              
}              
void draw() {              
 background(150, 0, 150);              
 fill(255);              
 text("Motor Control GUI", 195, 30);              
}    

we will use the ControlP5 library which allows us to add some buttons to our App, this library uses not limited on buttons only, it also gives you many more features like adding sliders, checkboxes, radio buttons, canvas, drop-down lists, …

installing any library in Processing is very simple, you just need to go to the sketch tab-> Import Library-> Add Library.

After this window appears, search for ControlP5, then select the ControlP5 library and press install. The installation process will take only a few minutes.

• Import the ControlP5 library to our sketch import controlP5.*;
• Take an Object from the ControlP5 class ControlP5 cp5; . I will name it “cp5” (you can name it as you want) this cp5 object allows you to use the ControlP5 library methods to add buttons, sliders, checkboxes, etc…

inside the setup() function

• Set up the cp5 object cp5 = new ControlP5(this);
• adding buttons using the ControlP5 library is very simple, you just need to use the .addButton("name") method to give it a name. and use the .setPosition(x, y) method to position it on the screen, and the .setSize(w, h) method to set its dimensions. that’s it.

Buttons Functionality

import controlP5.*;             //import ControlP5 library            
import processing.serial.*;     //import the Serial Library            
            
ControlP5 cp5;                  //create ControlP5 object            
Serial port;                    //create Serial object            
            
void setup() {              
size(500, 300);              
cp5 = new ControlP5(this);            
port = new Serial(this, "/dev/tty.usbmodem143101", 9600);            
            
cp5.addButton("forward")                  
  .setPosition(190, 50)              
  .setSize(120, 70)                    
  ;                 
cp5.addButton("backward")                    
  .setPosition(190, 210)              
  .setSize(120, 70)                    
  ;              
cp5.addButton("right")                  
  .setPosition(350, 130)            
  .setSize(120, 70)            
  ;              
cp5.addButton("left")             
  .setPosition(30, 130)                
  .setSize(120, 70)                   
  ;              
cp5.addButton("stop")                 
  .setPosition(190, 130)                
  .setSize(120, 70)             
  ;              
}              
            
void draw() {              
background(150, 0, 150);              
fill(255);              
text("Motor Control GUI", 195, 30);              
}             
             
void forward() {            
 port.write('f');            
}            
void backward() {            
 port.write('b');            
}            
void right() {            
 port.write('r');            
}            
void left() {            
 port.write('l');            
}            
void stop() {            
 port.write('s');            
} 

We will implement 5 different methods, one method for each button. the method name should be the same name as the button. this method will get called once the button gets clicked.

For Example, when we click the “right” button, the right() method will get called. So, the Processing IDE will send the character ‘r’ to the Arduino Serial port via Serial Communication.

How to use it

• Now all you have to do is to connect your Arduino board using the USB cable with your laptop and upload the Arduino code.
• Then run the Processing program and enjoy your Work!

Make it wireless

Voilaaa! Now we are able to control the Motors from Processing through the Serial Communication, but what about getting rid of the ugly USB cable. Cool, Right!

To make it wireless we will use the HC-05 Bluetooth module which has wide use, it can set as slave or master as well (unlike the HC-06 module which can work only as a slave) which means that you can make a Bluetooth connection between two different Arduino boards. the HC-05 Bluetooth module is an SPP (Serial Port Protocol) module, which means that it communicates with the Arduino board via Serial communication.

Circuit Diagram

Processing Code Modification (macOS & Linux)

we need to make a slight modification in our Processing Code, we need to update our port name "/dev/tty.usbmodem143101" to the new HC-05 port name.

port = new Serial(this, "/dev/tty.usbmodem143101", 9600);

• First, you need to pair your laptop with the HC-05, after powering up your Arduino board go to your Bluetooth preference on your laptop and pair with the Bluetooth module, if asked you for a passcode enter “1234”.

• Create a new Processing sketch and paste this code in the new sketch and run it, after running the program it will print all the available Serial Ports on the console, choose the HC-05-DevB port.

import processing.serial.*;          
Serial port;          
          
void setup(){          
 printArray(Serial.list());          
}          
void draw(){          
} 

So in my case, I will update this line

port = new Serial(this, "/dev/tty.usbmodem143101", 9600);

To

port = new Serial(this, "/dev/tty.HC-05-DevB", 9600);

Processing Code Modification (Windows)

• First, you need to pair your laptop with the HC-05, after powering up your Arduino board go to your Bluetooth preference on your laptop and pair with the Bluetooth module, if asked you for a passcode enter “1234”. the Bluetooth device needs to be set up to use a COM port, open up the Bluetooth settings and press More Bluetooth Options.

• Switch to the COM Ports tab and then press the Add button

• In the Add COM Port dialog select the Outgoing radio button. Choose the HC-05 device under Device that will use the COM Port drop-down and then click OK.

• It will assign the device to a COM port, click OK out of the Bluetooth settings

So, in this case, I will update this line

port = new Serial(this, "/dev/tty.usbmodem143101", 9600);

To

port = new Serial(this, "COM10", 9600);

How to use it?

• After uploading the code to the Arduino board, Remove the USB cable and power up the Arduino board using the external battery.
• connect with the HC-05 Bluetooth module from your laptop (passcode 1234).
• Modify the Processing Code Serial Port name According to your connected Serial Port name.
• Run the Processing Code, AND ENJOY PLAYING!

Thanks!

TADA, WE ARE DONE! if you have any questions, don’t hesitate to drop them in the comments section. And if you like this tutorial, send me some memes on my

The post Bluetooth-Controlled 2WD Robot appeared first on Make Some Stuff.