Author Archives: paynterf

New TP5100-based Battery Pack for Wall-E2

Posted 13 March 2018

In a recent post, I described my study of the widely available and dirt-cheap TP5100 1/2-cell LiPo battery charger as a possible replacement for my current Adafruit PB1000C-based battery charger.  Based on the results of this study, it was clear the TP5100-based system was superior in all respects to my home-brew system:

  • Twice the charge current (2A vs 1A) means significantly shortened charge times
  • Much smaller and simpler
  • Charger current path independent of load path – much lower IR drop
  • Battery always connected to the system, so no requirement for ultra-low-drop MOSFET diode
  • Much simpler software – no requirement to monitor status of two separate chargers
  • No electromechanical relay to screw up.

I constructed a small charger module using some perfboard and a couple of 2-place screw terminals, as shown below (with the previous module shown for size comparison).

New TP5100-based charger module, with previous Adafruit PB1000C-based module below for size comparison. The orange box contains 4 Panasonic 18650 cells.  Note the separate charge & load circuits

The following figures show the old and new schematics:

Old battery pack schematic

New battery pack schematic

Now that the load current doesn’t have to go through the charging module, I was able to replace all main battery wiring with #20 wire for lower IR drops, as shown below

Power wiring replaced with #20 wiring, and 2-pin Deans connectors

#20 wiring to main battery buss. Note in-line safety disconnect


The change to the new battery pack also considerably simplified the system hardware and software.  The changes to the system schematic are shown below:

Old system schematic. Note the ultra-low-drop MOSFET diode required to keep Arduino Mega alive during charge. and the number of pins required for charge monitoring.

New system schematic. No requirement for diode, as full battery voltage is available at all times. Also, only two pins are required for charge monitoring

The operating system software has also been simplified.  Now, instead of monitoring both cell voltages and four different status lines, only two lines have to be monitored.  Also, there is now no requirement to correctly sequence the ‘Charger Connect’ and ‘Coil Enable signals in order to accomplish correct charging station connect-disconnect behavior.  Now the system simply shuts off the motors when the robot connects to the station, and turns them back on again to disconnect.  As an added benefit, the six charge status LEDs have been repurposed to show a crude approximation (based on battery voltage only for the moment) of charge status.

All these changes have caused one minor hiccup in the implementation of the charging station; the new charging voltage is +12V vs +5V as before.  As you may recall, the charging station implements a square-wave modulated IR signal, and this signal is produced by a Teensy 3.2 and some associated circuitry, all of which expect +5V.  This will require either a dual-output supply, or the addition of an on-board 12-to-5V regulator. This is still up in the air, but I suspect it will land on a simple 3-pin regulator.

So far, all the hardware changes (except for the charging station changes) have been accomplished, but the software changes have yet to be implemented and tested. Stay tuned!



Bridge Game Reporter for Duplicate Bridge

Posted 10 March 2018


Some time ago I created Bridge Game Reporter (BGR), a wrapper for Ray Spalding’s wonderful Bridge Composer (BC) program, for the Columbus Bridge Center, our local bridge club.  Bridge Composer produces really nifty HTML and PDF reports of duplicate bridge games, but using it can become tedious, and non-technically-oriented bridge directors are prone to making mistakes when FTP’ing result files to a website.  So, my BGR program automates all that stuff and makes calls into the BC API to make the magic happen.  After the inevitable problems and issues, it seemed to be working fine at the CBC, and then Siraj Haji, owner/operator of the Aloha Bridge Club asked me if I would mind sharing the program with him.  Siraj had a slightly different setup, and rather than FTP’ing result files to a website, he wanted to email them to just those players who actually played in a particular game, so he and I worked out the strategy for using ACBL player numbers from session reports as a search key into a CSV-formatted email list.  After the usual number of mistakes, we got it working.  A few days later Siraj mentioned that he also uses Bridge Composer to generate game files for upcoming games, but it was somewhat tedious – could I maybe use my new-found BC superpowers to do something about that?  Well, it turns out that the BC guy (Ray Spalding) created a pretty nice API to BC, and provided a WScript/JScript example that did most of what we wanted.  After a few days of fumbling around, I figured out most of what was going on behind the curtains, and realized that I could fairly easily add a ‘game generation tool’ to my BGR app to add bulk game generation capabilities.  Again after the normal number of mistakes, Siraj reported that this feature seemed to be working – yay!

At some point in this process, after the email feature was added and before the bulk game generation feature, I got another request for the program from another club in the area, so I realized I was going to have to provide an actual installation program and some user documentation.  Since I already had this blog site, I decided to use it as the documentation vehicle.


Bridge Game Reporter Features:

  • Uses Ray Spalding’s Bridge Composer program, which must be installed and active for the magic to work.
  • Automates the process of calling Bridge Composer with the correct set of files for a particular game.
  • Optionally automates the process of FTPing Bridge Composer game summary and hand records to a selected website
  • Optionally automates the process of emailing results to a user-supplied list of email recipients
  • Automates the process of generating multiple games over a range of dates/times using the ‘Game Generation’ tool.

