Arduino – Garage Door Indicator

First I would like to say thank you in advance for visiting my site.  My goal is to help anyone who loves to work with electronics.



1. Introduction

2. Bill of Material

3. Block Diagram

4. Schematics

5. Arduino Uno sketch and upload

6. ESP8266 sketch and upload

7. Final thoughts

8. Download original files


I don’t know about you guys but when it comes to closing my garage door I always seem to forget.  Most of the time I don’t even notice until the night before I head to bed.  I was getting tired of leaving it open so then I was inspired to create this project.

The garage door indicator project essentially sends you a text if the garage door is left open for more than 5 minutes.  It uses an arduino, ESP8266, and IFTTT to remind me that I left it open.

Lets get started!


Board Part Quantity Link
Arduino Board
 Arduino Pro Mini 1 Amazon
ESP8266 Board
ESP8266 ESP01 1 Amazon
RC1206JR-0710KL 4 Digikey
C1206C104K5RAC7867 2 Digikey
Boost Converter #1: Arduino Board
GRM21BR61E475MA12L 1 Digikey
MCP1640T-I 1 Digikey
GRM21BR61C106KE15K 3 Digikey
RC0805JR-07560KL 1 Digikey
TC33X-2-105E 1 Digikey
MSS5131-103ML 1 Coilcraft
Boost Converter #2: ESP8266
AAT1217ICA-3.3-T1 1 Digikey
GRM21BR61E475MA12L 1 Digikey
GRM21BR61C106KE15K 3 Digikey
RC1206JR-071ML 1 Digikey
MSS5131-472ML 1 Coilcraft
Switch: ESP8266 Power
DMG2305UX 2 Digikey / Arrow
2N7002-7-F 1 Digikey
RC1206JR-0751KL 1 Digikey
RC1206JR-0710KL 1 Digikey


Electronics - Garden_Block diagram_01

Here the block diagram gives you a general idea of how this is connected together. I’ve made this project very modular so upgrades and replacements are easy to do.  I decided to go with two boost converters because the ESP8266 has a lot of noise issues that always messed with my arduino board and so separating the supplies and the controllers from each other did the trick.


Below I’ve listed all the schematics that are associated with this design.  I’ve designed this project to be very modular because I CNC mill all the boards and it makes it a lot easier to work with.

If you click on the schematic images, i’ll take you to the pdf version that you can download.

Arduino nano board:

Arduino Board

ESP8266 Board:

Electronics - ESP8266 Board

Boost Converter #1:

Electronics - MCP1640

Boost Converter #2:

Electronics - AAT1217

Switch: ESP8266 Power:

Electronics - Switch ESP8266


Here is the arduino sketch used in the garage door project.  Essential the arduino nano is used to first sense the status of the garage door and second to wake up the ESP8266.

The way this sketch is written is the arduino is put into an 8 second sleep state because thats the longest the watchdog timer will fire.  This is then looped in that adds up to 5 minutes.

The reed switch is connected to the interrupt pin 2 on the nano and is used to wake up the arduino  when the door is open.  Then a counter will start counting and when 5 minutes are up that the door is left open, this will activate the switch that will turn on the ESP8266.

[code language=”cpp”]

#include “LowPower.h”

int ESP8266 = 10;

int Open = 2;

int x = 0;

void setup()







void loop()


// put your main code here, to run repeatedly:

// Low power sleep mode is used here to put the arduino

// in an 8s sleep state


if (digitalRead(Open) == HIGH)


x = x + 1;


// Here is the value entered that will

// set the time it takes for it to

// wake up the ESP8266

// 2 minutes = 15

// 4 minutes = 30

// 5 minutes = 39

// 10 minutes = 80

if ( x == 39)


digitalWrite(ESP8266, HIGH);



x = 0;


if (digitalRead(Open) == LOW)


x = 0;





All sketches and libraries will be attached in the links at the end of the post under download files


After the arduino nano is configured to wake up the ESP8266, the next thing we will do is load the sketch for the ESP8266.

Now before we go into the sketch, we first need to setup an account with  After that is done then we need to create a new applet.

IFTTT - New Applet

Next, we click on If this:

IFTTT - If this

Next, we search for webhooks service:

IFTTT - Webhooks

After that, we create the trigger.  Here we enter “Door” as our trigger:

IFTTT - Trigger

Now we need to create the action, in this case send a text when this is activated.  We click on THAT now:

IFTTT - That

We search for SMS and click on the first one:


We now set the action, leave it as is and click on create:


Then you click finish.

In case your phone number is not set, lets go to search:

IFTTT - sms_number.PNG

And we click on settings and edit.  Here you enter your phone number you wish to receive your text:


