Voltaic has added the ability to read the voltage, and thus the charge level, of the Li-ion cells in its V25, V50 and V75 USB Battery Packs. If you are building an IoT application using one of these Always On battery packs, you can monitor the state-of-charge (SoC) and potentially make changes to your application’s power consumption in order to keep it running 24 x 7.

 

In this post, I show how you can use a microcontroller and the INA219 voltage/current sensor to read and report the cell voltage from the batteries’ USB-C port. 

 

/*
 * Reading Voltages and Current with Arduino ADC + INA219
 * -------------------------------------------------------
 *
 * Maker Portal LLC Copyright 2020
 * Written by: Joshua Hrisko
 *
 */
#include <Wire.h>
#include <Adafruit_INA219.h>

Adafruit_INA219 ina219_A(0x40); // start INA219 current/voltage sensor

void setup(void)
{
  analogReference(EXTERNAL); // set analog reference to 3.3V
  Serial.begin(115200); // open serial port at 115200 bps
  Serial.println("Acquisition Start"); // start word for Python code

  // check to make sure INA219 is being read
  if (! ina219_A.begin()) {
    Serial.println("Failed to find First INA219 chip (0x40)");
    while (1) { delay(10); }
  }
  // print header for logging data:
  Serial.println("Time[s],InputVoltage[V],InputCurrent[mA],D+[V]");
}

void loop(void)
{
  // preallocate variables
  float shuntvoltage = 0.0; float busvoltage = 0.0;
  float current_mA = 0.0; float loadvoltage = 0.0;
  float d_plus = 0.0;

  // read variables from INA219 (voltages/current)
  shuntvoltage = ina219_A.getShuntVoltage_mV();
  busvoltage = ina219_A.getBusVoltage_V();
  current_mA = ina219_A.getCurrent_mA(); // load current
  loadvoltage = busvoltage + (shuntvoltage / 1000); // load voltage
  d_plus = 3.3*analogRead(A0)/1023.0; // reading D+ from USB-C on Arduino pin A0
 
  Serial.print(millis()/1000.0); // print milliseconds since code start
  Serial.print(","); // comma-separation
  Serial.print(loadvoltage); // load voltage
  Serial.print(",");
  Serial.print(current_mA); // load current
  Serial.print(",");
  Serial.println(d_plus); // D+ scaled cell voltage
  delay(1000); // wait 1 second between readings
}

##################################################
# ---- Python Serial Port Datalogger
# 
# ---- Maker Portal LLC Copyright 2020
# ---- Written by: Joshua Hrisko
#
##################################################
#
# This code reads from the serial port and saves
# the data until the user presses
# CTRL+C, wherein the acquisition ceases
#
##################################################
#
import numpy as np
import matplotlib.pyplot as plt
import serial,datetime,csv,os
import serial.tools.list_ports as COMs
#
#
############################################
# Real-time plotter functions
############################################
#
def plotter_start(x_lims=[0.0,1.0],new_plot=1):
if new_plot:
plt.style.use('ggplot')
fig = plt.figure(figsize=(12,9))
ax = fig.add_subplot(111)
ax2 = ax.twinx()
ax.set_xlim(x_lims)
ax.set_ylim([0.0,6.0])
ax2.set_ylim([0.0,2200.0])
ax.set_ylabel('Voltage [V]')
ax2.set_ylabel('Current [mA]')
ax.set_xlabel('Time [s]')
lines = []
for ii,header_ii in enumerate(header[1:]):
if ii==1:
line_ii, = ax2.plot([],color=plt.cm.Set1(ii),linewidth=3.0,
label=header_ii)
else:
line_ii, = ax.plot([],color=plt.cm.Set1(ii),linewidth=3.0,
label=header_ii)
lines.append(line_ii)
ax.legend(loc='upper left')
ax2.legend(loc='upper right')
fig.canvas.draw()
ax_background = fig.canvas.copy_from_bbox(ax.bbox)
plt.show(block=False)
else:
fig = plt.gcf()
for ii in fig.get_axes():
ii.cla()
fig.clf()
ax = fig.add_subplot(111)
ax2 = ax.twinx()
ax.set_xlim(x_lims)
ax.set_ylim([0.0,6.0])
ax2.set_ylim([0.0,2200.0])
ax.set_ylabel('Voltage [V]')
ax2.set_ylabel('Current [mA]')
ax.set_xlabel('Time [s]')
lines = []
for ii,header_ii in enumerate(header[1:]):
if ii==1:
line_ii, = ax2.plot([],color=plt.cm.Set1(ii),linewidth=3.0,
label=header_ii)
else:
line_ii, = ax.plot([],color=plt.cm.Set1(ii),linewidth=3.0,
label=header_ii)
lines.append(line_ii)
ax.legend(loc='upper left')
ax2.legend(loc='upper right')
fig.canvas.draw()
ax_background = fig.canvas.copy_from_bbox(ax.bbox)
return fig,ax,ax2,lines,ax_background
def plotter_update(xs,y_vec):
y_vec = np.transpose(y_vec)
for iter_ii in range(0,len(lines)):
if iter_ii==1:
lines[iter_ii].set_data(xs,y_vec[iter_ii])
ax2.draw_artist(lines[iter_ii])
else:
lines[iter_ii].set_data(xs,y_vec[iter_ii])
ax.draw_artist(lines[iter_ii])
fig.canvas.restore_region(ax_background)
fig.canvas.blit(ax.bbox)
fig.canvas.draw()
return
#
############################################
# Find Arudino ports, select one,
# start communication with it
############################################
#
arduino_ports = [ii.device for ii in COMs.comports() if\
len((ii.device).split('ttyACM'))>1 or\
len((ii.device.split('ttyUSB')))>1]
ser = serial.Serial(arduino_ports[0],baudrate=115200) # match baud on Arduino
ser.flush() # clear the port
#
############################################
# Grabbing real-time data from Arduino
############################################
#
t_now = datetime.datetime.strftime(datetime.datetime.now(),
'%Y_%m_%d_%H_%M_%S')
datafile = 'arduino_data_'+'{0}'.format(t_now)+'.csv' # date 
t_vec = [] # allocate time vector
data_array,data_plot = [],[] # for saving all values
start_bool = False
plot_refresh_dt = 60 # every # of seconds between axes limit updates
plot_update_pts = 10 # number of pts to read before plotting
#
while True:
try:
ser_bytes = ser.readline() # read Arduino serial data
decoded_bytes = ser_bytes.decode('utf-8') # decode data to utf-8
data = (decoded_bytes.replace('\r','')).replace('\n','')
if start_bool==False and data=='Acquisition Start':
# read the first line after acquisition start as header
header = (((ser.readline()).decode('utf-8').replace('\r','')).\
replace('\n','')).split(',')
# create csv file for saving the data each loop
with open(datafile,'w') as csvfile:
csv_writer = csv.writer(csvfile,delimiter=',')
csv_writer.writerow([header])
fig,ax,ax2,lines,ax_background = plotter_start(x_lims=[0.0,
plot_refresh_dt],new_plot=1) # start plot
start_bool = True
print('Data Acquisition Starting...')
ser.flush()
continue
if start_bool:
try:
if len([float(ii) for ii in data.split(',')[1:]])!=3:
continue
t_vec.append(float(data.split(',')[0]))
data_plot.append([float(ii) for ii in data.split(',')[1:]])
data_array.append([float(ii) for ii in data.split(',')])
except:
continue # if data format issue - skip
if len(t_vec)%plot_update_pts==0:
plotter_update(t_vec,data_plot) # update data on plot
# set new limits on plot to create scrolling effect
if ax.get_xlim()[1]<t_vec[-1]:
new_xlims = [0.0,plot_refresh_dt+t_vec[-1]]
fig,ax,ax2,lines,ax_background = plotter_start(new_xlims,0)
plotter_update(t_vec,data_plot) # update data on plot
# save data to the existing csv file
with open(datafile,'a',newline='',encoding='utf-8') as csvfile:
csv_writer = csv.writer(csvfile,delimiter=',')
csv_writer.writerow(data_array[-1])
except KeyboardInterrupt:
ser.close() # close the serial port 
print('Exiting Loop')
break # finally, exit loop after save