Main Page:

The main page of the Bridge Game Reporter program is shown below, along with a description of each control area.

Bridge Game Reporter main page

Game Date: The user selects the desired game date from a drop-down calendar display.  This date is used to construct the filename to be searched for. The file name format is in the form [yymmdd][session time].ext, where yy = year, mm = month, dd = day, session time = ‘M’ (Morning), ‘A’ (Afternoon), ‘E’ (Evening), or ‘L’ (Late).  All input files associated with a particular game will have this format.  For instance, for an afternoon game on March 6, 2018, the filename will be 180306A.ext, where ‘ext’ = BRI (or DUP or PBN) for the deal file, BWS for the Bridgemate results file, TXT for the text summary file, HTML for the report output from Bridge Composer, and LOG for the log file optionally created by BGR.

Game Time: The user selects one of ‘Morning’, ‘Afternoon’, ‘Evening’, or ‘Late’.  This selection is used to form the ‘MAEL’ suffix to the filename.

Lock Entry Fields: For a particular club setup, most of the fields dealing with file locations can be set once and then never changed again.  To prevent inadvertent changes to these fields, this option, when checked, will make them all read-only.

Game Input Folders: The location for the .BRI, .DUP, or .PBN game files, the .TXT summary file, and the .BWS Bridgemate score files.  The .BWS file can be skipped, if necessary.

Game Report Folders: The location for the .HTML and the optional .LOG files.  This section also contains the ‘FTP to Website’ checkbox and the the URL for the destination website, if this feature is enabled, and the ‘Email to List’ checkbox and corresponding location for the email list document.

Start, Close buttons and logging area: The ‘Start’ button will remain grayed-out until all required input conditions are met, at which time it will become click-able.  Clicking ‘Start’ will cause the program to assemble all the required information and send it to Bridge Composer for processing; then it will optionally transmit the results to either a selected website or to addresses on an email list.  The ‘Close’ button will close the program.  The logging area displays progress and/or error information. If the ‘Save log to folder’ option is checked, then the log file will be saved to [yymmdd][session].LOG in the selected folder.

Set FTP/Email Creds: FTP and/or email server login information (username & password) is saved in the ‘BGR.TXT’ file, which must be in the C:\BGR\ folder (this folder and a default file are automatically created at installation).  The format of the BGR.TXT file is


Clicking the Set FTP/Email Creds button will bring up the following dialog box for editing the contents of BGR.TXT.  This dialog is password protected, more to prevent inadvertent changes by untrained personnel than for any serious security.

Reset Folders to Defaults: Clicking this button will overwrite the current folder settings with the last-saved set of default settings.  This button (and the corresponding ‘Save Current Settings as Defaults’) are almost never used, as the program automatically saves the last set of user settings whenever the program is closed, and automatically restores them the next time the program is launched.


Emailing Results:

The email feature requires four components:

  • The session summary ([date][session].TXT) file produced by ACBLSCOR containing player names and ACBL player numbers
  • A user-provided file containing email addresses in CSV format (an example is provided)
  • A user-customized ‘EmailTemplate.txt’ email template file  (an example is provided) containing the body of the email to be sent
  • Any HTML/PDF attachments to be sent.  All desired attachments must have the same filename as all the game files for the particular session, with a .HTML or .PDF extension, and must be in the same folder.

The email list must be in CSV format, and must be formatted as follows:

Name,ACBL #,Email Address,Opt out
Jody Lastname,R892974,,
Daniel Lastname,N184169,,yes

A ‘yes’ (case-insensitive) in the ‘Opt out’ field will cause that address to be skipped.

The ‘EmailTemplate.TXT’ file format is:

Aloha Bridge Club results for [GAMEDATE] – [SESSION]

Thank you for playing. This automated email is intended solely for players in this specific session. Thank you for your support and cooperation.

In the above example, the FROM:, SUBJECT:, and BODY: sections are required fields, and must be placed as shown.  [GAMEDATE] and [SESSION] are optional fields that will be replaced by the actual game date and the actual session time (‘Morning’, ‘Afternoon’, etc).  The resulting email using the above template looks like the following, where ‘[GAMEDATE] – [SESSION]’ was replaced by ‘February 26, 2018 – Evening’

Game Generation Tool:

The game generation tool is intended to automate the process of batch-producing dealer (.PBN or .BRI) files for games over a range of dates and session times. if, for instance, you wished to produce the deal files for all Monday, Wednesday, and Friday afternoon and evening games for the entire month of April you could simply set up the dates and times, and press one button to generate all the game files.

The game generator tool is accessed from the main Bridge Game Reporter page by selecting the ‘Game Generator’ item under the ‘Tools’ menu.  The tool dialog is shown below, along with an explanation of each control section.


