2021/05/04 (version A4)

  1. Replaced P102,P104 pads with high current part# 7460305
  2. Added R107 (300k) and C104 (330pF) for better stability by lowering the gain

Update (All updates are already included in the github files, link at the end):

  1. Updated R104, R105 to resistor value 470ohms for better reverse current protection threshold
  2. Updated R101 to resistor value 16ohms for better stability


What is an ideal diode? An ideal diode operates exactly as a traditional blocking diode that’s used to reverse current protection for a power path to protect the source from become the load and absorb power.

The only downside to using a diode is the power loss since most Shottky diodes, which is the a type of diode used primarily in power circuits, have a minimum voltage drop of 0.4V to allow current flow. This is an issue if you are trying to pass 50A through the diode which is a power loss of 10W which is a significant on design to eliminate that much heat from the diode.

The solution is to use is to use the ideal diode as a replacement for the Shottky diode. The ideal diode in summary is a linear op amp driving a mosfet with a low RDson internal resistance to turn on when current is flowing to the load and turn off when current tries to flow back to the source.


Why is this circuit used and why is it needed?

The primary reason why I looked into this and designed this circuit was to have the ability to parallel multiple battery banks without having to worry if one of the banks ended up shorting out or having some fault that triggered the BMS system to turn off that particular bank.

This circuit is also known as an OR-ing diode because it allows the use of multiple parallel sources to help drive the load and the load alone. If one source has an issue then it can be removed without having to turn off the system to do so and in the case of a battery bank, it keeps it from either being charged from the other batteries in parallel in case of an over voltage condition and it keeps it from discharging to other banks in case of an under voltage condition.


How is this circuit made? Below I’ve created a discrete ideal diode using an op amp for driving and a Mosfet as the diode switch.


  • Vinmin: 14V
  • Vinmax: 36V (This is limited by the mosfet and tvs diode, change those parts to increase input voltage range)
  • Imax: 30A ( This is dependent on the mosfet that is chosen, this rating is without a heatsink. I will perform test when I receive the actual boards as I used 2oz copper and should be able to handle more current without an issue. In theory this mosfet should be able to handle 400A with a proper heatsink)





Below I also simulated the circuit and you can see what both the sources share the current when they are equal in voltage. But when source “BAT01” drops in voltage, which simulates either a faster discharge on that parallel cell or the bms turned off the battery pack due to a fault event, source “BAT02” is now providing all the current to the load. You can see that BAT01 ideal diode is blocking the current from charging the battery which is known as reverse current.


I’ve uploaded all the files, which included sources files and gerber, on my github below:

CLICK HERE for github link.



Continue reading

Arduino 4S BMS (Version 7)


Like my previous post about this project, this is a customizable arduino based 4S BMS system. This is now version 7 of hardware and version 21 of software.

The benefit of using this over other low cost solutions is that gives a lot more feedback about what exactly its doing and control over how its doing it. For example setting the limit for the over voltage protection and under voltage protection value.


Here is a couple pictures of my BMS in action on a 4S11P 18650 pack.


Now to the key features that makes this project different from the rest:

  1. Adjustable voltage tolerance (maximum difference between cells)
  2. Display individual voltage cell values on an oled i2C display and/or serial print monitor over UART (TX, RX, GND)
  3. Set under-voltage protection value and over-voltage values for series MOSFET
  4. Adjustable balance current with a swapping of drain resistor up to 1A safely
  5. Serial commands for adjusting variables and feedback:
    1. Under voltage protection value
    2. Over voltage protection value
    3. Cell voltage tolerance
    4. Request calibration values
    5. Request status of UVP and OVP event and reset if triggered
    6. Enter calibration mode to re-calibrate if needed for ADC inputs


Schematic and original kicad files

Arduino Code

NOTE: Arduino BMS A7 hardware is supported only with the current arduino software


Now lets look into the hardware for this. There are 5 important sections in this board:

  1. Power Section
  2. MCU: Arduino ATMEGA328P running at 8MHz with minicore bootloader
  3. Reference 1.25V voltage for ADC
  4. Voltage dividers for cell measurement into ADC
  5. Balance Section
  6. Series MOSFET Section


One of the most important sections in this project is the power section. Key features I was looking for was low Quiescent current because this will be battery operated.

Quiescent current is the amount of current needed to operate an IC.

The current power IC I’m using is a buck converter RT6208G. I chose a buck converter over an LDO because of efficiency, again trying to keep the current draw from the battery low. Key features of this converter is:

  1. Low quiescent current: less than 500nA or 0.5mA
  2. High input voltage: 36Vin max
  3. Small and compact
  4. Efficient: around 80-90%

