Design and Implementation of an Automated Battery Balancing Module in Electric Car Battery

Management System Using Alternating Capacitor Connection

A Thesis Topic Proposal
Presented to the Faculty of the
Department of Electronics and Communication Engineering
College of Engineering, De La Salle University








In Partial Fulfillment of
The Requirements for the Degree of
Bachelor of Science in Computer Engineering






by:

CHUA, John Robert B.
CHUA, Lawrence S.
DE GUZMAN, Carlo M.
LIM, Chester C.
UTTOH, Benjamin O.

March, 2014


1. INTRODUCTION
1.1 Background of the Study
The most troublesome part of current electric vehicle implementations is the
battery module. Current batteries are yet to be optimized for larger capacity so as to gain
the ability of powering an electric car that matches that of gasoline powered cars.
Chemical engineers have developed various types of batteries for different uses but a
better battery is yet to be developed (Hettrich, 2014).
Engineers are in the pursuit of making current battery systems safer and more
efficient. Optimization of the battery management system of an electric vehicle is a
remedy for the lack of capacity a battery has. Methods such as battery characterization
are being implemented so as to pair up the batteries that have the most similar
characteristics thus resulting to a more efficient system. In addition, some electric car
systems can be quite problematic because of the lack of inherent safety features in its
battery management system.
Battery balancing modules improves both efficiency and safety by continuously
equalizing paired batteries while the car is running.
1.2 Statement of the Problem
Battery balancing is often done once before a battery module would be used in an
electric car. This does not solve the problem of two paired batteries becoming unbalanced
for a certain period of time rendering it inefficient and less safe. An automated
implementation that would implement the use of MOSFETS and capacitors would enable
the module to be balanced while the car is running.



1.3 Objectives
1.3.1 General Objectives
To design implement an automated battery balancing module that can improve
battery lifespan, safety, and overall performance.
1.3.2 Specific Objectives
1.3.2.1 To implement the fast switching of the balancing capacitor using MOSFET.
1.3.2.2 To determine the optimal capacitor and MOSFET specification to be used.
1.3.2.3 To implement a voltage monitoring module using Android.
1.3.2.4 To optimize the balancing frequency using a PIC microcontroller.
1.3.2.5 To test the lifespan, safety and overall performance of the entire module by
means of comparison to current systems.
1.4 Scope and Delimitation
The study will include testing the devised module in three cases, immediate
charging at 75% minimum capacity, 50% minimum capacity, and 25% minimum
capacity. These conditions will be tested until the battery balancing operation gains
optimal efficiency. The group will be constrained to ideal conditions and will not
simulate the strains of actual vehicle testing. The group will devise a scaled down battery
system for the balancing module to test on. The testing would be implemented with
working standards of measurement.
1.5 Significance of Study
Nowadays, air pollution, emitted by automobiles, is the number one contributor
on destroying the environment. To prevent this issue, electric cars has been developed to
be an alternative for engine powered vehicles to lessen the pollution produced from
vehicles. Unfortunately, the number one problem of electric cars are their batteries.
Batteries have different charge and discharge rate. Thus, batteries can be over discharged
and malfunction which can cause the system to fail. To prevent this from happening, an
active balancing methods has been deduced. This will ensure that the pack of batteries
will always have the same voltage level without the big energy loss that passive
balancing wastes. Furthermore, active balancing does not only prevent batteries from
getting over discharged but it will also improve the lifespan of the whole battery pack and
will ensure safety as it will prevent the failing of each individual batteries in the pack.
1.6 Description of Project
1.6.1 Block diagram

Figure 1: Block diagram of the proposed battery balancing system

The 9 batteries were grouped in three paralleled connections hence 3P. Then the
three 3Ps would be put in series to attain 12.6V. Each of the three groups are controlled
with a slave and each of the slaves is controlled by the master module. The capacitor
switching occurs when the master sends a command to the specific slave. The slave then
controls the circuit which balances the batteries.
1.6.2 Flowchart
The master module initiates the i2c connection then waits for response of the
slaves which sends out the voltage of the batteries. This is followed by the master module
which checks whether the voltage levels of paired batteries are equal, if they are equal,
the master calls the interrupt and will wait for a certain interval before it checks again, if
not the master module sends out a command to the slaves which balances the batteries.












Figure 2: Flowchart of the proposed system


1.7 Methodology
The testing of the system will be carried out in different cycles and conditions. The cycles
will be performed with the following durations:
- 75% capacity
- 50% capacity
- 25% capacity

Different capacitor models will be tested in order to obtain the optimal balancing
efficiency of the system. Lifespan and safety will be taken into consideration when
choosing the capacitor. The data acquisition system will be carried out by the individual
slave's current, voltage and temperature sensors. The derived system will be compared to
existing researches. The group will implement a test bench that will simulate the load in
typical electric car systems wherein the consumption of the power will vary. The data
will be evaluated with the following parameters:
- Accuracy of balancing.
- Precision.
- Comparison to existing researches.