Start/End Date: The starting and ending dates for game generation (inclusive)

Game Times: Select one or more game time checkboxes to have that session time’s game generated for every applicable date.  Checking ‘All’ will enable all times, and unchecking ‘All’ will disable all times.

Game Days: Select one or more game day checkboxes to have games generated for all enabled session times for all those days of the week within the selected date range, inclusive.  Checking ‘All’ will enable all days, and unchecking ‘All’ will disable all days.

Selection Summary: This is a read-only running summary of the number of days, times, and total games to be generated.  It’s  a good idea to check that the ‘Tot Games’ number is what you expect, before starting the generation run.

Destination Folder: The folder to be used as the destination for generated game files.  This folder must exist, and must contain the template file ‘handrecord.pbn’ (see below)

Output Format: Bridge Composer can create game files in either .PBN or .BRI format – simply select which one is desired.

Number of boards to generate: Type in the desired number of boards to generate per game.  This will typically be 24, 27, or 36, but can be anything.   I suggest setting this to 2 or 3 when first getting used to the program.

Generate Games: Starts the generation process.  Note that this button won’t be enabled (click-able) until all the prerequisites are met (start/end date, days of week, session times, destination folder, etc).  If the button won’t enable, check the log for helpful messages.

handrecord.pbn template file: This is a required file, and it must be present in the folder selected in the ‘Destination Folder’ entry field.  This template file is used by Bridge Composer to customize hand record output for your club or organization, as shown below:

2-board game generated using the default ‘handrecord.pbn’ file

The above figure shows a 2-board game generated by Bridge Composer using the default ‘handrecord.pbn’ file.  The text in the title area above can be customized for your own club using Bridge Composer’s ‘Format Title Area’ menu as shown below

Once the required customizations have been accomplished, simply save the result back to ‘handrecord.pbn’, and they will show up the next time a game is generated.  Note that Bridge Composer supports many other customizations to the ‘handrecord.pbn’ template, but that’s an exercise that is left up to the user ;-).


Download and launch BridgeGameReporter.msi to install Bridge Game Reporter on your (Windows only – not MAC) PC.  The installation program will do the following:

  • Install the BGR application in C:\ProgramFiles(x86)\Bridge Game Reporter
  • Create the folder C:\BGR\ and place a default BGR.TXT file there for ftp/email credentials
  • Create another BridgeGameReporter folder in your ‘My Documents’ folder to hold the ‘handrecord.pbn’ file required for game generation, and the ‘EmailAddressList_Sample.csv’ and ‘EmailTemplate_Sample.txt’ sample files.
  • Place a red heart-shaped ‘BGR’ icon on your desktop

Once the installation completes, launch the program using the desktop icon, and fill in fields as required/desired.  Note that if you want to use the game generation tool, you should set the Destination Folder field to the ‘BridgeGameReporter’ folder in your ‘My Documents’ folder.



TP5100 2-cell LiPo Charger Module Study

Posted 24 February 2018

I have been working on Wall-E2, my autonomous wall-following robot, for almost three years now, and it seems like I have been struggling with the battery and charger arrangement for that entire time.  I started out with 4 AA batteries, but quickly moved on to a pair of Sparkfun 2000mAh ‘flat-pack’ cells with Sparkfun chargers, with a relay to switch the batteries from series (RUN) to parallel (CHG) wiring.  This worked, but not very well.  The flat-pack batteries weren’t a good match for motor control, and I kept burning up charger modules as well.  After struggling with this through several iterations, I finally abandoned it entirely in favor of a 7.4V 20C LiPo RC battery and an external charger. This worked much better, but forced me to manually disconnect the battery from the robot and charge it externally – not at all what I wanted.  Later on I made another run at the 2-cell series/parallel switching strategy for charging, this time using Adafruit Powerboost 1000C charge modules, each capable of 1A charge rates. Again this worked (actually quite well), but I recently discovered that it has a fatal flaw – this design imposes significant IR drops on the way from the battery terminals to the motors.

So, I have once again been searching for a solution to the battery/charger problem.  While wandering through the Googleverse the other day, I ran across a mention of the 1/2-cell TP5100-based charger module (about 9:50 from start), available for next to nothing on eBay.

Unfortunately, the available technical information on this module is also next to nothing, and what does exist is all in Chinese.  Still, this module has the potential for vastly simplifying my charger setup, so I thought it was worth the effort to perform a thorough study.

In a previous post, I described an Arduino controlled charge/discharge test setup for testing operation of my 2-cell parallel/series switched setup, so I decided to modify it for evaluating the TP5100 module, as shown below

View of TP5100 module showing RUN & CHG indicator connections

Charger test setup, in discharge mode (note 1.1A discharge current)

Charger test setup, in charge mode (note 1.8A charge current)

TP5100 Module Test Circuit

Using this setup, I was able to cycle the battery between a 7.5Ω load and the TP5100 charge module.  In order to keep the cycle times down to a dull roar, I set the software to switch to charge when the battery voltage dropped below 7.5V, resulting in the plots shown below.