One thing to mention is that the buck converter I chose is currently out of stock and will not be available until November. I’m currently working on choosing an alternative but any buck converter will work with this.

Figure 1: Power Section

Anything here is that instead of stepping down to 3V3, I stepped down the voltage to 2V7. The image above is wrong and the FB resistor values are picked for an output voltage of 2V7 but it will function the same.

The reason for going with this voltage is because I was trying to minimize the current draw from the battery. I found that 2V7 is the minimum voltage I can use while still being able to use the I2C OLED screen.


The next section is the Arduino MCU and the external 1.25V reference.

Figure 2: MCU and Reference Section

Here you can see where the ADC pins are attached to the cell pins for measurements. And the digital pins for the control of the mosfets for the balance section. Its pretty straight forward here

On the bottom you can see the external 1.25V voltage reference. I’m sure there are different values I could have gone with but I figured that with a 1.25V I could try and increase resolution even after the voltage dividers. Without accounting for the voltage dividers for measuring the cells, we have a 1.22mV resolution. Not too bad but obviously it will increase with the voltage dividers.


The next section is the voltage divider section which is used to step down the cell voltages to within the voltage reference value, in our case 1.25V max.

My values calculated were based stepping down the voltage value to within 1.20V, that is when a cell is at 4.2V then the divider will be 1.20V. This gives some margin in case the cells get overcharged.

Here you can see the divider circuit. Since the measurements are single-ended measurements and not differential, then everything is reference to ground and there for the higher in cell measurements we go the bigger the voltage divider we need.

I used 100k as the base resistor as I tried to minimize current consumption. The measurement cycle will be slower due to the arduinos 14pF capacitor but thats ok because we sample about 100 measurements to offset this.


The last section is the balance section. Here the controllers turns off and on the mosfets corresponding to the cell its attached to. When the software determines that ex. cell 2 is higher than the lowest cell, then D1 is triggered and an 18 ohm resistor will start draining some current to let the rest of the cells catch up.

Figure 3: Balance Section

Looking at the bottom section of this circuit ( BAT0 / BAT1 ) you can see resistor value R424, this controls how much current is drained. At full charge of the cell 4.2V, you will see a current drain of 0.23A and then a minimum drain of 0.16A when the cell is at 3.0V.

Since the series mosfets are capable of 4.2A, you can theoretically lower the resistor value to drain more current but I do not suggest draining more than 1A at least with this board.


This section was added for an extra layer of protection and is not needed for the bms balancing functionality to operate.

I’ve added a mosfet switch that utilizes the arduinos digital pin 9 and 10 to control power mosfets that are in series on the positive line of the battery.


Theoretically each mosfet can handle around 10A without a heatsink and about 40A per mosfet with a heatsink for a total of 120A total. But here you can add more in parallel for higher current or change the mosfet for a higher current capable one. The mosfets used here are P_Channel mosfets for high side switching.


Now to cover the software side of this board, here I will only cover the important sections in which you might want to adjust for your own purposes. Most of the variables you would want to change can be accessed and changed via serial monitor using an FTDI while only connecting the TX, RX, and GND pins.

Here I will list the important sections:

  1. Sampling frequency
  2. Tolerance adjustment
  3. Serial Commands


// Sampling number for analog read values.
// Will use this sample size to calculate a
// better estimation of the analog value
int samples = 100;

Here in the samples variable you can change the value for how many samples the adc takes before creating an averaging of the cells. If you want a smoother value you can increase but I would not go past 250 samples. Remember this will also effect the amount of time it takes to display voltage values.


// This is the max difference that the cells
// can achieve in respect to each other
float tol = 0.01; // 10mV max voltage difference

Here in the tol variable, it is used to as a reference for when the balancing of the cells should stop. The cells will balance until all cells are within 10mV of each other. This might not be exact because with the last 2 cells the register voltage different might be greater than 10mV due to a higher voltage divider but the measured voltage is around +/- 25mV of the actual cell voltage.


The most important part is the serial commands because this allows you to make changes without having to reflash the arduino.

Below we have a list of 6 serial commands that I will explain in details on how to enter the values into the serial monitor.