1.8 Gantt Chart
1.8.1 Chua, John Robert B.

1.8.2 Chua, Lawrence S.

1.8.3 De Guzman, Carlo M.

1.8.4 Lim, Chester C.


1.8.5 Uttoh, Benjamin O.



1.9 Estimated Budget of the Project
Table 1: Estimated budget proposal for the entire system
Materials Quantity Price
Molicel IBR18659BC 9 P 1350.00
Presentized PCB 2 P 500.00
PIC16F877A 1 P 250.00
PIC16F88 3 P 450.00
Miscellaneous Components N/A P 200.00
Total P 2750.00











2. LITERATURE REVIEW
There is an abundant amount of related literature regarding battery balancing methods
and the method that the researchers are trying to implement. Related literature can be
seen way back to the year 1993 when a research was conducted in order to extend battery
life by charge equalization [1]. This meant that the battery was to be controlled in its
charging so that it doesn't overcharge so as to extend battery life. Cell balancing among
groups of batteries which should share the same characteristics and are in parallel was
also said to be effective in extending the capacity and life span of the battery [2]. Electric
Vehicles, or EVs, use paralleled battery packs that are connected in series to reach a
certain current and voltage respectively. The researchers are attempting to implement an
efficient battery balancing method for the batteries per pack in order to make them last
longer, parallel to the goal of Cao, Schofield and Emedi in their study [3]. Currently
implemented in the Electric Vehicle's battery is the passive balancing method, where a
resistor is used to dissipate extra energy. In this research, the goal of active battery
balancing methods serve as an inspiration to implement a new style of battery balancing
which may be simpler than the methods mentioned in the past experiments done by
researchers [4]. The batteries are lithium ion batteries, where readings on past research by
Chang et al. and Lee et al. provide the constraints of where the new battery balancing
method has to fit in [5][6]. For the design method, inspiration comes from Mohamed et.
al and Baughman et. al in their research of single and double switched capacitor for
battery balancing [7][8]. Performance evaluation of previous battery balancing methods
were done by Daowd et. al which was implemented in Matlab [9]. Preindl, Danielson and
Burrelli also provided the researchers the overview and insights into the currently
implemented battery balancing methods [10]. Finally, Hettrich discusses in his paper the
challenge that Electric Vehicles are deemed to take, wherein battery life among other
problems, are discussed [11]. He provided floating solutions in order to serve as
pathways for future researchers to take.





















3. THEORETICAL CONSIDERATIONS
3.1. PIC programming and Implementation of I2C system management bus
An integrated circuit is an electronic component that consists of several electric
circuits that are compacted together to form small single chip. These integrated circuits
are very independent that every electronic device has been using it. Most of these
integrated circuits performs a specific task but some integrated circuits can be
programmed by the use of a programming software installed on a computer and a
programming device. This programmable integrated circuits is very popular because of
its multiple features, low power consumption, and usually has low cost. The
programming language that will be used depends on the user whether it is high level
programming or assembly programming.
When programming a programmable integrated circuit, or commonly known as
PIC, configurations, e.g. what range of the oscillator is being used, are need to be set.
Because of its multiple features, pin configurations are needed to be set. These pin
configurations whether the pin is used as an input/output, analog-to-digital conversion,
pulse-width-modulation, communication such as UART, SPI, I2C and CAN, and many
more.

The I2C bus system is comprised of two lines, the SDA and the SCL line. These
two lines are used to synchronize all data transfers in the I2C bus. SCL is the clock line
that synchronizes the all the devices on your bus and the SDA line serves as the data line.
One notable thing about I2C is that both SCL and SDA lines are open drain drivers
which means that the chip can drive its output low but not high. With this in hand, a
single pull up resistor must be provided for both lines. The value of the pull up resistors
may range from 1.8kOhm to 47kOhm.
Devices in the I2C bus are categorized into two, namely the master and the slave.
Typically, there is only one master and multiple slaves, but multi-master systems are also
being done but will not be covered by this paper. Slaves can never initiate data transfer
over the I2C bus, only the master can do this. A transfer is initiated by the master through
a start sequence. A demonstration of the start and stop sequence clocking is shown in
figure x below.

Figure 3: Timing diagram of I2C start and stop sequence
Data transfer is transmitted in lengths of 8 bits, but an acknowledge bit is always
followed by the 8 bit data, so practically speaking, each data transfer consists of 9 bits.
The maximum clock speed is defined by the device that will be used and the application
of the system. A 7 bit addressing mode will be used as the complexity of a 10 bit
addressing mode is not required, this means that the system can have a total of 127
slaves. The 7 bit address is followed by a R/W bit that denotes whether the master is
reading or writing to the slave. An acknowledge bit is also present in the 9
th
bit.