In this case, the discharge current was about 1.1A, and the observed charge current was about 1.8A. The TP5100 modules seems to work as advertised – with a 12V 5A power supply and a partially charged battery, it successfully charged my 2-cell LiPo pack terminated the charge at about 8.4V (I’m not sure if it is terminating based on current or voltage).

Over the next couple of days, I performed three complete charge/discharge cycles using this same setup.  Discharge was terminated at 6V, and charge was terminated when the TP5100 ‘complete’ output changed from open-circuit to active-low. As can be seen in these charts, performance was very consistent – almost 6 hours run time into a 7.5Ω load, and about 4 hours for a complete recharge.


So here’s what I know now about the TP5100 module

  • When the ‘1-cell/2-cell’ jumper selector is shorted to select 2-cell, the output voltage stabilized at 8.4 with a 10-15V DC input (I used a 12V 5A supply for the tests).  Below about 10V, the output voltage falls below 8.4V
  • with a partially charged battery stack, output current was about 1.8A at the start, tapering to below 200mA at termination
  • There is an onboard Red/Blue LED and solder holes for an external bi-color LED.  The onboard LED states are:
    • RED = Charging
    • Blue = Finished
  • Both the onboard and external LED connections are tied to +V via the same 1K current limiting resistor.  This resistor is routed to the center hole of the 3-hole external LED breakout.  The rightmost hole is tied to an open-collector gate that goes LOW upon charge termination, and the leftmost hole is tied to an open-collector gate that goes LOW upon charge initiation.  In my testing circuit above, these lines are labelled ‘Fin’ and ‘Chg’ respectively and were routed to digital inputs with 20K pullups on the Arduino UNO.
  • This is NOT a balance charger – so there may be differences in cell voltages over time.  If this is a potential issue, then separate cell protection modules like these should be installed.

Here’s an annotated photo showing the pertinent features:

So, it looks like this TP5100 module will work fine for my 2-cell LiPo application, with the addition of an external 2-cell protection module like the one noted above.  Not only will this solve my original IR drop problem, but it is much smaller and simpler too, as shown in the following size comparison shot.  Oh well, at least I had a lot of fun building up and testing the original charger module ;-).

charger module and TP5100 size comparison

Stay tuned!





The operation was a success, but …

Posted 21 February 2018

In early January of this year I posted about finishing the integration of my new-improved battery charger & battery pack into my new-improved robot chassis.  Between then and now I have been working on getting the new robot chassis mated up with the charging station (the new robot chassis is wider, and I also changed to larger diameter wheels) in preparation for renewed field testing.

Unfortunately, just as I was getting ready to move into field testing, my robot started acting funny.  About half the time, it wouldn’t disengage from the charging station and instead would reboot.  At first I thought the added weight of the new battery pack and robot chassis was causing the motors to stall, so I changed the code to have the robot disconnect at full motor speed rather than 1/2 as before.  This made the problem even worse; now not only wouldn’t Wall-E2 disengage from the charger, it wouldn’t even move forward or backward under it’s own power!  Clearly something was badly wrong, but I had no clue what it was.

Applying my time-honored troubleshooting – I simply put Wall-E2 aside for a few days and let my subconscious work backwards through all the changes since Wall-E2 had last worked properly.  After enough time had elapsed, my subconscious reported back and said:

“You are an idiot.  All of the complexity you added in your quest for an on-board charging system has placed that wonderful high-capacity battery pack at the far end of a long series of (relatively) high resistance circuitry, and the IR drop caused by full-speed motor currents is killing you!”  “Oh, and by the way, you’re ugly too!”

Well, my subconscious is almost never wrong, and it only took me a little bit of testing to confirm it’s theory.  I set the code up to go forward and backward at full speed, and monitored the CPU’s 5V regulated output line with my trusty oscilloscope.  As soon as the motor command was executed, the 5V line drooped to less than 3V, and the CPU rebooted – oops!

So now I knew what was happening, and I (or my subconscious anyway) had a good idea why.  To confirm the why, I bypassed all the charge-management circuitry and wired my 7.4V 7200mAh battery pack directly into the main robot power line, as shown in the photo below

7.4V 7200mAh battery pack wired directly into robot power

With this setup, the robot not only was able to move forward and backward at full speed, the thing damn near took my arm off when I tried to stop it – whoa!

So, the bottom line is that all the work I put in designing and implementing a really cool on-board dual-cell charge management system had the ultimate effect of making the battery unusable.  The operation was a success, but the patient died! ;-).

So, where to go from here?  It appears that I have to completely revise my thinking about battery charging and maintenance for Wall-E2.  Instead of being in series with the battery, any charging/maintenance system must operate in parallel, and be completely out of the path between the battery pack and the load when the robot is running.  Now I realize this is the reason most RC/Hobbyist multi-cell battery packs have a balance charging cable in addition to the main power cable; charging is done completely independently of the output path.