Now the last and most important part, we need to get your “mykey” needed to link ifttt with your esp8266.

We go to search again and this time type in webhooks.  Then you go to settings and you copy the highlighted key into your ESP8266 sketch:

IFTTT - Webhooks_mykey

Now you are ready to continue to the sketch.

Here is the sketch for the ESP8266.

Original sketch was taken from this link and modified slightly for my project.

[code language=”cpp”]


// Name: Steven Guzman

// Date: 12/13/2017

// Description: ESP8266 code for sending a message over to IFTTT that the garage door is open


#include <ESP8266WiFi.h>

#include <arduino.h>

#include <SPI.h>

#include “DataToMaker.h”

#define SERIAL_DEBUG // Uncomment this to dissable serial debugging

// Define program constants

const char* myKey = “”Enter your key right here”; // your maker key here

const char* ssid = “Enter your SSID wifi name here”; // your router ssid here

const char* password = “Enter your password here”; // your router password here

// declare new maker event with the name “ESP”

DataToMaker event(myKey, “Door”);<span data-mce-type=”bookmark” id=”mce_SELREST_start” data-mce-style=”overflow:hidden;line-height:0″ style=”overflow:hidden;line-height:0″ ></span>


bool connectedToWiFI = false;

void setup()








delay(10); // short delay