3.2 Cell Balancing
Cell balancing is a technique that improves efficiency, lifetime, and maximizes
battery capacity. A battery balancer, which is usually a relay or high powered transistors
such as MOSFET performs the balancing by switching charges from one cell to
another. Typically, individual cells in a battery pack have different capacities and
state of charge even though it is manufactured by same machine. Without active cell
balancing, a battery pack will stop functioning or discharging once the cell with the
lowest capacity in the pack becomes empty even when the other cells are still not empty.
To prevent this and maximize the battery life, the battery balancer will discharge the cell
with the highest state of charge and use it to charge the lowest state of charge so that
when the two cells become equal, both will reach zero level at the same time.

3.3 Fast Switching Devices
The research study aims to use fast switching devices in order to implement the
said active battery balancing method. MOSFETs or Metal Oxide Semiconductor Field
Effect Transistors are utilized because they have certain advantages over other electronic
switching devices like relays and BJTs. One big difference between MOSFETs and
Relays are their switching speed. Comparing a mechanical relay to MOSFET, switching
speed of the MOSFET is faster and more reliable than a relay's. A solid state relay may
be faster, but its internal workings are composed of several MOSFETs. Such complexity
would only allow it to run slower than one single MOSFET. A BJT can be compared as a
switching device, but its unstable characteristics of relying on current would render it
much harder to control than a MOSFET which entirely relies on voltage. MOSFET
switching is done by having a voltage between the gate and the source. This would
depend on whether an N or a P channel MOSFET is to be used. An N channel MOSFET
would use a positive voltage between the gate and the source in order to activate said
MOSFET, while a P channel MOSFET would use a negative voltage. Such application in
active battery balancing would use one or both kinds of MOSFETs in order for it to be
implemented.

3.4. Battery and Capacitor Characteristics and Behavior
The said research study will be utilizing a Li-ion type battery for the
implementation of active cell balancing. The battery model that will be used is
IBR18650BC from Molicel with a nominal voltage of 3.6 Volts and has a typical
capacity of 1500mAh. Batterys measurement of stored energy is referred to as State-of-
Charge (SoC) and is expressed in percentage with 100% as a representation of a fully
charged battery. Typically, batteries should not be charged above 80% SoC to prevent
stress to the battery and prolong its life. If ever a fully charged battery is desired, the
charging process should observe its saturation time which is the time needed for the
battery to still acquire more charge despite the fact that it already matched the set
charging voltage. It is also advisable to leave the batteries at around 50% SoC during
long-time storage to minimize stress on the battery while still providing enough charge
for its leakage current. Li-ion batteries are also sensitive to over-discharge and should not
be left in storage with SoC below 20%. In case the battery was over-discharge, it should
immediately be charged up to its working voltage range or else it will be permanently
damaged.
The capacitors that will be used in the said research study will vary depending on
the demands of the battery and the circuit that will be implemented. Ideally, it should
have enough capacitance to properly and effectively charge and discharge the batteries
with taking into account the frequency of the switching between the batteries. Using
capacitors as a temporary storage of energy provides an excellent job as it can charge and
discharge at a very high current. This means that the batteries can be balanced at a fast
rate given that the system demands a high frequency switching to the capacitor since it
can easily handle the fast transition of energy from one battery to another. The capacitor
selection for the active balancing will not only take into account its rated capacitance and
voltage but also the manufacturer of the capacitor to fully obtain the best capacitor for the
said application.
3.5 Android Interface
The research study also will utilize Android technology as a tablet will be used in
order to display voltage levels in the pack to be balanced. A tablet will be used in order to
display the output. Android technology can be used in such applications because it can be
connected to the circuit via a microcontroller which would send pulses for the device to
interpret. A program will be used to decode such pulses and interface it into a GUI which
can be read by the user.