When I first started the charger project, my original goal was to avoid having to remove the battery from the robot to charge it; I wanted Wall-E2 to  connect to power and charge itself without human intervention.  At the time, I felt the only way to do this was to have the charging circuitry on board, so that only a single DC connection from the charging station was required.  I thought the only way to make this happen was to use two of the Adafruit SBC1000 charger modules to charge each of the two cells independently.  Unfortunately, the SBC1000’s grounds aren’t isolated, so this meant that I had to disconnect the two battery pack cells from each other to charge them independently and then switch them back together again to run the robot after charging.  This worked (rather elegantly if I do say so myself), but had the unintended side-effect of putting too much high-loss circuitry and wiring between the battery pack and the motors.

Now that it is clear that I can’t interfere with the current path to the motors, I know I have to abandon the current charging module design, but what are the alternatives?

  • The TP5100 is a little module that can balance charge a 2-cell LiPo stack at 2A.  It has a dual-color LED output that I might be able to use for charge termination.  Unfortunately, the specs are all in Chinese, so it may take some experimentation to figure out.
  • I can use an external balance charger like the EV Peak e4 ‘cube’ automatic balance charger, and feed the three required wires (ground, B1+, B2+) out through the front of the robot to the charging station. This solves the problem of carrying the charger around, but significantly complicates the interface to the charging station.

Stay tuned!


Printing an ABS Shaft Adaptor for 80mm Wheel

Posted 25 January 2018

Over the last few days I have been struggling with a project to 3D print a small adaptor to allow me to mount some 80mm wheels I bought some time ago to my Wall-E2 autonomous wall-following 4-wheel drive robot.

The original robot came with 56mm wheels and this gave Wall-E2 very little ground clearance.  I found some 80mm wheels that I thought would do the trick nicely, but when I tried them, it quickly became apparent that the shaft receptacle on the wheel was significantly larger than the motor shaft, leading to a very bad wobble and catastrophic wheel departures – oops!

Lightweight 4WD Drive Aluminum Mobile Dolly Car Robot Platform for Arduino


original 56mm wheel and companion motor

Ebay ‘Arduino Robot’ motor dimensions

80mm wheel

After some troubleshooting, I discovered that the new 80mm wheels have a shaft receptacle that measures 5.9mm long and 3.6mm wide, while the motor shafts are 5.4mm long and 3.5mm wide.  The width is OK, but the longer length is causing the problem.

After thinking (and cursing) a bit, I decided to try printing an adaptor.  The larger diameter wheels are also considerably thinner (20mm or so vs 30mm), so there should be room for an adaptor part, as shown below

shaft adaptor for 80mm wheel

And threw it on my PowerSpec 3D PRO (Flashforge Creator Pro knockoff).  After just a little fiddling, I got some nice parts, and thought I was done.  A couple of days later, I noticed one of the parts was just a little loose on its shaft, so I said to myself – “I’ll just print off another one”.  Unfortunately, what came off the printer was really ugly, and completely unusable, even though that same printer had produced nice parts just a few days ago – WTF!?  Clearly I had forgotten what magic I had wrought the first time, so now I had to go back and recreate it – bummer.  As part of my penance for this crime, I am writing this post so the next time I want to do this, I’ll have the print settings recorded.

Print Settings for ABS

The significant factors in how to get good prints with ABS on this printer appear to be

  • Print speed
  • Extrusion factor

The first thing I did was slow the print speed down, but this had only a minor effect on print quality.  Going slower helped, but even very slow speeds (like 10mm/sec) didn’t result in clean edges on the male part of the adapter. However, the female portion was very clean, which left me a bit puzzled – why one part but not the other?  I finally realized that the difference was that the female piece was perfect because the hole perimeter was the first thing laid down at each slice, then the outside perimeter, and finally the fill material was added last.  This meant that the hole perimeter had a chance to cool and solidify before the fill material impinged on its outer surface, and this meant that the perimeter stayed in the same shape as originally laid down.  When printing the male part, however, the outer perimeter was laid down first, and then the fill material was immediately added, before the outer perimeter had a chance to cool and solidify, even at the slower speeds.  The material making up the fill was pushing the outer perimeter out of shape.

This led me to focus on the extrusion factor.  Reducing the extrusion factor from 1.00 to 0.95 had a significant positive impact on the print quality of the male portion of the adaptor.  Reducing it again to 0.90 resulted in an even better print, as did a further reduction to 0.85.  However, at the 0.85 value, I started to see some degradation in the quality of the female portion, so I backed off to 0.90 as the final value.  The following image shows the last seven prints.  All were printed at either 20mm/sec or 10mm/sec, and the last three on the right were printed with 10mm/sec and extrusion factors of 0.95, 0.90, and 0.85 respectively.

The last seven prints. the last three on the right were printed at 10mm/sec and with extrusion factors of 0.95, 0.90, and 0.85 respectively