##################################################
# ---- Python Data Plotter (for: Arduino+INA219)
# 
# ---- Maker Portal LLC Copyright 2020
# ---- Written by: Joshua Hrisko
#
##################################################
#
# This code reads from locally saved .csv files
# that have Arduino + INA219 values saved by
# the Python script: INA219_pylogger.py
#
##################################################
#
import numpy as np
import matplotlib.pyplot as plt
import csv,datetime
#
################################################
# Data File Reader
################################################
#
#
csv_filename ='./arduino_data_2020_10_31_13_52_15.csv'
data = [] # data vector for storing values
with open(csv_filename,'r') as csvfile:
reader = csv.reader(csvfile,delimiter=',')
header = next(reader)[0].split(',') # header info
for row in reader:
data.append([float(ii) for ii in row]) # append data into array
data = np.array(data) # put into numpy array
# scale voltage based on 4.2V peak:
data[:,3] = (4.2/np.nanmax(data[:,3]))*data[:,3] 
start_indx = 0 # start index
end_hour = 6 # hour when charging stops
end_indx = int(end_hour*(3600.0)) # end index 
data = data[start_indx:end_indx,:] # clip data
#
################################################
# Plot Routine 
################################################
#
plt.style.use('ggplot') # visual formatting
fig = plt.figure(figsize=(14,9)) # open figure
ax = fig.add_subplot(111) # add subplot
t_vec = data[:,0] # time vector 
t_diffs = np.append(0.0,np.diff(t_vec)) # finding spikes
t_vec/=(3600.0)
lines,lines_leg = [],[]
for ii in range(1,np.shape(data)[1]):
plot_data = data[:,ii] # variable (currrent, voltage, etc.)
y_diffs = np.abs(np.append(0.0,np.diff(plot_data))) # de-spike
if ii==2: # place current to other side of x-axis
current_label_color = plt.cm.Set1(0)
ax2 = ax.twinx() # move current to other side of axis
ax2.plot(t_vec,plot_data,label=header[ii],
color=current_label_color,linewidth=3.5) # current plot
ax2.set_ylabel('Current [mA]',fontsize=16,color=current_label_color)
ax2.tick_params(axis='y',colors=current_label_color)
ax2.spines['right'].set_color(current_label_color)
ax2.grid(False)
else:
current_label_color=plt.cm.Set1(ii)
ax.plot(t_vec,plot_data,label=header[ii],
color=current_label_color,linewidth=3.5) # voltages
lines.append(plt.Line2D([0],[0],color=current_label_color,
label=header[ii]))
ax.legend(handles=lines,bbox_to_anchor=(0.7,0.5,0.25,0.25),
fontsize=14) # plot legends 
ax.set_ylim([2.5,6.0]) # set voltage axis bounds
ax2.set_ylim([0.0,2200.0]) # set current axis bounds
ax.set_xlabel('Time [hours]',fontsize=16)
ax.set_ylabel('Voltage [V]',fontsize=16)
fig.savefig('V25_charge_cycle_readouts.png',dpi=300,bbox_inches='tight')
plt.show()