4. DESIGN CONSIDERATIONS
4.1 Pseudo code
4.1.1 ADC pseudo code
The ADC initialization is required so as to acquire data from the battery balancing
module. This is required so as to read the voltage levels of individual batteries.
Void ADC_init(){
adcon0 = 0x01; //sets ADC acquisition
adcon1 = 0x00; //line,adc pin
adcon2 = 0x3E; //+ - vref
unsigned char ADC_getpin (unsigned charpin){
adcon00 = 0x01;
adcon01 = pin<<z;
_delay_us(1000); //wait until cap is charged
go=1;
while(go);
return adresh; // returns 8 bit data gathered from ADC}
4.1.2 I2C pseudo code initialization
This code snippet is to initialize the communications mode of the entire system.
Initi2c(){
Int scl = 0; //initialize clock line
Int sda = 0; //initialize data line
Int data[8] = 00000000; //initialize data pin
Int address[8] = 00000000; //initialize address pin
}

4.2 Schematic Diagram

Figure 4: schematic diagram of the battery balancing module
4.3 Block Diagram

Figure 5: A more detailed block diagram of the proposed battery balancing module.
The block diagram shows the setup of the whole system. 3 sets of 3 batteries are
connected in parallel so as to obtain a certain voltage rating and current rating. Each set is
connected to a slave which is basically a voltage reader that utilizes the analog to digital
conversion function of the PIC microcontroller. From there, data is gathered from the
slaves to the master using the I2C protocol. A bus is needed for the data bits to travel
from the slaves to the master. The master is the one that gathers the data. The process
works in the following manner: the master module will tell the slaves that something is
not balanced, and the slaves will correct it by themselves. Data collected is sent thru the
Universal Asynchronous Receiver/Transmitter Protocol to a USB-UART Module which
can communicate with the Android Device so that it can display the output in the tablet.

5. DATA AND RESULTS
Data collection
Data collection is implemented together with the Android display in the tablet. An excel
spreadsheet is provided together with the program in order to collect and save data for later
analysis. From the circuits, the master module will provide data display from the slaves and
transmit it using the USB-UART module. Bit stream is interpreted by the Android device for
display and data is also saved into the spreadsheet where quantitative data regarding different
parameters like voltage, temperature among others are arranged in columns.
Model

Figure 6: Model of the Battery Balancing Module
Parts list I2c Codes New pics android codes android scrnshot
Data:

Figure 7: Schematic model of the Bidirectional MOSFET

Figure 8: Actual Implementation of the Schematic Diagram






3.9
3.95
4
4.05
4.1
4.15
4.2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
V
o
l
t
a
g
e

(
V
)

Time (mins)
Voltage vs Time for 100 uF (50 ms switching time)
B1 B2 B3
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5
1 2 3 4 5 6
V
o
l
t
a
g
e

(
V
)

Time (mins)
Voltage vs Time for 100 uF (100 ms switching time)
B1 B2 B3


3.3
3.4
3.5
3.6
3.7
3.8
3.9
4
4.1
4.2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
V
o
l
t
a
g
e

(
V
)

Time (mins)
Voltage vs Time for 1 mF (50 ms switching time)
B1 B2 B3
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5
1 2 3 4 5 6 7 8
V
o
l
t
a
g
e

(
V
)

Time (mins)
Voltage vs Time for 10 uF (50 ms switching time)
B1 B2 B3










3.4
3.5
3.6
3.7
3.8
3.9
4
4.1
4.2
1 2 3 4 5 6 7 8
V
o
l
t
a
g
e

(
V
)

Time (mins)
Voltage vs Time for 1 uF (50 ms switching
time)
B1 B2 B3
Table 1: Testing for Battery Internal Resistance
Battery Voltage Load (2.5
ohms)
I, 2.5
ohms
Load (2.5
ohms)
I, 2.5
ohms
1 3.834 3.68 V 1.3 A 3.821 V 0.86 A
2 3.948 3.824 V 1.36 A 3.931 V 1.47 A
Formula for computation of Internal Resistance:

Battery 1:



Battery 2:



Therefore, R
total
= 120 m + 90 m = 210 m.
Maximum voltage tested = 4.045 Volts.


= 19.262 A.
Therefore, MOSFET saturation current >> 19.262 A.

F
i
g
u
r
e

9
:

S
c
h
e
m
a
t
i
c

D
i
a
g
r
a
m

o
f

t
h
e

S
i
m
u
l
a
t
e
d

C
i
r
c
u
i
t


Figure 10: Actual Implementation of the Circuit Version 1

Figure 11: Actual Implementation of the Circuit Version 2
I2C Communications:
The data of the voltage and temperature of the battery are being collected by converting their
analog data into digital by the Analog-to-Digital Conversion of the pic. As soon as the data is
collected, the pic connected to the battery, which is called Slave, will send it to another pic,
called Master, using Inter-Integrated Circuit or commonly known as I2C. The Master will begin
by sending a start bit followed by SSPADD. The SSPADD determines the address of the slave
and whether the Master wants to Read from or Write to the Slave. If the address sent by the
master is equal to the slave, an acknowledgement will be sent by the Slave. Then, the data will
be sent by the slave. When the data is sent, the Master will now send an acknowledgement to the
Slave for it to know that the data was accepted. A stop bit will also be sent by the master to end
the transmission.

I2C Slave Code:
/*
* File: i2cSlave_pic16f1823.c
* Author: carlo
*
* Created on March 1, 2014, 3:09 PM
*/

#include <stdio.h>
#include <stdlib.h>
#include <xc.h>
#include <pic16f1823.h>
/*
#pragma config FOSC = INTOSC
#pragma config PWRTE = ON
#pragma config LVP = OFF
#pragma config WDTE = OFF
#pragma config CP = OFF
*/

__CONFIG (FOSC_INTOSC & WDTE_SWDTEN & PWRTE_ON & MCLRE_ON & CP_OFF &
CPD_OFF & BOREN_OFF & CLKOUTEN_OFF & IESO_OFF);
__CONFIG (FCMEN_OFF & WRT_OFF & PLLEN_OFF & STVREN_OFF & LVP_OFF );

#define ADDRESS_I2C 0x30

/*
*
*/
unsigned char dummy;

void interrupt isr();
main(){
// initialization
// internal oscillator
//set to 8MHz
IRCF3 = 1;
IRCF2 = 1;
IRCF1 = 1;
IRCF0 = 0;
//set system clock select bits to internal osc
SCS1 = 1;
SCS0 = 0;
// i2c slave init
TRISC = 0x03; // Make i2c pins input
SSP1CON1 = 0b00110110; // Enable MSSP module as I2C slave w/
7bit addr
SSP1CON3bits.SDAHT = 1; // 300ns hold time on SDA after SCL
falling edge
SSP1CON3bits.AHEN = 1; // Address Hold Enable
SSP1ADD = (ADDRESS_I2C<<1); // Slave Address
GIE = 1;
PEIE = 1;
SSP1IE = 1; // Enable interrupts
SSP1IF = 0;
TRISA = 0;
//SSP1MSK = 0xFE;

while(1);
}

void interrupt isr(){
if(SSP1IF){

if(1){
// State 1: Write operation, last byte was an address
if(!R_nW && !D_nA && BF){
SSP1IF = 0;
dummy = SSP1BUF;
//I2C_var1 = 0;
CKP = 1;
}
// State 2: Write operation, last byte was an data
else if(!R_nW && D_nA && BF){
SSP1IF = 0;
//I2C_receiveArray[I2C_var1++] = SSP1BUF;
CKP = 1;
}
// State 3: Read operation, last byte was an address
else if(R_nW && !D_nA){
SSP1IF = 0;

dummy = SSP1BUF;
//I2C_var2 = 0;
SSP1BUF = 0x04;
CKP = 1;
}
// State 4: Read operation, last byte was an data
else if(R_nW && D_nA && !BF){
// RC4 = 0;
SSP1IF = 0;
SSP1BUF = 0x01;

CKP = 1;
}
// State 5: Slave I2C logic reset by NACK from master
else if(D_nA && !BF && CKP){

}
}
}
}












I2C Master Code:
/*
* File: i2cMaster.c
* Author: carlo
*
* Created on February 25, 2014, 8:44 PM
*/

#include <stdio.h>
#include <stdlib.h>
#include <pic16f877a.h>
#include <xc.h>

#pragma config FOSC = HS
#pragma config PWRTE = ON
#pragma config LVP = OFF
#pragma config WDTE = OFF
#pragma config CP = OFF

#define _XTAL_FREQ 16000000
#define CLOCKSPEED 1000
#define BAUDRATE 19200
#define CTRLIN 0XA0 // Control In Byte
configures the EEPROM to be in input mode
#define CTRLOUT 0XA1 // Control Out Byte
configures the EEPROM to be in output mode
#define TEST_PIC
#define I2C_DEBUG



void wait_SSPIF();
void init_I2C();
void init_UART();
void sendByte_I2C(unsigned char TX);
void UART_send(unsigned char data);
void dispError();
void errorCheck_I2C();
unsigned char readFrom_PIC(unsigned char ctrl);
unsigned char readFrom_EEPROM(unsigned char ctrl, unsigned char
address);
void writeTo_PIC(unsigned char ctrl, unsigned char data);
void writeTo_EEPROM(unsigned char ctrl,unsigned char address, unsigned
char data);
void UART_sendString(unsigned char* data);
void UART_sendHex(unsigned char data);
void UART_sendBytes(unsigned char* data, unsigned char num);

main(){
init_I2C();
init_UART();
//while(1) UART_send('A');
#ifdef TEST_EEPROM
TRISB = 0;
PORTB = 0;
//writeTo_EEPROM(1,0,0x12);
//writeTo_EEPROM(0,0,0x21);
while(1){
PORTB = readFrom_EEPROM(1,0);
__delay_ms(500);
}
//PORTB = readFrom_EEPROM(0,0);
#endif

#ifdef TEST_PIC
TRISB = 0;
PORTB = 0;
while(1){
readFrom_PIC(0x30);
__delay_ms(1000);
}
#endif


}

void init_I2C(){
SSPSTAT = 0x80;//10X0 0000 SMB off & SMP std mode
SSPCON = 0x28;//0X1X 1000 SSPEN on & Master mode
SSPADD = (_XTAL_FREQ/(4*CLOCKSPEED)) - 1;
TRISC = 0B00011000;
SSPIF = 0;
}
void init_UART(void){
//sync =1 syncro, sync = 0 ascn
// spen = 1;
// 8 bit

/* TRISC6 = 0;
TRISC7 = 1;
SPBRG = 129;
BRGH = 1;
TXSTA = 0x24; //00100100
RCSTA = 0x90;
*/
SPEN = 1;
CREN = 0;
ADDEN = 0;
TXSTA = 0b00100100;
// SPBRG = 129;
TRISC6 = 0;
TRISC7 = 1;
//SPBRG = (_XTAL_FREQ/(16*BAUDRATE))-1;
SPBRG = 51;
}

void UART_send(unsigned char data){

while(!TXIF);
TXREG = data;
}

/*Reading from PIC*/
unsigned char readFrom_PIC(unsigned char address){

unsigned char read_ctrl = (address<<1) | 1;
//read_ctrl =| 1;

unsigned char read_bat = 0x00;

#ifdef I2C_DEBUG
UART_sendString("\r\nI2C Master Read\r\n");
UART_sendString("Start Condition\r\n");
#endif
/*Start*/
RSEN = 1;
wait_SSPIF();
#ifdef I2C_DEBUG
UART_sendString("Sending Start bit was successful!\r\n");
UART_sendString("Sending address..\r\n");
#endif
/*Control Byte*/
sendByte_I2C(read_ctrl);
wait_SSPIF();
//errorCheck_I2C();
#ifdef I2C_DEBUG
UART_sendString("Adress sent\r\n");
#endif
#ifdef I2C_DEBUG
if(ACKSTAT){
UART_sendString("Slave Acknowledge failed\r\n");
return 0;
}
#endif


#ifdef I2C_DEBUG
UART_sendString("Slave Acknowledge was successful!\r\n");
UART_sendString("Start Receiving data\r\n");
#endif
/*Start Receive*/
RCEN = 1;
wait_SSPIF();

read_bat = SSPBUF;
#ifdef I2C_DEBUG
UART_sendString("Data was received successfully!\r\n");
UART_sendString("Data was:\r\n");
UART_sendHex(read_bat);
UART_sendString("\r\nSending Acknowledgement\r\n");
#endif
ACKDT = 1; //ACKDT is originally = 0
ACKEN = 1; //Send Acknoweldge bit
wait_SSPIF();
#ifdef I2C_DEBUG
UART_sendString("Acknowledgement sent!\r\n");
UART_sendString("Sending Stop bit\r\n");
#endif
/*Stop*/
PEN = 1;
wait_SSPIF();
#ifdef I2C_DEBUG
UART_sendString("SUCCESSFULY READ from Slave\r\n");

#endif



return read_bat;


}
unsigned char readFrom_EEPROM(unsigned char ctrl, unsigned char
address){

unsigned char ctrl_in = CTRLIN | (ctrl<<1);
unsigned char ctrl_out = CTRLOUT | (ctrl<<1);
unsigned char read_bat;
/*Start*/
RSEN = 1;
wait_SSPIF();
/*Send Control IN*/
sendByte_I2C(ctrl_in);
wait_SSPIF();
errorCheck_I2C();
/*Send address*/
sendByte_I2C(address);
wait_SSPIF();
errorCheck_I2C();

RSEN = 1; // Sends Restart Bit so that EEPROM
will distinguish that the next data byte will be a control byte.
wait_SSPIF(); // Wait until tranmission is
finished.
/*Send Control OUT*/
sendByte_I2C(ctrl_out);
wait_SSPIF();
errorCheck_I2C();

/*Start Receive*/
RCEN = 1;
wait_SSPIF();

ACKDT = 0; //NACK bit
ACKEN = 1; //Send Acknoweldge bit

/*Stop*/
PEN = 1;
wait_SSPIF();

//read_bat = SSPBUF;

return SSPBUF;

}

/*Writting to EEPROM*/
void writeTo_EEPROM(unsigned char ctrl,unsigned char address, unsigned
char data){

unsigned char ctrl_in = CTRLIN | (ctrl<<1);
unsigned char ctrl_out = CTRLOUT | (ctrl<<1);
/*start*/
SEN = 1;
wait_SSPIF();
/*Send control*/
sendByte_I2C(ctrl_in);
wait_SSPIF();
errorCheck_I2C();
/*Send Address*/
sendByte_I2C(address);
wait_SSPIF();
errorCheck_I2C();
/*Send data*/
sendByte_I2C(data);
wait_SSPIF();
errorCheck_I2C();
/*Stop*/
PEN = 1;
wait_SSPIF();
__delay_ms(1);
return;
}

/*Writting to PIC*/
void writeTo_PIC(unsigned char ctrl, unsigned char data){
/*Start*/
SEN = 1;
wait_SSPIF();

/*Send Ctrl*/
//sendByte_I2C();
wait_SSPIF();
errorCheck_I2C();
/*Send data*/
//sendByte_I2C();
wait_SSPIF();
errorCheck_I2C();
/*Stop*/
PEN = 1;
wait_SSPIF();
return;
}

/**/
void wait_SSPIF(){
while(!PIR1bits.SSPIF);
PIR1bits.SSPIF = 0;
}
void sendByte_I2C(unsigned char TX){
SSPBUF = TX;
}

void errorCheck_I2C(){
if(ACKSTAT) dispError();
}

void dispError(){

PORTB = 0xFF;
while(1);
}
void UART_sendString(unsigned char *data){
while(*data!=0)
UART_send(*data++);
}

void UART_sendHex(unsigned char data){
char buffer[2];
for(int i=1; i>=0; i--){
if(data%16 < 10)
buffer[i] = (data%16 + 48);
else
buffer[i] = (data%16 - 10 + 'A');
data/=16;
}
UART_sendBytes(buffer,2);
}
void UART_sendBytes(unsigned char *data, unsigned char num){
for(int i=0;i<num;i++)
UART_send(*data++);
}

Android Application UI:

Figure 12: Android User Interface Version 1
Android Application Code:
package com.prolific.pl2303hxdsimpletest;


import java.io.IOException;
import java.util.Arrays;
import java.util.Random;

import tw.com.prolific.driver.pl2303.PL2303Driver;
import tw.com.prolific.driver.pl2303.PL2303Driver.DataBits;
import tw.com.prolific.driver.pl2303.PL2303Driver.FlowControl;
import tw.com.prolific.driver.pl2303.PL2303Driver.Parity;
import tw.com.prolific.driver.pl2303.PL2303Driver.StopBits;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.hardware.usb.UsbManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.preference.PreferenceManager;
import android.text.format.Time;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

public class ActiveBalancing extends Activity {
PL2303Driver mSerial;

private Button btn_Refresh;
private TextView txt_Voltage;

private int mDisplayType = DISP_CHAR;
private int mReadLinefeedCode = LINEFEED_CODE_LF;
private PL2303Driver.BaudRate mBaudrate =
PL2303Driver.BaudRate.B9600;
private PL2303Driver.DataBits mDataBits =
PL2303Driver.DataBits.D8;
private PL2303Driver.Parity mParity = PL2303Driver.Parity.NONE;
private PL2303Driver.StopBits mStopBits =
PL2303Driver.StopBits.S1;
private PL2303Driver.FlowControl mFlowControl =
PL2303Driver.FlowControl.OFF;

private static final String ACTION_USB_PERMISSION =
"com.prolific.pl2303hxdsimpletest.USB_PERMISSION";

public int PL2303HXD_BaudRate;
public String PL2303HXD_BaudRate_str="B4800";

private String strStr;

@Override
public void onCreate(Bundle savedInstanceState) {
Log.d(TAG, "Enter onCreate");

super.onCreate(savedInstanceState);
setContentView(R.layout.activity_pl2303_hxdsimple_test);
Button mButton01 = (Button)findViewById(R.id.button1);
mButton01.setOnClickListener(new Button.OnClickListener() {

public void onClick(View v) {
openUsbSerial();
}
});
mSerial = new PL2303Driver((UsbManager)
getSystemService(Context.USB_SERVICE),
this, ACTION_USB_PERMISSION);

if (!mSerial.PL2303USBFeatureSupported()) {

Toast.makeText(this, "No Support USB host API",
Toast.LENGTH_SHORT)
.show();

Log.d(TAG, "No Support USB host API");

mSerial = null;

}

Log.d(TAG, "Leave onCreate");
}//onCreate

protected void onStop() {
Log.d(TAG, "Enter onStop");
super.onStop();
Log.d(TAG, "Leave onStop");
}

@Override
protected void onDestroy() {
Log.d(TAG, "Enter onDestroy");
if(mSerial!=null) {
mSerial.end();
mSerial = null;
}
super.onDestroy();
Log.d(TAG, "Leave onDestroy");
}

public void onStart() {
Log.d(TAG, "Enter onStart");
super.onStart();
Log.d(TAG, "Leave onStart");
}

public void onResume() {
Log.d(TAG, "Enter onResume");
super.onResume();
String action = getIntent().getAction();
Log.d(TAG, "onResume:"+action);

//if (UsbManager.ACTION_USB_DEVICE_ATTACHED.equals(action))
if(!mSerial.isConnected()) {
if (SHOW_DEBUG) {
Log.d(TAG, "New instance : " + mSerial);
}

if( !mSerial.enumerate() ) {

Toast.makeText(this, "no more devices found",
Toast.LENGTH_SHORT).show();
return;
} else {
Log.d(TAG, "onResume:enumerate succeeded!");
}
}//if isConnected
Toast.makeText(this, "attached",
Toast.LENGTH_SHORT).show();

Log.d(TAG, "Leave onResume");
}
private void openUsbSerial() {
Log.d(TAG, "Enter openUsbSerial");
if(null==mSerial)
return;

if (mSerial.isConnected()) {
if (SHOW_DEBUG) {
Log.d(TAG, "openUsbSerial : isConnected ");
}
String str =
PL2303HXD_BaudRate_spinner.getSelectedItem().toString();
int baudRate= Integer.parseInt(str);
switch (baudRate) {
case 9600:
mBaudrate = PL2303Driver.BaudRate.B9600;
break;
case 19200:
mBaudrate =PL2303Driver.BaudRate.B19200;
break;
case 115200:
mBaudrate =PL2303Driver.BaudRate.B115200;
break;
default:
mBaudrate =PL2303Driver.BaudRate.B9600;
break;
}
Log.d(TAG, "baudRate:"+baudRate);
// if (!mSerial.InitByBaudRate(mBaudrate)) {
if (!mSerial.InitByBaudRate(mBaudrate,700)) {
if(!mSerial.PL2303Device_IsHasPermission()) {
Toast.makeText(this, "cannot open, maybe no
permission", Toast.LENGTH_SHORT).show();
}

if(mSerial.PL2303Device_IsHasPermission() &&
(!mSerial.PL2303Device_IsSupportChip())) {
Toast.makeText(this, "cannot open, maybe
this chip has no support, please use PL2303HXD / RA / EA chip.",
Toast.LENGTH_SHORT).show();
}
} else {
Toast.makeText(this, "connected",
Toast.LENGTH_SHORT).show();
}
}//isConnected

Log.d(TAG, "Leave openUsbSerial");
}//openUsbSerial

private void readDataFromSerial() {

int len;
byte[] rbuf = new byte[4096];
StringBuffer sbHex=new StringBuffer();

Log.d(TAG, "Enter readDataFromSerial");

if(null==mSerial)
return;

if(!mSerial.isConnected())
return;

len = mSerial.read(rbuf);
if(len<0) {
Log.d(TAG, "Fail to bulkTransfer(read data)");
return;
}

if (len > 0) {
if (SHOW_DEBUG) {
Log.d(TAG, "read len : " + len);
}
for (int j = 0; j < len; j++) {

sbHex.append((char) (rbuf[j]&0x000000FF));
}
txt_Voltage.setText(sbHex.toString());
Toast.makeText(this, "len="+len,
Toast.LENGTH_SHORT).show();
}
else {
etRead.setText("empty");
return;
}

try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}

Log.d(TAG, "Leave readDataFromSerial");
}//readDataFromSerial


References:
[1] S.T. Huang, D. C. Hopkins, C.R. Mosling, Extension of battery life via charge
equalization control, IEEE Trans. Ind. Electron., vol.40, no.1, February 1993.
[2] S. Wen, Cell Balancing buys extra run time and battery life, Analog Applications
Journal, Texas Instruments Incorporated, March 2009.
[3] J. Cao, N. Schofield, A. Emadi, Battery balancing methods: A comprehensive
review, Proc, IEEE Ven. Power Propulsion Conf., Harbin, China, September 2008.
[4] J. Lonzano, E. Cadaral, M.I. Montero, M. Asmartinez, Battery Equalization active
methods, Journal of Power Sources, Vol. 246, January 2014.
[5] Y.N. Chang, Y.S. Shen, H.L. Cheng, S.Y. Chan, Design of active balance circuit
for lithium battery pack, Future Energy Electronics Conference, November 2013.
[6] Y. S. Lee, M. W. Cheng, "Intelligent Control Battery Equalization for Series
Connected Lithium Ion Battery Strings", IEEE Trans. on Industrial Electronics, Oct.
2005.
[7] D. Mohamed, A. Mailier, O. Noshin, P. Van den Bossche, J. Van Mierlo, Single
switched Capacitor Battery Balancing System Enhancements, energies, Vol. 6, April
2013.
[8] A.C. Baughman, M. Ferdowsi, Double-Tiered switched-capacitor battery charge
equalization technique, Industrial Electronics, IEEE transaction, Volume 55, June 2008.
[9] Y.J. Rong, C.Y. Hua, W.B. Tang, Charging and Discharging Equalization with
Improved switching Matrix for Series-Connected Battery Pack in EV, Applied
Mechanics and Materials, Vol. 260-261, December 2012.
[10] M. Daowd, N. Omar, P. Van Den Bossche, J. Van Mierlo, Passive and active
battery balancing comparison based on MATLAB simulation, Vehicle Power and
Propulsion Conference (UPPC), September 2011.
[11] M. Preindl, C. Danielson, F. Burrelli, Performance evaluation of battery balancing
hardware, Control Conference (ECC), July 2013.
[12] K. Hettrich, Transportations Battery Bottleneck: Context, Challenges, and Path
Forward, Stanford energy club, Issue 3, June 2013.