Original and new wheels, with completed adaptor shown

Bottom Line (PowerSpec 3D Pro, Simplify3D):

  • Material: Gray ABS
  • Extruder temp: 230 (not critical 220-240 should be OK)
  • Bed temp: 110 (not critical, 100 should do too)
  • Speed: 20 or 10mm/sec (maybe faster would be OK, but not much)
  • Extrusion factor: 0.95 or 0.90





A New Chassis For Wall-E2, Part III

Posted 13 January 2018

Back in November of last year I started moving Wall-E2 to his new home in a larger chassis, and subsequently I was able to integrate the new-improved charging system in to this new chassis.

So, today I started some field testing, and discovered a major problem – the motors that came with the new chassis don’t have sufficient torque to handle the operating environment – they stall out much too quickly when encountering any movement issues at all.  This wasn’t a problem for the previous incarnation of Wall-E2, so clearly the motors that came with the new chassis have different speed/torque specs than before.  And, of course, the old motors won’t fit into the new chassis (actually, they do fit, but not with the new battery pack).  What a bummer!

So, I started researching dc motors to determine if I could find motors with the speed/torque specs of the old chassis, but with the physical specs of the motors that came with the new one.

Motors in previous ‘Pirate’ chassis:

The specs for the motors that came with the DF Robots ‘Pirate’ chassis are shown below:

Specifications for the motors using in the ‘Pirate’ robot chassis from DFRobots

With a gear ratio of 160, the motors should produce about 160 RPM at At Wall-E2’s normal operating range of 6-7.5V, and can produce a maximum torque of 0.8 kgf-cm (kilogram force – cm).

Motors in new chassis:


I couldn’t find the max torque specification, but assuming it’s the same basic motor body, the much lower gear ratio should result in the observed higher no-load speed and lower torque.

So, I’m fairly confident that I now know why the motors in the new chassis aren’t performing as well as the old ones – a much lower gear ratio.  Now all I need to do is find another motor source with the same form factor as the new ones, but with a gear ratio more like the ones from the older chassis:


I found a 120:1 gear ratio right-angle motor at Pololu

Pololu 120:1 right-angle motor dimensions

Pololu 120:1 right-angle motor

These motors have almost the same exact dimensions as the ones in the new chassis, but they have a shorter (5 vs 9mm) and larger diameter shaft (7 vs 5mm).  These are not insurmountable difficulties, but surely I can find a better fit.


So, eventually I ended up back on eBay, the same place where I got the new chassis.  But, this time I was a little more informed about what gear ratio I wanted, and so was able to reasonably quickly locate a set of 4 motors (without wheels – I have too many already!), as shown below

4ea 1:120 right-angle shaft motors with 5mm shaft diameter

So, now all I have to do is wait 2-3 weeks for them to arrive, and I should be back in the low(er)-speed, high(er)-torque business!

Stay tuned!




Wall-E2 battery charger module integration

Posted 01 January 2018

What a way to start off the new year!  The battery charger module for my autonomous wall-following robot Wall-E2 has been completed and tested, and now has been integrated into the robot – yay!!

If you have been following this saga, you will recall that I started working on an internal charging module for Wall-E2 well over a year ago, back in November 2016 with this post.  Since then I have gone through several iterations, revisions, and mis-steps (including a semi mind-boggling deep-dive into the details of the Adafruit PowerBoost 1000C specifications in this post).  Last month I finally got a complete system (two PowerBoost 1000C’s integrated onto a single PCB with appropriate control and battery switching circuitry) working, and was able to run extensive charge/discharge cycle testing using a simple test circuit and an Arduino Uno to run it. So, now all I had to do was stuff the whole thing back into the robot.  This task was made possible by my earlier decision to upgrade Wall-E2’s ride to a slightly larger chassis, so instead of trying to cram 2Kg of battery/charger into a 1Kg space, I now had the pleasure of fitting 2Kg into a 3Kg space – nice!   Here are some photos of the integration process.

Battery module shown in the ‘maintenance’ configuration.

Another shot of Battery module in the ‘maintenance’ configuration.

Front cover removed to show how the battery module fits into the robot. Note there is plenty of room for cable runs

Front cover removed to show how the battery module fits into the robot. Note there is plenty of room for cable runs

Rear cover removed to show how the battery module fits into the robot. Note there is plenty of room for cable runs

Rear cover removed to show how the battery module fits into the robot. Note there is plenty of room for cable runs

Now that the battery/charger module has been integrated into the robot chassis, I will have to make some minor changes to the robot operating system to accommodate changes I have made along the way, but these should be easy and straightforward.  Then, it will be back to field testing, I hope.

Stay tuned!




Wall-E2 battery charger module testing, Part II

Posted 22 December 2017

After having worked out (hopefully) all the bugs in the Arduino Uno program and associated test hardware, I have moved on from testing just one of the Adafruit PowerBoost 1000C  charging module in isolation to testing the entire 2-cell battery pack system, albeit with the smaller 2500mAh LiPo’s rather than the full-up 18650 stacks.