/* This is the table for entering into different modes and how to 
 *  enter commands within serial console
 *  modes:
 *  1. Display ADC calibration values = 1001
 *  2. Enter adc auto calibration     = 1002
 *  3. Adjust minimum and maximum     = 1003
 *     voltage threshold for OVP
 *     and UVP
 *  4. Used to set all digital outputs
 *     to low                         = 1004
 *  5. Erase all EEPROM values        = 1005
 *  6. Reset series switch value      = 1006
 *  7. Display status for Reset, UVP
 *     OVP state condition            = 1007
 *  1.Example of displaying calibration values
 *    Serial window: mode
 *    Serial window: 1001
 *  2.Example of entering into auto calibration mode
 *    Serial window: mode,vref1,vref2,vref3,vref4
 *    Serial window: 1002,4.00,8.00,12.00,16.00
 *  3.Example of entering UVP and OVP values
 *    Serial window: mode,UVP,OVP
 *    Serial window: 1003,3.10,4.15

Lets look at the first command entry.

  • 1001
    • This will display the calibration values that is stored in EEPROM
  • 1002
    • This will enter calibration mode. Since there might be some offset from what the adc reads vs the actual value, I added a calibration mode that will add the offset to each adc value to try and get the values closer to the actual.
    • To enter calibration mode you will need to enter:
      • 1002,vef1,vef2,vef3,vef4
      • The vef1-4 values are the actual measurements of the battery cells
    • Calibration setup:
      • Enter 1004 first to turn off all balancing MOSFETS
      • Measure each cell value with a multimeter to get the actual value
      • Then enter calibration mode by entering 1002,3.54,3.76,3.20,3.56 as an example for vef values
  • 1003
    • This will adjust the values set for under voltage protection and over voltage protection. So if lets say 3.1V is set value for under-voltage protection then if any one of the cells drop below this value then the series FET will trigger if you have it attached.
    • This command is only valid if you use digital pin 9 and 10 for the series FET switch.
    • Enter 1003,UVP,OVP
    • 1003,3.2,4.2
  • 1004
    • Used to set all balancing values to low so that no cell is draining current. This is usually used for testing purposes.
    • Enter 1004,1 for setting all values to low
    • Enter 1004,0 to go back to normal balancing operation
  • 1005
    • This is used to erase all eeprom values
  • 1006
    • If UVP or OVP is triggered then you will need to reset this fault condition
    • Enter 1006,0
    • NOTE: If values are above or below the UVP and OVP values then resetting the 1006 command will not allow current to pass


I’m very happy on how this project has progressed but its far from perfect and I will continue to optimize both the software and hardware to make it easier to integrate into a battery.

Future updates in my roadmap:

  1. Optimize the Power MOSFET Switch circuit to handle higher currents
  2. Possibly combine the mosfet control to one pin as using two might not be needed. UVP and OVP conditions open circuit the mosfet bidirectional switch
  3. Add current sense capability for overcurrent protection.
  4. My next big protection is creating a 7-8S BMS as well as a separate UVP, OVP, and Over-current protection board that will operate independently from the 8S BMS board but will still communicate via I2C to pass current data to the BMS board

If you have any questions or any suggestions or improvements please feel free to ask or comment.

Thank you and hope you enjoyed this project.






Now this might seem like it was a complete waste of time to try and reinvent the wheel with creating my owm custom BMS solution. You can buy them on ebay or alibaba or banggood for super cheap and it seems like a plug and play solution.

One problem I see with this, at least for me, is that I dont completely trust those cheap BMS system. I like to buy something that is reasonable as well as trusting that it will safely protect my cells from unbalancing. Another this is that I like to have flexibility with how I balance my cells or anything else.

Now this is where the custom arduino BMS came into play. I’ve designed this bms to handle a 4S battery pack so upto 16.8V fully charged and 14.8V nominal. The balance discharge current can be adjusted by simply replacing the discharge resistor with any value you wish. Just to add this does not have over current or over voltage protection..yet 🙂 I’m currently working on an add on for this so stay tuned for that future update.

Lets get started with all the cool details for this arduino bms.


Here i just wanted to show you the 3D rendering images of the final board. The rendering was created using kicad and its pretty nice actually for an EE cad software.

The heart of this system is the atmega328P running the minicore arduino bootloader[1]. From here you have the 4 balancing passive resistors to the right of the board. The best part of this project is that you can replace these resistors to any value you want to customize the balance current.

The one thing that this does not have is overvoltage and overcurrent protection but that will be a separate circuit later on ;).

Now we can talk about the main features below in the schematic section.


Below are images of the full schematics for this project:

The first page of the schematic files is a hierarchy block level of the system to help understand how a lot of these subcircuits are linked together. Below I’ll breakdown all the pages and what exactly they do.

1. Hierarchy Block:

  • This is the overview block level that links the subcircuits on the separate pages. I normally like to design my projects this way if I have more than 2 subcircuits because its easier to see how things are working together

2. Power Supply

  • This section is just the power supply section to power the arduino. This is a high differential buck converter. The input voltage can go up to 36V and output down to 1.8V with an active quiescent current of only 190uA. Now the most important part is the quiescent current because we are trying to eliminate any wasted current since this is for a battery operated system and we do not want to drain the batteries faster than needed.

3. MCU

  • The MCU page has the Atmega328P and all the corresponding IO related to it. Im using A0-A3 to measure the batteries via a resistor divider
  • This page also includes the external reference voltage used instead of the built in 1.1V from the atmega328p. Its a 1.25V external voltage reference that has a better tolerance at a range of temperatures.

4. Balancing Circuit

  • This page has the balacing circuit which is incharge of discharging the battery cell that has a higher potentional. The heart of this is a bidirectional N-channel mosfet that allows current to flow in both directional either during discharge or during charging.

5. Connectors

  • This page has the power pin connectors and the BMS pads that connectors to the lithium cells.

Now that we’ve gone through the schematic lets go into the second most important part and that is the arduino code.


Now probably the second most important part is the arduino code that will control the mosfets triggering the discharge when a preset voltage difference is hit.

#include "Adafruit_SSD1306.h"

/* Revision: A9

* Written by: Steven Guzman

* Date: 7/10/2018

* Description: This is a customizable BMS system for a 4

* cell lithium ion pack.


#include "Wire.h"

#include "avr/wdt.h"

#define OLED_RESET 4

Adafruit_SSD1306 display(OLED_RESET);

#define NUMFLAKES 10

#define XPOS 0

#define YPOS 1

#define DELTAY 2


// This variable is used for checking on

// whether the OLED screen is attached or not


int check = LOW;


// Sampling number for analog read values.

// Will use this sample size to calculate a

// better estimation of the analog value


int samples = 100;


// This is the max difference that the cells

// can achieve in respect to each other


float tol = 0.03;


// To temporaly store analog values from the

// cell voltages to average out later with

// the number of samples taken


float temp_cell[4];


// Float array to store unconverted cell values


float cell[4];


// Variable array to store converted voltage

// values for cell measurement


float B[4];


// Variable array to store voltage differences

// between cells


float diff[4];


// Variable used for digital output

// signals


int BAT[4];


// Variable used for storing the cell pack


float PACK = 0.000;


// Scaling factor used for converting

// the scaled down analogread values to there

// actual values from the voltage divider


float scale0 = 0.25; // 10k/(30k + 10k)

float scale1 = 0.125; // 10k/(69.8k + 10k)

float scale2 = 0.083; // 10k/(110k + 10K)

float scale3 = 0.0625; // 10k/(150k + 10k)

#if (SSD1306_LCDHEIGHT != 32)

#error("Height incorrect, please fix Adafruit_SSD1306.h!");


void setup()



analogReference(EXTERNAL); // Configure reference voltage for

// external 1.25V


// After switching to external reference you

// need to read a value a couple times before

// the reference has stabalized.






// Setup up watchdog timer to reset

// after 4 seconds



// Variables to set the digital output

// pins 1-4


BAT[0] = 5;

BAT[1] = 6;

BAT[2] = 7;

BAT[3] = 8;


// Setting digital pins to output configuration


pinMode(BAT[0], OUTPUT);

pinMode(BAT[1], OUTPUT);

pinMode(BAT[2], OUTPUT);

pinMode(BAT[3], OUTPUT);


// Sets the digital outputs to an initial low

// state







void loop()


Wire.requestFrom(0x3C, 1); // Pings OLED screen


// If OLED pings back and check statement

// equals 1, then initiate the OLED screen

// and reset the check value to 0 so it will

// not continue to re-initiate. It needs to

// initiate another request one last time


if (Wire.available() && check == HIGH )


display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

check = 0;

Wire.requestFrom(0x3C, 1);


if ( Wire.available() && check == LOW)


// Leave blank


else if (!Wire.available())


check = 1;



// Sets the temp variable array back to zero


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


temp_cell[x] = 0.00;

diff[x] = 0.00;

cell[x] = 0.00;



// For loop used to record battery cell voltage

// information and used later to average out

// the readings




// Using true RMS calculation for computing a

// better average estimate for multiple samples.


for (int i = 0; i < samples; i++)


temp_cell[0] = temp_cell[0] + sq((analogRead(A0)/scale0)* (1.249 / 1024));


temp_cell[1] = temp_cell[1] + sq((analogRead(A1)/scale1) * (1.249 / 1024));


temp_cell[2] = temp_cell[2] + sq((analogRead(A2)/scale2) * (1.249 / 1024));


temp_cell[3] = temp_cell[3] + sq((analogRead(A3)/scale3) * (1.249 / 1024));



cell[0] = sqrt(temp_cell[0] / samples);

cell[1] = sqrt(temp_cell[1] / samples);

cell[2] = sqrt(temp_cell[2] / samples);

cell[3] = sqrt(temp_cell[3] / samples);


// Scale up the cell values and then convert to

// to voltage values


B[0] = (cell[0]);

B[1] = ((cell[1] - cell[0]));

B[2] = ((cell[2] - cell[1] ));

B[3] = ((cell[3] - cell[2] ));

PACK = B[3] + B[2] + B[1] + B[0];


// Compares each cell voltage to each other and then finds the

// lowest cell value. Then it stores the difference between the

// lowest cell and the remaining cells for comparison


if ( (B[0] <= B[1]) && (B[0] <= B[2]) && (B[0] <= B[3]))


diff[1] = B[1] - B[0];

diff[2] = B[2] - B[0];

diff[3] = B[3] - B[0];


else if ((B[1] <= B[0]) && (B[1] <= B[2]) && (B[1] <= B[3]))


diff[0] = B[0] - B[1];

diff[2] = B[2] - B[1];

diff[3] = B[3] - B[1];


else if ((B[2] <= B[0]) && (B[2] <= B[1]) && (B[2] <= B[3]))


diff[0] = B[0] - B[2];

diff[1] = B[1] - B[2];

diff[3] = B[3] - B[2];




diff[0] = B[0] - B[3];

diff[1] = B[1] - B[3];

diff[2] = B[2] - B[3];



// It enables the balancing protocol for a given cell that has a

// greater voltage difference from the lowest cell and the set

// tolerance.



for ( int x = 0; x tol )


digitalWrite(BAT[x], HIGH);





digitalWrite(BAT[x], LOW);





// text display tests




























Lets break down this code in order to understand my thought process behind this.

  1. The samples variable is used to create an average sampling of the battery cells to eliminate any noise issues. The averaging technique I used in this project is a little different than most but I will explain later on
  2. The next variable is the tol variable. This variable is the maximum voltage different between the lowest cell and the rest of the cells in the 4S pack. Currently its set to a maximum of 30mV difference but this can be set to a minimum of 10mV because of the 8-bit adc on the arduino.
  1. Here is the scaling factor for the adc from the cell measurements. We have different values because in order to get the best accuracy measuring in reference to ground, different values were needed for measuring cell 1 which has a max of 4.2V and cell 4 which measures a max of 16.8V.
  1. This portion of the code is mainly for the OLED screen. It allows for the screen to be removed and re attached without having to reset the arduino. Before you had to initialize it in the setup but with this loop it is initialized in the main loop when it detects the screen.
  1. Now this section is averaging the adc values from all 4 cells to get a best measurement of the cell voltage values. Instead of using the traditional sample 25 and take the average, I’m using a true RMS calculation that will give you a slightly better voltage measurement that just taking the average. It will be at a closer measurement to your multimeter than using average sample.


Here is the final PCB:

I’m pretty excited to do more testing on this and I will post my technical review later on that includes current consumption, maybe a mini manual on how to use it or change values for your own build.

Again this does not include an over voltage or over current protection circuit but I decided to make that a separate board with its own controller in order to make the board as small as I could and isolate the two circuits as a redundancy. I’m still making some tweaks and might make another revision but all in all I’m very happy about it.

Some current issues that I know off.

  1. You might have to calibrate with a known good multimeter. The arduinos ADC has some weird issues with analogPin A2 measuring higher than the rest. I added a calibration value in the code to help with that.


Arduino Code Download

Schematic and Gerber Download

For the Bill of Materials, I’ve embedded the datasheets for some of the major components in case you wondered why the file is larger than it should.


1. Minicore bootloader

Project – GRBL Controller Board


1. Introduction
2. Bill of Materials
3. Schematic
4. 3D Redering
5. Final Thoughts
6. Download Original files


With all the low cost CNC machines out in the market, there is also an abundant of GRBL shields for the arduino platform. Like always, I’m always looking to for ways to customize and improve whats in the market.

What I’ve created is a slightly better GRBL controller board for low cost CNC machines. This uses the Arduino Nano instead of the Uno as this allowed for more flexibility on the size of the board. It also integrates the relay switch for the spindle with an integrated flywheel diode to avoid over voltage spikes when the spindle is first turned on.

Below I’ll discuss in more detail along with the files you need to create this board.


Click here to download the bill of materials


Here in the schematic you can see a couple of items that are different from the traditional ebay/amazon grbl shields. First of all this is not a shield per say but more of a standalone controller board.

  • Since the capacitors that are used to filter the stepper drivers are 35V rated, I’ve limited the input voltage to 24V
  • I’ve added a TVS diode at the power input that protects from over voltage spikes.
  • Used better output connectors for the stepper motor drivers
  • Added 0.1uF capacitor for the probe pin for autoleveling
  • Added x3 5V rail connectors
    • One thing to add is that these connectors are taking power from the USB port and should not be loaded more than 0.2A combined
    • I added these for low current 5V noctua fans to cool the stepper drivers
  • Added relay control on the main board to eliminate adding external relay switch for the spindle.
    • some newer versions of the grbl software, I believe v1.1 has the spindle pin and z-axis switch so thats why I included the option to switch between the two
    • I believe you can switch this back in the firmware of the grbl settings. But none the less the option is there
  • The relay controller also includes a 1000uF and a flywheel diode to prevent voltage spikes on turn-on


Here is a 3D Rendering from Kicad of the board. I’ve added this rendering because I thought it looked really cool.

Here is a picture of the final board below:

Below is the board fully soldered and it works amazing. I will add some images of the quality of boards my machine makes with the new controller board.

Future revisions of the board I will increase the 5V rail to supply up to 1A of current for high current draw fans and order accessory’s. Also, I will try to route out the limit switch pins. This will require me to remove the z-limit switch pin that connects to the spindle control but that should not be an issue.

If you have any comments or suggests please feel free to send them my way.

Thank you!!

Download original files here.

Project – DC Power and Efficiency Meter



1. Introduction

2. Bill of Materials

3. Schematic

4. Code

5. ME Cad design

6. Final Thoughts

7. Download Original files


This is a fun little project that actually took me awhile to put together.  What makes this project interesting and useful is that it will display your voltage, current, and power of any device you plug it into.  What also makes this project useful is that it will calculate the efficiency of your device for example a dc dc converter.

The heart of this project is two INA219 high side current sensors from Texas Instruments.  With this sensor you can measure up to 26V DC and up to +/-3.2A with a 0.1ohm shunt resistor (if you swap out the shunt with a 0.01ohm shunt you can measure up to +/-32A)


Click Here for bill of materials


Here you can see a block diagram showing how I connected the different boards to create this project. Since I used my CNC machine to create the boards, it’s always much easier to separate the circuits into different boards for routing.

The main board consist of an arduino pro mini to keep the footprint as small as I can and also host a 5V boost converter being power from the 18650 lithium ion battery.  In order to charge the battery without having to remove it from the enclosure, I decided to add a lithium ion charger board that connects in parallel with the battery.  Its powered by a 5V USB mini connector and can be bought on amazon.

The second board host x2 INA219 high side I2C current, voltage, and power sensor by Texas Instrument.  This IC is an amazing little thing because it takes a lot of the number crunching away from the Arduino and just sends the data over I2C that you need.

The final piece of this is the I2C liquidcrystal display for the arduino.  I used this library here for the display.  Make sure you connect the display and run an i2c address scanner on the examples for arduino because sometimes the displays have a different address than the default one listed.




 * Name: Steven Guzman

 * Date: 2018/03/18

 * Description: This is a DC power meter that measures input and output

 *              power and calculates the efficiency of the system.

 *              It can also measure voltage and current of one or two

 *              voltage sources





LiquidCrystal_I2C lcd(0x3F,20,4); // Set the LCD address


 * Below are the array values to store the measurements

 * and then used to convert float to string


char float_volt1[8];  // voltage 1 array

char batt0[21];

char float_volt2[8];  // voltage 2 array

char batt1[21];

char float_current1[8]; // current 1 array

char curr1[21];

char float_current2[8]; // current 1 array

char curr2[21];

char float_eff[8];  // efficiency variable array

char line6[21];

char float_batt[6]; // battery voltage array

char line5[21];

// Analog sampling number

int sample = 20;

// Inialize current sensors.

// ina219_A default address is 0x40

Adafruit_INA219 ina219_A;

Adafruit_INA219 ina219_B(0x43);

// Variables to store current sensor data

float busvoltage1 = 0;

float busvoltage2 = 0;

float current_mA1 = 0;

float current_mA2 = 0;

float batt = 0.00;

void setup()













void loop()


  float xbat = 0.00;

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


    batt = analogRead(A0);

    xbat = xbat + batt;


  // Read voltage levels from the voltage address

  // of the IN219 on both ICs

  busvoltage1 = ina219_B.getBusVoltage_V();

  busvoltage2 = ina219_A.getBusVoltage_V();

  // Read current levels from the current address

  // of the IN219 on both ICs

  current_mA1 = ina219_B.getCurrent_mA();

  current_mA2 = ina219_A.getCurrent_mA();

  // Average out the analog measurements

  // for the lithum ion battery voltage

  // sensing

  xbat = xbat/sample;

  float battery = xbat * (5.00/1024);


  sprintf(line5, "Battery:%-5s",float_batt);

  char temp3[] = "V";


  // Convert float values into an char array to

  // better update on the lcd screen without

  // having to use the lcd.clear function


  sprintf(batt0, "V1:%-5s",float_volt1);

  char temp2[] = "V";

  strcat(batt0, temp2);


  sprintf(batt1, "V2:%-5s",float_volt2);

  char temp1[] = "V";

  strcat(batt1, temp1);

  // Convert mA to A readings

  float C1 = current_mA1/1000;

  float C2 = current_mA2/1000;


  sprintf(curr1, "C1:%-5s",float_current1);

  char temp4[] = "A";

  strcat(curr1, temp4);


  sprintf(curr2, "C2:%-5s",float_current2);

  char temp5[] = "A";

  strcat(curr2, temp5);

  float power1 = busvoltage1 * C1;

  float power2 = busvoltage2 * C2;

  float eff = (power2/power1)*100;


  sprintf(line6, "Efficiency:%-7s",float_eff);


   * Display on LCD screen all the values.

   * I used char arrays to update the values on the

   * screen.  Using the lcd.clear caused flickering

   * and was annoying.  With char array you can include

   * the units and it will update properly and not

   * overright the units.
















There might be some issues with how wordpress displays the arduino code but I attached the original files at the end this tutorial.

As mentioned before, the libraries used here I obtained from other sources:

  1. Liquid crystal display library
  2. INA219 adafruit library


I designed the enclosure in fusion 360 and printed the both with matterhackers pro series PETG red.  I used a monoprice maker select v2 to print this enclosure.

Here is the step file for the enclosure


This was one of my favorite projects yet because the design alone makes me feel accomplished learning everything on my own.  I still feel like I can make some upgrades to how I mount the internals and to be honest, I really rushed this part because I wanted to finish it.

Some upgrades I’m considering is using the arduinos internal 1.1V reference with a voltage divider to measure the battery voltage because it wasn’t as accurate as I wanted it to be.

Thank you for visiting and reading my project. if you have any questions or comments or suggestions please don’t hesitate to ask.


Original files

Electronics: FTDI USB TO UART



1. Introduction

2. Bill of Materials

3. Schematic

4. Oshpark

5. Final Thoughts

6. Download Original files


With the Arduino mini, there is a need for a USB to UART controller to upload your sketches and this could also be used for the ESP8266.

This project is inspired and based off the Sparkfun’s FT231X breakout board design.  I’ve created this project because 1. I like designing and soldering electronics 2. Try to create a cheaper alternative to the popular FT232RL and also add 1 or 2 features to the current FT231X breakout board.


For the bill of materials, its pretty straight forward.  I’ve attached links to digikey for each component as I find them easier to order from but you could also get the parts from arrow or mouser as well.


Component Description Part number Quantity Link
47pF, 0603, 50V C1608C0G1H470J080AA 2 Digikey
0.1uF, 0603, 25V CGA3E2X7R1E104K080AA 4 Digikey
10uF, 0805, 6.3V TCJN106M006R0250 1 Digikey
Micro B Connector 10118192-0001LF 1 Digikey
6-pin Header M20-7910642R 1 Digikey
N-Channel FET BSS84-FDICT-ND 1 Digikey
27 ohm, 1206 RC1206JR-0727RL 2 Digikey
10k, 0603 RT0603DRD0710KL 2 Digikey
FT231X, SSOP-20 FT231XS-U 1 Digikey


Below I’ve attached an image of the schematic but i’ve also attached the original kicad files and a PDF version of the schematic at the end of the post.


If you feel like you want to get this board made, I’ve attached a link to my oshpark project.  With oshpark, I find they make great quality boards at a great price for small sized boards.

Order from OSH Park


I know this was a short post and project but I found it important to share another option for those’s who want to find a cheaper solution and want to learn along the way.  You can find a lot cheaper solutions on amazon that are china made but i’ve read stories in some cases that they were not genuine FT232RL ICs.  If you wish to build your own, its very easy and rewarding at the same time.

In the next revision I will add LEDS for TX and RX indication as for this version I eliminated to save some cost and space.

Hope you enjoyed this post, THANK YOU 🙂





1. Introduction

2. Bill of Materials

3. Block Diagram

4. Schematics/CAD DESIGN

5. Assembly

6. Final Thoughts/ Improvements

7. Download Original Files


Arduino and the implementation of GRBL has allow for amazing things to be created.  One of those things are low cost CNC machines that enable us to create anything we want.

I bought myself a low cost CNC engraver from amazon and after modifying it, it has been one of my best investments because as en electrical engineer I can create PCB boards to test my designs here at home and verify before getting them sent out. One problem I usually have is that I use my laptop to run the gcode software and my laptop is really big and sometimes a hassle to keep on my desk.

My solution was to create this project and make a standalone CNC machine controller to run the gcode software in a compact package.  I tried fiddling around with using a raspberry pi 2 as my main PC but I’m still a beginner with raspberry pi’s and I had issues getting the settings right.  My next option was to use a windows based machine and luckily I found just the solution.

In this tutorial I will explain how I put this together and what improvements could be made.


Component Quantity Link
Windows computer stick 1 Amazon
Wireless keyboard/mouse 1 Amazon
DIY HDMI male adapter angled 1 Adafruit
DIY HDMI female adapter 1 Adafruit
DIY HDMI Ribbon cable 20cm 1 Adafruit
3.5 inch Screen 1 Amazon
Left angled micro usb cable 1 Amazon
Top angled usb 3.0 extension 1 Amazon
USB Board
USB Female Connector 2 Sparkfun
5VWM TVS Diode 1 Digikey
0.1uF 50V X7R 1206 1 Digikey
1uF 25V X7R 0805 1 Digikey
10uF 16V X5R 0805 1 Digikey
100 OHM 0.1% 1/8W 0805 2 Digikey


Visio_blog - block diagram

Here is the block diagram for how this project is wired.  With the exception of the enclosure itself and the usb power board, everything was bought ready to go.  I’ve added a fan as a just in case because the computer stick does generate some heat so the fan will prevent the system from over heating but so far it does not seem to be an issue with heat and therefore is an option.

The 5V and 12V supply are coming from my 24V power supply that powers my Arduino GRBL shield.  What I did was use two step down converters 1) For 5V step down and 2) For 12V step down.  I realized this might not be idle but it is my first revision of this project.


The only schematics I have is for the USB power board and I created that using Kicad.  The board was basic, since both the screen and the windows computer stick ran on 5V via micro USB, I needed to distribute power from one source into two loads.  To add some safety, I did add a TVS 5VWM diode to prevent over voltage spikes from destroying the devices along with some filtering capacitors.

Electronics_pdf - cnc usb power board-1

If its a little blurry don’t worry because all original files will be included in a download link at the end.

Now for the enclosure, I designed it using Fusion 360.  Honestly, I am not a Mechanical engineer/Designer so this was my first attempt at designing something in a CAD software.  Mine you its really just a box but Fusion 360 makes it really easy to design for someone who had no prior experience.

I designed this in two pieces:

  1. The bottom portion of the enclosure:CAD_pdf - Enclosure Drawings-1
  2. The Lid for the enclosure:CAD_pdf - Lid Drawings-1

For material used for making this enclosure, I used my Maker Select V2 3D printer with PETG filament for the temperature resistance and flexibility.

I will include the STL files so you guys can 3D print this yourself.


Now for the fun part, putting this thing together and hoping everything works without the magic white smoke lol jk.  This was actually very easy to put together though there were a couple of design hick ups.

Since I wanted to get the print out as fast as possible, I sacrificed quality of the print which is why it looks the way it does but its very function.

As I mentioned I did have some design issues after I was putting this thing together.  If you look at image 3, you can see that the usb power board is tilted up and thats because I placed the cooling fan to close.  The board was able to fit but I could not connect anything because the fan was blocking the connectors.

I decided to use hot glue to hold everything down because it wouldn’t be a DIY project if hot glue wasn’t involved.

In image 4, you can see I used some basic terminal block connectors to attach my 5V and 12V supply.  You can also see the USB port to connect the arduino grbl controller board.


Overall I enjoyed putting this project together.  It’s made my project efficiency increase dramatically because I don’t have to take it out and set it up every time I want to make a board.

With anything we do, there’s always room for improvements.  In a future version of this project I plan to improve the way I connect my external 5V and 12V supply instead of using the terminal blocks.  I might possibly use some type of molex connector that can easily detach.  To reduce the amount of external connectors, I could switch out the 12V fan with a 5V fan and run it with only one step down converter.  I’m going to also move the fan placement so that I do not have to angle the usb power board.


Bill of Materials

KiCad files

3D STL files

PDF Documents

Thank you for visiting and I hope you enjoyed this project.

Please leave a comment and let me know about your thoughts, improvements or any issues you see with this post.  All comments are welcomed 🙂