void loop() {

if (wifiConnected)



if (event.connect())


if (digitalRead(2) == HIGH)


event.setValue(1,”Garage Door is Open, close it NOW!!”);

debugln(“Connected To Maker”);;


if (digitalRead(2) == LOW)


event.setValue(1,”Garage Door is Closed”);

debugln(“Connect to Maker”);;



else debugln(“Failed To Connect To Maker!”);

delay(5000); // pause for 1 second




delay(60 * 1000); // 1 minute delay before trying to re connect




bool ConnectWifi()


// Connect to WiFi network



debug(“Connecting to “);


unsigned long startTime = millis();

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED && startTime + 30 * 1000 >= millis()) {




if (WiFi.status() == WL_CONNECTED)



debugln(“WiFi connected”);






debugln(“WiFi Timed Out!”);



bool wifiConnected()


return WiFi.status() == WL_CONNECTED;


void debug(String message)






void debugln(String message)






void debugln()







Here is the second file needed for the ESP8266:

[code language=”cpp”]

#include <Arduino.h>

#include <ESP8266WiFi.h>

#ifndef DataToMaker_h

class DataToMaker



DataToMaker(const char*, String); // constructor

bool connect();

bool setValue(int, String);

void sendToMaker();

void post();

protected: // it is protected because the subclass needs access

//to max distance!


void compileData();

WiFiClient client;

const char* privateKey;

String event;

String value1, value2, value3 = “”;

bool dataAvailable;

String postData;


DataToMaker::DataToMaker(const char* _privateKey, String _event)


privateKey = _privateKey;

event = _event;


bool DataToMaker::connect()


if (client.connect(“”, 80))

return true;

else return false;


void DataToMaker::post()



client.print(“POST /trigger/”);




client.println(” HTTP/1.1″);


client.println(“User-Agent: Arduino/1.0”);

client.println(“Connection: close”);

if (dataAvailable)

{ // append json values if available

client.println(“Content-Type: application/json”);

client.print(“Content-Length: “);








bool DataToMaker::setValue(int valueToSet, String value)


switch (valueToSet)


case 1:

value1 = value;


case 2:

value2 = value;


case 3:

value3 = value;



return false;



return true;


void DataToMaker::compileData()


if (value1 != “” || value2 != “” || value3 != “”)


dataAvailable = true;

bool valueEntered = false;

postData = “{“;

if (value1 != “”)




valueEntered = true;


if (value2 != “”)


if (valueEntered)postData.concat(“\”,”);



valueEntered = true;


if (value3 != “”)


if (valueEntered)postData.concat(“\”,”);






else dataAvailable = false;


#endif<span data-mce-type=”bookmark” id=”mce_SELREST_start” data-mce-style=”overflow:hidden;line-height:0″ style=”overflow:hidden;line-height:0″ ></span>


Make sure to place the datatomaker file code above in the same directory as the ESP8266 code.


Here is the final project assembled:


This project was not designed to be pretty but since I used my CNC machine to mill out the boards I was limited to the one side.  There is an upside to designing it this way, if one or two of the boards happen to malfunction, you can switch it out.  Or if you ever need to upgrade, you can easily swap out what you need to upgrade.

I’m planning on making a professional board and consolidating the boards into one or two boards in the future but for now I’m happy with the results.

If you have any questions please feel free to comment or if you find an error or an issue with anything posted please let me know and I’ll correct it.



Project files




The arduino platform is one of the biggest and most popular platforms used for prototyping.  One of the most popular Arduino boards is the Arduino Uno and for good reasons because its very intuitive and easy to use with plenty of IO pins and analog pins.

With the Arduino uno having 28-pins, sometimes your design or project will only require a handful of IO pins and will need to be crammed into a small board.  That’s when the ATTINY85 IC comes to the rescue.

The ATTINY85 is a low-power, 8-bit AVR microcontroller.  Its a great little micro controller that can be programmed with Arduino, though it does have its limitations like a smaller 8kB flash memory instead of the Arduino uno 32kB.  Its is still a great alternative for small not so code intensive projects.

Along with having a small package, if you run this off battery you want to make sure it’ll last more than a couple of days.  To fix this issue, we can implement a sleep cycle and wake it up using a watchdog timer that’ll make it last for easily over a year on 2 AA NiMh batteries.  Below I’ll add the sleep code you can paste into your own to add a sleep function to your ATTiny85 projects.


  • x1 ATtiny85 – Link
  • x1 Arduino Uno – Link


Below is a general wire diagram for connecting the Arduino Uno and the ATtiny85 in order to upload your program.  Unlike the Atmega328P used on the arduino, the ATtiny85 does not require a special boot loader in order to upload Arduino code.

Blog - ATtiny85_Arduino

Here is a schematic version below:



The next step is to download the libraries for the ATtiny85.

Go to file -> Preferences

Under Additional Boards Manager URLs copy and paste this link:


Then click ok.

Next, go to tools -> Board -> Boards Manager

Board Manager

Next, type in ATtiny85 on the search bar and install the ATTinyCore by Spence Konde.  Select the newest version available.


Now that you have the libraries installed for the ATTiny85 IC, you next need to setup your Arduino uno to be an ISP programmer to upload your code to the ATTiny85.


Once you’ve opened up that example code, you upload that sketch file into your arduino.

Next step is to choose the right board before uploading.

REMEMBER TO SELECT ARDUINO AS ISP UNDER PROGRAMMER or your code will not upload to the Attiny85.


The last step before being able to upload your code to the ATTiny85 is to make sure your settings in the image above are exactly the same.


[code language=”css”]


/// Title: Auto Garden Project (Tiny) //

/// Author: Steven Guzman //

/// Date: 5/11/17 //

/// Description: This code can be added to any ATTiny85 project in order to put it into //

/// a sleep cycle //


#include <avr/sleep.h>

#include <avr/wdt.h>

int watchdog_counter = 0; // Used for looping the watchdog timer



watchdog_counter++; // Increments the watchdog timer counter


void setup()


set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Power down everything, will only wake up from WDT

sleep_enable(); // Enable sleep


void loop()


ADCSRA |= (1<<ADEN); // Turns on ADC in order to read analog values

// 15 = 2 minutes

// 37 = 5 minutes

// 75 = 10 minutes

// 112 = 15 minutes

// 255 = 30 minutes

// Loops the 8 second internal to extend the sleep state

while (watchdog_counter < 15)



ADCSRA &= ~(1<<ADEN); // Turns off the ADC sleep_mode(); } watchdog_counter = 0; } // This is creating the back end code for running the sleep // function of the ATTiny85. The longest sleep cycle is // 8s //From: // 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms // 6=1 sec,7=2 sec, 8=4 sec, 9= 8sec void setup_watchdog(int ii) { byte bb; int ww; if (ii &amp;gt; 9 ) ii=9;

bb=ii < 7;

if (ii > 7) bb|= (1<<5);

bb|= (1<<WDCE);


MCUSR &= ~(1<<WDRF);

// start timed sequence

WDTCR |= (1<<WDCE) | (1<<WDE);

// set new watchdog timeout value

WDTCR = bb;




For some reason the html code doesn’t properly convert the characters, I’ve attached the arduino file here.


Now that you have the code ready. The next thing is to upload your code into the ATTiny85. Simply click on the right arrow in the tool bar and it’ll start uploading.



Hopefully this helped you guys learn how to easily use an ATTiny85 with your Arduino code.  They are a little limited in what they can do but if your project is not that complicated and you need to save space then this is the micro controller for you.

Please leave me any comments below let me know what you think.


1. Microchip

2. Big Dan the Blog Man

3. Renewable Energy Innovation

Arduino: WiFi Temperature Data Logger



Lets build a WiFi temperature data logger!!  The reason this project came to mind was because I needed to monitor the temperature of an outside enclosure box that will eventually house a couple of lithium ion batteries.  Can’t have the box get too hot or else we will end up having a nice backyard campfire.

This temperature data logger consist of three sections:

  1. The WiFi web server
  2. The temperature sensor
  3. The sleep controller

Lets get into the project now 🙂

Schematics, PCB, Arduino Libraries can be downloaded Here

Bill of Materials

  • x1 ESP8266 – Link
  • x1 Barometric (BMP180) – Link
  • x1 Atmega328P-PU – Link
  • x1 FTDI to Serial Converter – Link
  • x1 2N7002 – Link
  • x1 DMG2305UX-7 – Link
  • x7 10k Resistor 1206 – Link
  • x3 0.1uF Capacitor 1206 – Link
  • Female Headers – Link
  • x1 28 pin DIP Socket – Link
  • x1 PCB Terminal block – Link
  • x1 3.3V Boost Converter – Link


I’ve designed this project to consist of two microcontrollers.  Its not the most efficient way of doing it but it is effective.  The heart of this project is the ESP8266-ESP01 IC.  It will take in the data from the BMP180 sensor over I2C and send the data over to a web hosting site


Webserver - Schematic

The schematic is not that all complicated but it is very effective at trying to save as much battery as possible and deliver my data for viewing purposes.

In order to have this be powered by 2x AA batteries and last longer then a couple of days or weeks, I needed a couple of things to make this possible which is where the second microcontroller comes into play.

First, we need to make sure we have a stable power supply that can provide up to at least 0.3A and have a minimum quiescent current in the low uA range.

Before we get started into writing the code on the ESP8266 we need to set up an account at thingspeak.

Blog - Thingspeak

Click on the signup and fill out the information:

Blog - Thingspeak_2

Click on new channel:

Blog - Thingspeak_3

The most important information to fill out is the fields, in our case we will fill out field 1 and type in temperature.  The name could be any name you want, for this purpose we will write Temperature Data Logger. Once finish, scroll down and click save.

Blog - Thingspeak_4Blog - Thingspeak_5

The final piece of information we need is the API key, for this just click on the API Keys button and copy the Write API Key.

Blog - Thingspeak_6

Now we can move on to the code.

Click here for step by step on installing the ESP8266 arduino addon.[3]

ESP8266 Code

[code language=”css”]


// Name: Steven Guzman //

// Date: 4/4/2017 //

// Description: Temperature webserver that will update every 30 minutes to //

// thinkspeak with data that shows the temperature of the inside //

// of the enclosure. //


#include <ESP8266WiFi.h&>

#include <Wire.h>

#include <SFE_BMP180.h>

SFE_BMP180 pressure;

char status;

double t, tf;

// Replace with your channel’s thingspeak API key

String apiKey = “”;

// Enter your wifi information below

const char* ssid = “”;

const char* password = “”;

const char* server = “”;

WiFiClient client;

void setup()




// Pin 0 = SDA

// Pin 2 = SCL





Serial.print(“Connecting to “);

while (WiFi.status() != WL_CONNECTED)






Serial.println(“WiFi Connected”);

// Initialize the sensor

if (pressure.begin())


Serial.println(“BMP180 init success”);




Serial.println(“BMP180 init fail\n\n”);



// Print the IP address

Serial.print(“Use this URL to connect: “);





void loop()


// This starts the BMP180 sensor and takes a reading

status = pressure.startTemperature();

if (status !=0)



status = pressure.getTemperature(t);


// Converts Celsius into Farenheid

tf = (9.0/5.0)*t+32.0,2;



char t_buffer[10];

// This will convert the double variable into a string

String temp=dtostrf(tf,0,5,t_buffer);

String postStr = apiKey;

postStr +=”&field1=”;

postStr += String(temp);

postStr +=”\r\n\r\n”;

client.print(“POST /update HTTP/1.1\n”);


client.print(“Connection: close\n”);

client.print(“X-THINGSPEAKapiKey: “+apiKey+”\n”);

client.print(“Content-Type: application/x-www-form-urlencoded\n”);

client.print(“Content-Length: “);




Serial.print(“Temperature: “);










Arduino Code

[code language=”css”]


/// Title: Auto Garden Project //

/// Author: Steven Guzman //

/// Date: 4/6/17 //

/// Description: This project will automatically water a plant when the sensor reads low //

/// water levels in the soil. If sensor reads low water, it will turn on //

/// boost converter that controls the solenoid valve and then turn on the //

/// solenoid valve control circuit to allow water to flow into the soil. //


#include <LowPower.h>

int ESP1 = 2; // Turns on sensor; set to low for battery consumption purposes (Active High)

void setup()


pinMode(ESP1,OUTPUT); // Configure sensor control as output

digitalWrite(ESP1,LOW); // Setup as low output



void loop()


digitalWrite(ESP1,HIGH); // Turns on the ESP8266

delay(15000); // 15 second delay

digitalWrite(ESP1,LOW); // Turns off the ESP8266

// Loops the 8 second internal to extend the sleep state

// 15 = 2 minutes

// 37 = 5 minutes

// 75 = 10 minutes

// 112 = 15 minutes

// 255 = 30 minutes

for(int x = 0; x <= 255; x++)








First things first, we will upload the code to the ESP8266-ESP01.  This one is a little bit tricky but after awhile you’ll get the hang of it.

You need to make sure your settings are correct under the Arduino IDE.

See image below:

Arduino ESP8266 settings

Here’s the wiring diagram for connecting the FTDI programmer to the ESP8266:

Blog - ESP8266_WIRING

Now that your settings are correct, this is were it gets a little tricky to upload the code, you need to follow the steps below in order to upload correctly and successfully

Before hitting upload:

  1. Ground GPIO0 (hold down the push button JP2)
  2. Reset by pulling RST pin to ground (Press and release JP1 button)
  3. Once it restarts, hit the upload sketch icon
  4. When you see compiling sketch switch to uploading, then release the GPIO0 pin
  5. uploading should begin

Next, we will upload the second code into the ATmega328 which has the lilypad bootloader installed ( Click HERE [2] for tutorial on flashing ATMEGA328P-PU with bootloader).

See image below for settings:

Blog - ESP8266

Final Thoughts and Future updates

And now the final product:

Blog - Thingspeak_graph

Its not the most elegant but I actually used my CNC machine to make these boards, in the future I might get them professionally made but for now its perfect for me.

Future Updates:

  1. Replace the ATMEGA328P-PU IC with a smaller ATTINY85 which can also be flashed with the Arduino bootloader
  2. Connect the Arduino to the I2C communication lines to expand its data logging capability
  3. Since this is running on 2x AA NiMH batteries, it would be great to monitor battery capacity.  We can use one of the analog pins on the arduino to read the data and send it over I2C to the ESP8266

1. Arduinesp

2. ATMEGA328 Bootloader

3. ESP8266 installation

Boost Converter – 3.3V@ 0.4A


Its time to show you my 3.3V output boost Converter design. In one of my earlier post I showed you step by step on how to design your own boost converter and if you haven’t read that yet then click here.

You can purchase this board fully assembled by clicking here. 🙂

Lets get started:


First of all, why do we even need this converter? Well every sensor, microcontroller, arduino, ESP8266, and various other digital components need a constant voltage.  A constant voltage is necessary to maintain proper operation of these components.

Here we will see the advantage of this boost converter.


Below are the operating specs for this converter

\Huge \bold V_\text{IN} = 1.8V - 2.4V

\Huge \bold V_\text{OUT} = 3.3V 

\Huge \bold I_\text{OUT} = 0.4A 

  • Note: Different Vin voltages gives you different max power output
    • \Huge \bold V_\text{IN} = 1.8V @ I_\text{OUT}: 0.2A
    • \Huge \bold V_\text{IN}: 2.0V @ Iout: 0.3A
    • \Huge \bold V_\text{IN}: 2.4V @ Iout: 0.4A

\Huge \bold V_\text{P-P} = 80mV 

Bill of Materials.

Here is a screenshot of the bill of materials.  I added the suppliers on the spreadsheet because I’ve found that some sites have better pricing than others.

Using, you can actually find the best value for the component you’re looking for.  I highly suggest you go look at the site.

BOM - L6920


Attached here is the schematic for this project.  All the original files are available for download at the bottom of the page.



I figure I’d help you guys out a bit if I added the layout for this board.  My approach for this layout was to minimize the overall size in order to get a better price for manufacturing the board.



Here comes the fun part, actually testing what you designed.  Now one thing that took me awhile to learn was that design and theory never really match reality.  There are a lot of different parameters that are not accounted for when designing in theory.

A couple of the major issues that could make or break your design is parasitic elements.  One of the biggest parasitic elements is ESR for output capacitors.  This is the equivalent series resistance of the capacitor that is not taking into account when designing.  In my post that covers the design of a boost converter, I emphasizes this topic to make you aware of this parasitic element.

Now, my design parameters consisted of loading the converter at 3 different voltage inputs (1.8V, 2.0V, and 2.4V).  Each input voltage was loaded starting at 0.1A and ending at 0.4A.  This load all depended on which input voltage was tested because the lower input voltage cannot provide the max output power.

First test – Vin: 1.8V @ 0.2A

Will add soon.

Next test – Vin: 2.0V @ 0.3A


Last test – Vin: 2.4V @ 0.4A


After completely the voltage ripple test, I also conducted a load regulation test at max load for each input voltage.  I got a 1.5% voltage drop from calculated voltage meaning at full load, my output voltage was 3.25V at the lowest.


Order from OSH Park

All files available here – Click

NMOS & PMOS: Useful Applications


Transistors, specifically MOSFETs, I would say are the second most important component to an EE designer next to the passive compoents (resistors, inductors, capacitors).

I will show you a few useful applications that can be applied using MOSFETs that anyone working in electronics should have in there arsenal.

First lets briefly look at the two variations of MOSFETs.

You have the N-Channel MOSFET below:


Then, you have the P-Channel MOSFET below:

Image - PMOS.png

They have some minor differences in the way they are made and how they are used but in essences they have the same function and operate the same.

Every MOSFET has a Gate-source threshold voltage \Huge (V_\text{GS}).  This is the most important part of the FET because in order to turn on the MOSFET you need to apply a voltage at the gate that exceeds this threshold voltage.  In the datasheet of the MOSFET, you can find this value.

Now, onto the main event:

1. Using them as digitally controlled switches.

One of the most common uses for these FETs is to use them as switches.  When working with electronics, especially with battery operated electronics, you sometimes need to control when certain sensors are turned on or control when certain components get powered on in order to conserve battery power.

Here comes the FETs to the rescue.

You have two ways of accomplishing this task, using either the NMOS or the PMOS.

Note: When using MOSFETs with digital electronics, make sure you get a logic level mosfet.  Meaning that the on voltage for Vgs is between 2V-5V.

Using the NMOS, this is considered LOW SIDE switching because the source pin is connected to ground.


Using the PMOS, this is considered HIGH SIDE switching because the source pin is connected to the device/component instead of ground.


2. Using them as logic level converters[1]

This one mostly applies to the NMOS MOSFET, I haven’t seen a configuration out there with PMOS.

Nowadays with DIY electronics being more and more popular and with a larger community of makers, you have a huge variety of microcontrollers and sensors to make the next big product. With this variant comes a variety of components with different supply voltages, ranging down from 1.8V up to 5V.  The issue with this is trying to match sensor supply voltages with your microcontroller when it comes to communicatong via I2C or SPI or even a single 1 or 0 signal. If you supply a sensor or IC with a higher signal voltage than it can handle you risk damaging the component and rendering it useless.

Here comes the NMOS to the rescue. With an NMOS you can fix this issue by making a 5V to 3.3V logic level shifter to communicate with each other while avoiding any damage.



3. Making a constant current source.

This is one is my favorite application using MOSFETs.  For me I do a lot of testing of DC DC Converters to make sure it meets my design specifications and one test requires I have a constant current that will not fluctuate.  Using this design I am able to set the desired current for my test.

Another application is used for LEDs.  LEDs are a lot different that traditional light bulbs in that instead of operating off a voltage rating, they operate at a current rating.  Essentially you need to maintain a constant current applied to the LED to achieve your desired brightness.


These are some of the three uses for MOSFETs that I normally deal with for my projects.  There’s plenty more but these were my top 3.

If you have any questions, input, corrections, please let me know in the comments below.

Enjoy building :)!


1. Bi-Directional Level Shifting

2. Sparkfun Learning

How-to: Design a Boost Converter

Figure 1: Basic Boost Converter Circuit


Designing a boost converter sounds complicated and intimidating, well that was always my impression when it came to this topic in school.  In reality, the design and testing of a boost converter is a lot easier than meets the eye.

Here I will walk you step by step on designing your first boost converter and how the datasheet is your best friend when designing.  For this tutorial we will be using the L6920DC IC Boost converter from skyworks.[1]

Download the Boost Converter excel spredsheet from the Resources page.

This information was referenced from TI reference report.[2]

First and foremost, download the highlighted datasheet, datasheet-l6920dc. This has all the highlighted paremeters that you will need when designing a boost converter.

Step 1:

You need to decide what are your specifications.  These are the key parameters:

  • Vin(min)
  • Vin(max)
  • Vout
  • Iout
  • n = efficiency; Most boost converters average around 85 to 90% under medium load and up to 95% on heavy load.  We will use the lowest percentage to be safe.


  • Vin(min): 1.8V
  • Vin(max): 2.4V
  • Vout: 3.3V
  • Iout: 0.4A
  • n = 87% or 0.87

Step 2:

With your specifications, next step is to find your DUTY CYCLE:

\bf \Huge D= 1 - \cfrac{(V_{\text{IN}}*n)}{V_{\text{OUT}}}

We calculated the duty cycle for both lowest input voltage and highest input voltage.

  • Lowest input voltage gives you the highest switching current you will see
  • Highest input voltage gives you the highest output current your converter can produce


\bf \Huge V_{\text{IN-MIN}}

\Huge D = 1 - \cfrac{1.8V*0.85}{3.3V} = 0.52

\bf \Huge V_{\text{IN-MAX}}

\Huge D = 1 - \cfrac{2.4V*0.85}{3.3V} = 0.36

Step 3:

Next we will estimate the switching current or CURRENT RIPPLE of the Inductor:

ΔIL = (0.3) * I_\text{OUTmax} * \cfrac{(V_\text{OUT})}{(V_\text{IN})}


\bf \Huge V_{\text{IN-MIN}}

ΔIL = \Huge  (0.3) * 0.4A * \cfrac{3.3V}{1.8V} = 0.22A

\bf \Huge V_{\text{IN-MAX}}

ΔIL = \Huge  (0.3) * 0.4A * \cfrac{3.3V}{2.4V} = 0.165A

Step 4:

Next we calculate the minimum INDUCTANCE we need:

\bf \Huge L_\text{MIN} = \cfrac{(V_\text{IN})*(V_\text{OUT} - V_\text{IN})}{\Delta I_\text{L}*f_\text{S}*V_\text{OUT}}

\bf \Huge f_\text{S} – This is the switching frequency that the converter will operate at.


\bf \Huge V_{\text{IN-MIN}}

\Huge L_\text{MIN} = \cfrac{(1.8V)*(3.3V - 1.8V)}{0.22A*1MHz*3.3V} = 3.72uH

\bf \Huge V_{\text{IN-MAX}}

\Huge L_\text{MIN} = \cfrac{(2.4V)*(3.3V - 2.4V)}{0.165A*1MHz*3.3V} = 3.97uH

We would select the highest inductance value to meet our input voltage rage of 1.8V-2.4V

When selecting the inductor, the key parameters you need to look for is low DCR, package size, and max current the inductor can handle.

DCR – Is the resistance in the coil because at the end of the day, an inductor is still a wire. When you keep this value at a minimum, it will increase your effieciency and the ability to provide a higher output power.

In step 7 , you will calculate the maximum current the inductor will see and there you will have all the necessary parameters needed to chose the inductor.

Step 5:

Now that we have our inductor value, we can calculate the actual CURRENT RIPPLE of the Inductor:

ΔIL = \bf \Huge \cfrac{V_{IN}*D}{f_\text{S}*L}


\bf \Huge V_{\text{IN-MIN}}

ΔIL = \Huge \cfrac{1.8V*0.525}{1MHz*3.72uH} = 0.19A

\bf \Huge V_{\text{IN-MAX}}

ΔIL = \Huge \cfrac{2.4V*0.36}{1MHz*3.97uH} = 0.18A

Step 6:

Next we need to calculate the MAX OUTPUT CURRENT the boost converter can output:

\bf \Huge I_\text{MAXOUT} = \bf  \Huge (I_\text{LIM} - \cfrac{\Delta I_\text{L}}{2}) * (1 - D)

I_\text{LIM} – This is the current switch limit of the boost converter.


\bf \Huge V_{\text{IN-MIN}}

\Huge I_\text{MAXOUT} = \bf  \Huge (0.8A - \cfrac{0.19A}{2}) * (1 - 0.52) = 0.33A

\bf \Huge V_{\text{IN-MAX}}

\Huge I_\text{MAXOUT} = \bf  \Huge (0.8A - \cfrac{0.18A}{2}) * (1 - 0.36) = 0.45A

Step 7:

Next we will calculate the MAX SWITCHING CURRENT, I_\text{SW} the Inductor will see.  This value cannot exceed the ILIM value of the boost converter:

\bf \Huge I_\text{SW-MAX} = \cfrac{\Delta I_\text{L}}{2} + \cfrac{I_\text{OUT}}{1 - D}


\bf \Huge V_{\text{IN-MIN}}

\Huge I_\text{SW-MAX} =  \cfrac{0.19A}{2} + \cfrac{0.4A}{1 - 0.525} = 0.94A

\bf \Huge V_{\text{IN-MAX}}

\Huge I_\text{SW-MIN} =  \cfrac{0.18A}{2} + \cfrac{0.4A}{1 - 0.36} = 0.72A

Note: \Huge I_\text{SW-MAX} value cannot exceed \Huge I_\text{LIM} which can be found in the datasheet.  In this example we see that with a low input voltage, the switching current exceeds the limit in the datasheet.  The boost converter might still be able to output the desired current at that low input voltage because \Huge I_\text{LIM} is the minimum switching current it can handle.  But better to be safe than sorry.

Here you can see the inductor will see a max of 0.94A at its lowest input voltage. Now we can chose the inductor for our design.

For this design I went with,MSS5131-472MLB, a 4.7uH inductor from coilcraft.[3]

Since I chose an inductor that has a higher value than previous calculated, the inductor current ripple and output power will be slightly lower but it will not effect your design negatively.

Step 8:

This step is only if your boost converter has an adjustable output voltage.

(This boost converter is a fixed output and does not require these resistors.  Step 8 values are dummy values but the process )

Here we will find R1 AND R2 values for the feedback network:

\bf \Huge I_\text{R0.5} >= 100 * I_\text{FB}

\bf \Huge I_\text{FB} – This is the current that the feedback resistor draws.

\bf \Huge R_2 = \cfrac{V_\text{FB}}{I_\text{R0.5}}

\bf \Huge V_\text{FB} – This is the feedback reference voltage

\bf \Huge R_1 =  R_2 * (\cfrac{V_\text{OUT}}{V_\text{FB}}-1)


\Huge I_\text{R0.5} >= 100 * 350nA = 35mA

\Huge R_2 = \cfrac{1.24V}{35mA} = 35.4kΩ

\Huge R_1 =  35.4k \Omega * (\cfrac{3.3V}{1.24V}-1) = 58.74kΩ

Step 9:

Next l, we will calculate the INPUT CAPACITOR and OUTPUT CAPACITOR needed to minimize the ripple going in and out of the system:

First, you find your input capacitor:

\bf \Huge C_\text{IN}: Typically this value is 4.7uF to 10uF

Next, we need to first to look at these two equations below[6]:

\bf \Huge \Delta V_\text{OUT}= \cfrac{I_\text{OUT} *T_\text{ONmax}}{ C_\text{OUT}}

\bf \Huge T_\text{ONmax} – This is the maximum on time of the boost converter.  It is also written as

\bf \Huge D * T_\text{S}

Were \bf \Huge T_\text{S} = \cfrac{1}{f_\text{S}}

\bf \Huge \Delta V_\text{OUTesr} = ESR* I_\text{SW-MAX}

ESR – All capacitors are not ideal capacitors and therefore have what is known as Equivalent Series Resistance. This is an important parameter that you need to consider when choosing the right output capacitor.


Cin = 10uF

First, we need to choose a voltage ripple that we can live with. Here I chose 50mV, and if we rearrange the first equation, we get:

 \Huge \Delta C_\text{OUTmin}= \cfrac{0.4 *6.25us}{50mV} = 50uF

Now we have a couple of options to choose from when it comes to materials for capacitors.

Most common are ceramic and electrolytic capacitors.  Each have there own pro and con.

Ceramic capacitors offer lower ESR for lower ripple but they typically do not have the bulk capacitance.

Electrolytic capacitors have bulk capacitance but generally have a high ESR that adds to ripple.

In this case I decided to go with both, getting the benefit of bulk capacitance and low ESR.

I went with a 1206 package, 10uF ceramic capacitor and a 47uF Electrolytic in parallel. For the electrolytic, they also have an aluminum polymer that has high capacitance with the added benefit of low ESR. I went with a 47uF that has an ESR of 40mΩ.

Now we plug in the values we got back into the equations and we get:Special Note: For ceramic capacitors, you need to be careful of which class and package size you choose because you only see a certain percentage of your nominal value (ex. 1206 10uF X7R will see 73% of 10uF)[4]. Click here for more info. I generally go with 1206 or 1210 with capacitors.

\Huge \Delta V_\text{OUT}= \cfrac{0.4A * 6.25us}{50uF} = 50mV

\Huge \Delta V_\text{OUTesr} = 40m\Omega*0.94A = 37mV

\Huge \Delta V_\text{OUT} = 87mV

Always refer to the datasheet and compare recommended value vs calculated[1]

You’ve now designed your own boost converter regulator.  See it wasnt too hard :).

I will post this project soon that has the schematic and bill of materials, it’ll be under the projects menu bar, stay tuned!!

Feel free to comment below and correct me if anything seems incorrect to you.


1. L6920 Datasheet

2. TI Basic Calculations of a Boost Converter Power Stage

3. Coilcraft Inductor

4. Temperature and Voltage Variation of Ceramic Capacitors

5. Ceramic or electrolytic output capacitors

in DC/DC converters—Why not both?

6. Boost Converter Output Capacitor Selection