Full-up test of the 2-cell charging system using 2500mAh LiPo cells

Full charge of 2500mAh cells

After several days of testing, I never really got consistent results with this setup – I seemed to be always chasing intermittent problems of one sort or another.  Then I finally figured it out (I think) – the problem wasn’t my setup, it was the proto plug-board I was using.  This board was a cheap no-name plugboard I got off eBay, and apparently I got exactly what I paid for! ;-(.  So, I reverted to my tried-and-true (but HUGE!) AP Products A.C.E. 236 plugboard that I have had around the lab for a couple of decades, at least.  When I transferred the setup to this plugboard, everything started working better.  In particular, the battery charging current went from about 0.5A to about 1.5A – a much more believable (and practical) figure than before.  Here’s the new test setup.

New test setup with my trusty AP ACE 236 plugboard. Note charging current shown on current meter

After getting the hardware problems squared away, I started getting reliable charge/discharge cycle data, as shown in the curves below

Two complete charge/discharge cycles. Note the time axis is in minutes here

The next step in the process will be to replace the PKCell 2500mAh flat-pack LiPo cells with the 6800mAh pack (two series banks of 2ea Panasonic 18650 3400mAh cells in parallel) to be used in the robot.

26 December Update:

Chg/Dischg testing with the Panasonic 18650 packs from the robot.

As shown above, I switched out the 2500 mAh flatpacks for the Panasonic 3400 mAh cells from the Wall-E2 robot.  Initially I was somewhat disappointed with charging performance, as I was only seeing about 1 – 1.5A initial charge current for both 6800 mAh cells, instead of the 2+ A I expected to see.  Eventually I narrowed the problem down to stray resistance in the testing circuit itself, through the plugboard, the plugboard wiring, and the relay being used to switch charging power to the battery module.  When I bypassed these elements and connected the external MeanWell 5V power supply to the battery module terminals, the max current increased to slightly over 2A, as expected.  This is actually very good news, as it means that the resistance of the PCB traces supplying power to the PowerBoost 1000C modules is low enough to not materially affect the max charging current – yay!

Still, even with the max charging current up at 1A/cell and with the PB 1000C’s PROG3 charge termination resistor reduced from 100K to 33K, it takes every bit of 10 hours to charge the battery pack from 3V to 4.2V, as shown below.

Panasonic 18650 6.8AH robot battery pack. Initial charge rate approx 1A per 2-cell parallel stack

Panasonic 18650 6.8AH robot battery pack discharge, 15 ohm load

28 December 2017 Update:

While testing these battery packs for charge and discharge performance, I came to realize that I had over-complicated the test circuit.  The original test circuit is shown below:

This circuit uses a relay to switch +5V power to the charger modules in the battery pack module, and also to switch the load in and out.  As I gained more experience, I realized the relay contact resistance was substantially reducing the charge current, so I wired +5V directly to the battery pack; this worked because the Arduino running the test circuit keeps the battery pack parallel/series relay disengaged (meaning the battery cells are arranged in series) until the load voltage drops below a set threshold.  So, this realization resulted in the following updated circuit schematic.

As shown above, I added the connections to the battery charger module, and the LED displays.

However, I have now come to realize that the other half of the relay isn’t necessary either, as the ‘Robot +’ line isn’t connected to anything until the test manager computer (Arduino Uno) recognizes the end-of-charge condition and changes the Coil Enable signal from HIGH to LOW, disabling the battery pack’s internal relay and changing the battery configuration from parallel (CHARGE) to series (RUN).  So, now the test circuit can be reduced to just the LEDs and the load resistors, as shown below.

While I was making the other changes, I also cut the load resistance in half, from 15Ω to 7.5Ω to more accurately simulate the actual robot motor loads, and (finally!) managed to capture a complete discharge cycle, as shown below.

Complete Robot Battery Pack Discharge Curve, 7.5-ohm load.

The 7.5Ω load for this run provides a good approximation for the maximum current drain experienced by the robot under most operating conditions, so it is now safe to say that the robot should be able to run at least 6 hours on a charge, and that a full charge will take about 10 hours.  So, the robot will spend more time on the charger than on the road, but that’s life in the robot lane.

Stay tuned!





Wall-E2 battery charger module testing, Part I

Posted 15 December 2017

For the last couple of months I have been working on the battery subsystem for my Wall-E2 autonomous wall-following robot.  Along the way I upgraded the robot chassis to provide more room for the on-board charger & battery pack, and created a PC board design for the module that charges the 2-cell LiPo stack in parallel and then switches to a serial configuration to run the motor.  This post describes the first part of a testing program to validate the performance of the Adafruit PowerBoost 1000C charger module, and the idea of switching seamlessly from charging to powering a load.

By way of background for this post, I ran into some difficulties when I tried to integrate the full-up 2-cell, 2-PB1000C battery pack/charger combination into my Wall-E2 robot, and troubleshooting the problems using the complete operating system software proved to be somewhat tedious, I decided to start at the other end with a very simple test program running on an Arduino Uno, and a single PB1000C charger.

The Arduino test program is very simple; when it is initialized, it checks the battery voltage to see if is above or below a preset threshold.  If above, it energizes a DPDT relay to connect the battery to a 15Ω load; if below, it de-energizes the relay, which disconnects the battery from the load and also connects 5V to the ‘USB’ (5V input) terminal of the PB1000C, thereby charging the battery.  After that, the program alternately switches the battery between the load and charging states, recording the battery voltage every four seconds.

Battery Testing Hardware

Arduino Uno and test circuit.  Note the yellow ‘charging’ LED on PowerBoost 1000C shown at middle right

After working the inevitable bugs out of the Arduino program, I got some reasonable battery cycling data, as shown in the following plots.  The battery used in all these tests was a PKCell LP795060 LiPo cell, rated for 3.7V and 2500mAH.  It is rated for about 5hrs at 0.2C discharge, but I was only seeing about 3hrs at 0.1C, most probably because I was terminating the discharge at 3.4V rather than the 2.75V used in the discharge tests.

Two complete chg/discharge cycles

Chg/Dischg cycles using PB2 (same battery as previous tests). Short cycles may imply battery wear-out

After the last test above, I was concerned that either the PowerBoost 1000C was not operating properly, or the battery itself was failing, or both.  So, I changed the discharge termination threshold from 3.4 to 3.0V to be more consistent with the 2.75V cutoff used by the battery manufacturer.  After making this change only, I got the following plot

Charge/discharge cycles after changing the discharge termination threshold from 3.4 to 3.0V

As can be seen from the above plot, the discharge and charge times were extended dramatically.  Discharge (at approximately 220 mA or 0.1C) took well over 3hrs, and charge took about the same amount of time.  So, it appears that both the PowerBoost 1000C modules are still working OK even after the abuse I put them through by plugging them into a PCB with wiring errors ;-).




Wall-E2 Battery Charger PCB Part II

Posted 1 November 2017

In my last post on this subject, I described my efforts to create a PCB for the charging module in my wall-following robot(s).  I showed the hand-wired original, and the first (of three, so far) PCB versions. My circuit-checking skills are a bit deficient, so I keep finding ‘issues’ with the PCBs I received from Bay Area Circuits.  It’s not their fault as they produced PCB’s exactly like I told them – apparently they don’t know about the RDM (Read Designer’s Mind) checkbox on their order form! 😉

In any case, the major problems I discovered on the first two revs are, kind-of, understandable for a PCB newbie like myself; I had the JST battery connectors switched, so Batt+ showed up on the PCB as Batt-, and the IRF-510 transistor holes were reversed as well.  A bit of cut-and-jumper work solved the first problem, and simply turning the transistor around solved the second one.  However, I really didn’t like leaving that as the ‘final solution’ so I splurged another $30 on a third rev with these problems fixed.  These boards have not yet arrived, so in the meantime I continued testing on the current setup.

As the photo below shows, the finished and populated PCB has almost exactly the same dimensions as the hand-wired perfboard model.  Since the perfboard version had several components mounted on the wiring side, arriving at the same dimensions with everything on one side is a definite plus!

comparison between the hand-wired perfboard version and the PCB

After getting the PCB populated, I did some electrical testing, and somewhere along the way I think I managed to damage the boost regulator chip on one of the PowerBoost 1000C modules.  And this is where I discovered my next major booboo – I had hard-wired the PB1000C’s to the PCB, and so now I couldn’t replace the damaged part without destroying the part, and probably the PCB too – oops!

07 December 2017 (Pearl Harbor Day) Update:

I received the latest (and hopefully, last!) batch of battery charger module PCB’s from Bay Area Circuits a week ago, but have been too busy with other things (mostly dealing with the new V3 robot chassis) to do much with it. So, today I started populating and testing the new charger module.  As I mentioned before, one of the bigger mistakes I made on the previous version was to hard-wire the PowerBoost 1000C’s onto the PCB, making it almost impossible to replace if it failed (and, as I learned from the Adafruit forums they can be easily damaged if they are powered up without a battery attached).  So, this time I soldered female headers onto the PCB and male headers onto the charger modules, making them easy to replace if needed.

New charger module with some test batteries attached

Charger module showing PowerBoost 1000C header arrangement

The next step will be to test the module’s ability to manage the robot’s battery stack.  I plan to simulate the robot load with a 500 mA resistive load, and simulate the actual battery stack with the two smaller 2500 mAH batteries shown in the above photos.  I’ll simulate the robot with an Arduino, programmed to print out time-stamped readings of the robot power voltage (actually 1/3 of the robot power voltage, but what’s a scaling factor between friends?).

Stay tuned!