Arduino based charge balancer

I should be able to run 18s with the OE (proud eagle) controller, so I'll get pete to work out a nifty "balanced grey code" sequence for me. IN theory, 5 address bits, each clacking 4 times, could get me up to potentially 19s so I'm a bit more confident now that I can achieve this with 4 clacks on each relay per scan.
This might get you over 30mph Andy......!!
At 18s we can probably leave out 5 or 6 of the relays - fit 'em when the extra cells go on.
Bob
 
My controller with the unlock gets me 35mph but it might get me nearer 40mph.

Sent from my ALE-L02 using Tapatalk
 
Here are some details about the bottom balancing PCB.
In general an Arduino nano is used to control a series of dual pole changeover relays which are on a binary decode to select one of the (max) 26 cells in series.
The selected cell is connected (1) to an external (say) 1ohm discharging resistor and (2) to a "difference amplifier" (U1), the output of which is fed into the arduino analog port A0
Power to this board is taken from the entire series cell array, mostly via an LM5017 (IC2) based buck converter to 12V. Because this power supply may be insufficient for all the relay coils in the worst case, the 4th battery tap may be switched in to help out during 'long period' discharges (when actively balancing) via arduino port D12 and transistors T1 and Q7. Power to the switcher arrives via plug PL2 so the board is only using power during the actual charging process (it should be switched off when the charger is unplugged)
Arduino D13 controls the output relay, which is connected to plug PL1. This isolated dry contact is provided to switch the charger on when closed. At a pinch the charger current could be directly controlled by the relay, it is 2 parallel 8A relay contacts, but I would have it driving some sort of enable on the charger.
Arduino D11 connects to PL4 and is a digital control to enable the balancing function. This is intended to be driven using a similar switch to the one on PL2.
Switch open causes the sequence:
1) scan cells
2) bottom balance if lowest voltage individual cell is less than 3.0V
3) enable charging until highest voltage individual cell reaches 3.4V
Switch closed just does
3) enable charging until highest voltage individual cell reaches 3.4V

I've started on the code for this, included below
Code: 
#define scale 0.005 // scale trim adjusts reading of lowest cell
#define hicorr  0.0004  // diff trim corrects for difference amp errors 
#define adcdel 10 // a few milliseconds for relay to clack and amp to stabilise
#define logginginterval 4000 // data logging time interval in milliseconds
#define Ncells 26 // number of cells
#define balthresh 3.0 // balance down to 3.00V on all cells
#define chargelim 3.4 // charge up to 3.40V on highest voltage cell

float Vcell[Ncells];
int celladc[Ncells];
float cellsum;
float mincell;
float maxcell;
int adcmin;
byte cellid;

void scancells() { // assume selectors all at zero to start
  digitalWrite(7, HIGH);  // 10000
  delay(adcdel);
  celladc[16] = analogRead(A0);
  digitalWrite(5, HIGH);  // 10100
  delay(adcdel);
  celladc[20] = analogRead(A0);
  digitalWrite(7, LOW);  // 00100
  delay(adcdel);
  celladc[4] = analogRead(A0);
  digitalWrite(3, HIGH);  // 00101
  delay(adcdel);
  celladc[5] = analogRead(A0);
  digitalWrite(7, HIGH);  // 10101
  delay(adcdel);
  celladc[21] = analogRead(A0);
  digitalWrite(4, HIGH);  // 10111
  delay(adcdel);
  celladc[23] = analogRead(A0);
  digitalWrite(5, LOW);  // 10011
  delay(adcdel);
  celladc[19] = analogRead(A0);
  digitalWrite(4, LOW);  // 10001
  delay(adcdel);
  celladc[17] = analogRead(A0);
  digitalWrite(6, HIGH);  // 11001
  delay(adcdel);
  celladc[25] = analogRead(A0);
  digitalWrite(7, LOW);
  digitalWrite(4, HIGH);  // 01011
  delay(adcdel);
  celladc[11] = analogRead(A0);
  digitalWrite(3, LOW);  // 01010
  delay(adcdel);
  celladc[10] = analogRead(A0);
  digitalWrite(6, LOW);  // 00010
  delay(adcdel);
  celladc[2] = analogRead(A0);
  digitalWrite(5, HIGH);  // 00110
  delay(adcdel);
  celladc[6] = analogRead(A0);
  digitalWrite(7, HIGH);  // 10110
  delay(adcdel);
  celladc[22] = analogRead(A0);
  digitalWrite(5, LOW);  // 10010
  delay(adcdel);
  celladc[18] = analogRead(A0);
  digitalWrite(6, HIGH);  // 11010
  delay(adcdel);
  celladc[26] = analogRead(A0);
  digitalWrite(4, LOW);  // 11000
  delay(adcdel);
  celladc[24] = analogRead(A0);
  digitalWrite(6, LOW);  // 01000
  delay(adcdel);
  celladc[8] = analogRead(A0);
  digitalWrite(3, HIGH);  // 01001
  delay(adcdel);
  celladc[9] = analogRead(A0);
  digitalWrite(5, HIGH);  // 01101
  delay(adcdel);
  celladc[13] = analogRead(A0);
  digitalWrite(3, LOW);  // 01100
  delay(adcdel);
  celladc[12] = analogRead(A0);
  digitalWrite(4, HIGH);  // 01110
  delay(adcdel);
  celladc[14] = analogRead(A0);
  digitalWrite(3, HIGH);  // 01111
  delay(adcdel);
  celladc[15] = analogRead(A0);
  digitalWrite(6, LOW);  // 00111
  delay(adcdel);
  celladc[7] = analogRead(A0);
  digitalWrite(5, LOW);  // 00011
  delay(adcdel);
  celladc[3] = analogRead(A0);
  digitalWrite(4, LOW);  // 00001
  delay(adcdel);
  celladc[1] = analogRead(A0);
  digitalWrite(3, LOW);  // 00000 
 
  Vcell[1] = celladc[1] * scale;
  cellsum = Vcell[1];
  mincell = Vcell[1];
  maxcell = Vcell[1];
  for (int x = 2; x <= Ncells; x++) {
    Vcell[x] = celladc[x] * scale + cellsum * hicorr;
    cellsum += Vcell[x];
    if (Vcell[x] < mincell) {
      mincell = Vcell[x];
    };
    if (Vcell[x] > maxcell) {
      maxcell = Vcell[x];
    };
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////

void setup() {
  // put your setup code here, to run once:
  // initialize serial:
  Serial.begin(9600); // serial control via the usb uart
  Serial.setTimeout(10000); // 10s serial timeout
  // set up ports
  pinMode(2, OUTPUT);   // state LED
  pinMode(3, OUTPUT);   // cell select LS
  pinMode(4, OUTPUT);   // cell select bit 1
  pinMode(5, OUTPUT);   // cell select bit 2
  pinMode(6, OUTPUT);   // cell select bit 3
  pinMode(7, OUTPUT);   // cell select MS
  InitTimersSafe();
  pinMode(13, OUTPUT);  // ready relay (also lights LED on arduino)
  //initiallise
  digitalWrite(2, LOW);  // state zero
  digitalWrite(3, LOW);  // select cell 0
  digitalWrite(4, LOW);  // select cell 0
  digitalWrite(5, LOW);  // select cell 0
  digitalWrite(6, LOW);  // select cell 0
  digitalWrite(7, LOW);  // select cell 0
  digitalWrite(13, LOW); // charger off
  //measure cells
  analogReference(INTERNAL);
  delay(adcdel);
  Vcell[1] = analogRead(A0) * scale; // dummy read - sort out adc
  
  Serial.println("scan all cells");
  scancells();
  if (mincell < balthresh) { // only balance when empty
    for (int x = Ncells; x > 0; x--) {
      digitalWrite(3, bitRead(x, 0));
      digitalWrite(4, bitRead(x, 1));
      digitalWrite(5, bitRead(x, 2));
      digitalWrite(6, bitRead(x, 3));
      digitalWrite(7, bitRead(x, 4));
      adcmin = int((balthresh - (cellsum * hicorr))/scale);
      cellsum -= Vcell[x];
      delay(adcdel);
      while (analogRead(A0) > adcmin) {
        delay(adcdel);
      }
    }
  }
  digitalWrite(3, LOW);  // just in case it was left on cell 1...
  digitalWrite(13, HIGH);  // balanced - start charging

  while (maxcell < chargelim) {
    scancells(); // check cell voltages
    delay(4000);
  }
  digitalWrite(13, LOW);  // full - stop charging  
  Serial.println("ready for input");

}

void loop() {

}
 

Attachments

  • botbalance - Project.pdf
    177.2 KB · Views: 92
You should add clamping diodes as transistors have inductive load (relay coils)...

BTW, relays are bit expensive, this idea is usable only if you have surplus of relays...

It's still better and cheaper to go with individual cell modules...

I found that only minor changes in my cell module firmware can make it bottom cell balancer... :D
It only needs to have disabled bleeding on processor reset. Still, think that top balancing is better...
 
good spot re: relay coil clamping diodes - I'll have to bodge them on as the PCBs are on their way already...
The relays cost me £1.06 each, I get a deal at RS components through work.
The boards cost about £30 in components, lets guess at £10 each for the PCBs; I think that's not bad for an easily programmable 26s charging/balancing solution.
And it has absolutely no current drain from anywhere in the battery stack when you're not actually charging (so it's not adding an extra "imbalancing" input..)
As far as I'm concerned, the only issue with the system is the inherent lifetime/reliability issue with relays (umpteen million ops in this case).
But - let's see what it's like in real use :)
 
It's been a while - I'm getting one of these going with my trial "drainpipe battery" from https://endless-sphere.com/forums/viewtopic.php?f=14&t=82777
It's only 6s but suitable for debugging. The cell scanning is working nicely and I have a big fat resistor to try out the balancing function.
The 18650 cells have different voltages c/w/ LiPo or LiFePO4, volts looks usable as a state of charge indication on the 18650s.
The opamp has been bodged to get round the designspark schematic symbol debacle and most relays left off. That little switcher works like a charm.
I had a puzzler in the code, this was down to C++ & how it does arrays - I'd declared an array of size 6 & expected the index to go up to 6. It doesn't, it goes up to 5, but no errors are thrown up on the arduino, it merrily works on with some random variable off the heap - that drove me nuts for a couple of hours....
 
Working properly now, here's a picture of the board in 6s build working on the drainpipe battery
View attachment 1
Here is the serial monitor terminal
botbalserial.JPG
This is the arduino code
Code: 
#define scale 0.0048 // scale trim adjusts reading of lowest cell
#define hicorr  0.0006  // diff trim corrects for difference amp errors 
#define adcdel 30 // a few milliseconds for relay to clack and amp to stabilise
#define logginginterval 5000 // data logging time interval in milliseconds
#define Nc 6 // number of cells
#define balthresh 3.5 // balance down to 3.00V on all cells
#define chargelim 3.6 // charge up to 4.10V on highest voltage cell

float Vcell[Nc];
int celladc[Nc];
float cellsum;
float mincell;
float maxcell;
int adcmin;
byte cellid;
//byte mincellid;

void scanfiltcells() { // assume selectors all at zero to start
  digitalWrite(5, HIGH);  // 00100
  delay(adcdel);
  celladc[3] = analogRead(A0);
  digitalWrite(3, HIGH);  // 00101
  delay(adcdel);
  celladc[4] = analogRead(A0);
  digitalWrite(5, LOW);  // 00001
  delay(adcdel);
  celladc[0] = analogRead(A0);
  digitalWrite(4, HIGH);  // 00011
  delay(adcdel);
  celladc[2] = analogRead(A0);
  digitalWrite(3, LOW);  // 00010
  delay(adcdel);
  celladc[1] = analogRead(A0);
  digitalWrite(5, HIGH);  // 00110
  delay(adcdel);
  celladc[5] = analogRead(A0);
  digitalWrite(5, LOW);  // 00010
  digitalWrite(4, LOW);  // 00000

  Vcell[0] = 0.900 * Vcell[0] + celladc[0] * scale * 0.100;
  cellsum = Vcell[0];
  mincell = Vcell[0];
  maxcell = Vcell[0];
  for (int x = 1; x < Nc; x++) {
    Vcell[x] = 0.900 * Vcell[x] + celladc[x] * scale * 0.100 + cellsum * hicorr;
    cellsum += Vcell[x];
    if (Vcell[x] < mincell) {
      mincell = Vcell[x];
    };
    if (Vcell[x] > maxcell) {
      maxcell = Vcell[x];
    };
  }
}

void scancells() { // assume selectors all at zero to start
  digitalWrite(5, HIGH);  // 00100
  delay(adcdel);
  celladc[3] = analogRead(A0);
  digitalWrite(3, HIGH);  // 00101
  delay(adcdel);
  celladc[4] = analogRead(A0);
  digitalWrite(5, LOW);  // 00001
  delay(adcdel);
  celladc[0] = analogRead(A0);
  digitalWrite(4, HIGH);  // 00011
  delay(adcdel);
  celladc[2] = analogRead(A0);
  digitalWrite(3, LOW);  // 00010
  delay(adcdel);
  celladc[1] = analogRead(A0);
  digitalWrite(5, HIGH);  // 00110
  delay(adcdel);
  celladc[5] = analogRead(A0);
  digitalWrite(5, LOW);  // 00010
  digitalWrite(4, LOW);  // 00000

  Vcell[0] = celladc[0] * scale;
  cellsum = Vcell[0];
  mincell = Vcell[0];
  maxcell = Vcell[0];
  for (int x = 1; x < Nc; x++) {
    Vcell[x] = celladc[x] * scale + cellsum * hicorr;
    cellsum += Vcell[x];
    if (Vcell[x] < mincell) {
      mincell = Vcell[x];
    };
    if (Vcell[x] > maxcell) {
      maxcell = Vcell[x];
    };
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////

void setup() {
  // put your setup code here, to run once:
  // initialize serial:
  Serial.begin(9600); // serial control via the usb uart
  Serial.setTimeout(10000); // 10s serial timeout
  // set up ports
  //pinMode(2, OUTPUT);   // state LED
  pinMode(3, OUTPUT);   // cell select LS
  pinMode(4, OUTPUT);   // cell select bit 1
  pinMode(5, OUTPUT);   // cell select bit 2
  pinMode(6, OUTPUT);   // cell select bit 3
  pinMode(7, OUTPUT);   // cell select MS
  pinMode(11, INPUT);   // '0' means enable balance
  pinMode(12, OUTPUT);  // beef up 12V supply from battery tap b4
  pinMode(13, OUTPUT);  // charge enable relay (also lights LED on arduino)
  //initiallise
  //digitalWrite(2, LOW);  // state zero
  digitalWrite(3, LOW);  // select cell 0
  digitalWrite(4, LOW);  // select cell 0
  digitalWrite(5, LOW);  // select cell 0
  digitalWrite(6, LOW);  // select cell 0
  digitalWrite(7, LOW);  // select cell 0
  digitalWrite(12, LOW); // main battery psu backup disabled
  digitalWrite(13, LOW); // charger off
  //measure cells
  analogReference(INTERNAL);
  delay(adcdel);
  Vcell[0] = analogRead(A0) * scale; // dummy read - sort out adc
//  for (int x = 0; x < Nc; x++) {
//    Vcell[x] = 3.5;
//  }
  Serial.println("scan all cells");
  scancells();
  if (mincell < 3.0) {
    mincell = 3.0;
    Serial.print("Minimum cell ");
    Serial.print(mincell);
    Serial.println("V");
  }
  if ((mincell < balthresh) && (digitalRead(11) == 0)) { // only balance when empty
    Serial.println("Do a bottom balance");
    digitalWrite(12, HIGH); // 12V supply may need backup
    for (int x = Nc-1; x >= 0; x--) {
      digitalWrite(3, bitRead(x+1, 0));
      digitalWrite(4, bitRead(x+1, 1));
      digitalWrite(5, bitRead(x+1, 2));
      digitalWrite(6, bitRead(x+1, 3));
      digitalWrite(7, bitRead(x+1, 4));
      adcmin = int((mincell - (cellsum * hicorr))/scale);
      cellsum -= Vcell[x];
      delay(adcdel);
      Serial.print("cell ");
      Serial.print(x+1);
      Serial.print(" voltage ");
      Serial.print(Vcell[x]);
      Serial.print("V ; discharge to ADC value ");
      Serial.println(adcmin);
      while (analogRead(A0) > adcmin) {
        delay(adcdel);
      }
    }
    digitalWrite(12, LOW); // 12V backup off
  }
  digitalWrite(3, LOW);  // just in case it was left on cell 1...
  digitalWrite(13, HIGH);  // balanced - start charging
  Serial.println("Charging started");
  while (maxcell < chargelim) {
    delay(logginginterval);
    scanfiltcells(); // check cell voltages
    for (int x = 0; x < Nc; x++) {
      Serial.print("cell ");
      Serial.print(x+1);
      Serial.print(" voltage ");
      Serial.print(Vcell[x]);
      Serial.print("V   ");
      Serial.println(celladc[x]);
    }
    Serial.print("cell sum ");
    Serial.print(cellsum);
    Serial.print("   min cell ");
    Serial.print(mincell);
    Serial.print("   max cell ");
    Serial.println(maxcell);
  }
  digitalWrite(13, LOW);  // full - stop charging  
  for (int x = 0; x < Nc; x++) {
    Serial.print("cell ");
    Serial.print(x+1);
    Serial.print(" voltage ");
    Serial.print(Vcell[x]);
    Serial.println("V");
  }
  Serial.println("Charging terminated");
}

void loop() {
  while (Serial.available() > 0) {
    int cellid = Serial.parseInt();
    // look for the newline. then use the number to select a cell
    if (Serial.read() == '\n') {
      scancells();
      if (cellid <= Nc) {
        for (int x = 0; x < Nc; x++) {
          Serial.print("cell ");
          Serial.print(x+1);
          Serial.print(" voltage ");
          Serial.print(Vcell[x]);
          Serial.print("V   adc reading ");
          Serial.println(celladc[x]);
        }
        Serial.println(" ");
        Serial.print("Discharging cell ");       
        Serial.println(cellid);
        digitalWrite(3, bitRead(cellid, 0));
        digitalWrite(4, bitRead(cellid, 1));
        digitalWrite(5, bitRead(cellid, 2));
        digitalWrite(6, bitRead(cellid, 3));
        digitalWrite(7, bitRead(cellid, 4));
      }
    }
  }    
}
 
6s build works a treat :) Used it on the 18650 "torpedo"/"drainpipe" battery.
18s build, bit of a PSU issue - all those relays add up to quite a bit of coil current (actually 0.72A at 12V in the worst case) and this is more than the pnp transistor can do without smoking. So I've swapped that for a p channel MOSFET & resumed testing. There's a unscheduled short circuit in there which I'll have to find and fix before I put it on scooter - it would short battery cells and that would do nobody any favours, it's a solder bridge somewhere or something. With luck I'll be able to bang it on the emax scooter tomorrow & do its first pukka automatic bottom balance. Fingers crossed :)
 
Looking forward to this. Any chance I can visit this week as Wife, dog and child are in Wales? till sunday that is.
 
This might be a bit of a naïve question but if a poorer man were to try to replicate this but not want to have to do as much soldering and design work could they not use the ready to go 5v relay modules of up to 16 relays on a single board for about £8 and then another 16 or even using the 8 and a 2 and a 1 plus the nano to control them. Yes it would be a rasts nest of wires but easy enough to setup. am I missing something? :roll:

EDIT* missing DPDT relays. Aren't so many cheap module ones of them about. but maybe use twice as many SPST if they are cheap that might work.
 
Still working on this - the little switcher was OK up to about 30V with a decent current draw but wimped out over that, Id' run it with high current and high volts, just not at the same time....
Anyway the batteries are merciless & did for every active component in the first build. Nil desperandum, No 2 build is mostly there now and I signed up for TI's WEBENCH & have an slightly tweaked design that might (should) be better. I should get the bits tomorrow; fingers crossed.
I'm sort of waiting with the scooter in bits to install this
Andy - the nice thing about the DPDT relays are that they make it impossible to put a short on any of the battery cells (I know..... nothing's impossible :))
 
Switcher working fine now at 60V and nearly an amp. phew. Turns out the LM5017 is quite a handy little chip.
I also found a board short (I must have missed it in the DRC phase) between cell 17 and the 12V rail - this is what smoked everything & why the 6s build was happy as a pig in poo. Max chip temperature now about 67degrees; that'll do.
The "webench" redesign works great and is significantly simpler than the original design I got from the datasheet.
The 12V psu measures 11.5V; I might bring it down a little more - that will reduce dissipation in the relay coils; I can make it just enough to drive the relays (according to their datasheet that's 8.4V) say 10V...
 
The 18s board is working on the scooter now:- I'm just doing its first "automated" bottom balance - it's taking some time....
I'm still not sure how/where to put the controls and switches, the have to go where they're accessible but unlikely to be accidentally switched, hmmmm
I also want to rig up a big volts and amps display - I'm too old to read the dash display (which has lousy resolution and an inappropriate scale)
I'll picture it when it's properly integrated :)
 
OK - 1st attempt at the automated balance was not so good -
problem was, bringing them all in sequence down to the voltage of the minimum cell; it starts with cell 18 then steps down through them (that way the common mode correction continues to operate correctly). If you do this, cell 18 gets discharged to the minimum voltage, but then continues to supply power to the balancer circuit while all the other cells get discharged to the minimum voltage. It's only a few tens of milliamps, but over the time period of a balancing procedure, it progressively unbalances the higher cell numbers.
So - small rewrite - the loop now scans all the cells and discharge the highest voltage one; keeps doing that until they're all within a few millivolts: (the loop is timed to 1 minute maximum)
I'll run that overnight & see how things look in the morning :)
 
Not mentioned this thing for a little while: I tried to improve the cell measurements today by putting a capacitor on the arduino's analog input. The op amp I'm using didn't like it (driving a capacitor) and the measurement got a zillion times worse. I tried 10nF and 100nF, both bad. So I put a RC filter on the opamp output, 3.3kohm and 100nF. Very sweet result, every cell measurement (conversion) identical every scan (or oscillating between 2 consecutive values).
The bottom balancing function works beautifully, and reasonably fast on the 6s 18650 battery.
I've also found a slightly larger synchronous buck chip from TI that can output a full amp. I suspect this will be needed on a fully loaded board (26s) but I should be OK short term with the 18s on the emax.
 
Nice!


Sent from my iPhone using Tapatalk
 
So I will do a redesign to tie up all the various loose ends & work with up to 26s. I'll put the schematic and the gerbers and the arduino code on here so anybody who wants can copy.
Right now the board is a mix of SMD and PTH componentry - I'll go over to SMD wherever I can, and include a couple of LEDs to show charge progress socketed for panel mount off board. Board size will stay the same but I will include a bolt hole on each corner to facilitate mounting. I won't make any more of the existing board, except to fix the broken one for Andy :) (it's got £25 worth of relays on it.......)
 
What's the expected final size?
 
Used the 6s prototype to control charging yesterday: set limit to 4.00V & charging stopped with 3.97V on cell 1 and 4.01V on cell 6 (i.e spot on). Discharge test on that battery next :)
 
I am likewise replying to follow, though perhaps I can add some things of value.

Point one...general note on these little telecom style relays:
I noted mention in an early post in the thread that these are sealed relays, and that is a good thing. Long ago I used a bunch of similar relays on a work related project. Building the boards and sourcing components was contracted out. The contractor substituted an UN-sealed version of the relay I had spec'd. They also used highly active flux in their wave solder process, and then automated immersion cleaning (think dishwasher). The boards were pristine and all worked when we received them, but began failing within a couple weeks. The relays had gotten full of water/soap in the board cleaning phase, and the relay contacts were growing fuzz, and in some cases corrosion had fused the C and NC contacts. I suppose similar problems could happen in high humidity.

Lesson: Use only sealed relays, and rosin flux makes a bit of an ugly mess, but the residue is non conductive, and not hydroscopic requires no cleaning. I prefer Kester 44 for my own use.


Point two.... This relates to relays and microcontrollers in general:
I observed a neat relay driving trick used by Elecraft of ham radio kit fame: They use bipolar latching relays, so there is no drive current used except when changing states. Ordinarily you would need 2 I/O pins per relay to drive these. Elecraft cleverly uses only one pin/relay. One lead (say +) of each relay goes to an I/O pin. Then all the other (-) leads are just tied together. In stand by, all pins are high, or all low, or all hi-z. To switch 1 relay high, pull it's pin high and all the others low. To switch it low, pull the the chosen pin low, and all the others high. Note that this only works if you need around 5 or more relays, as you are relying on the un-driven relays to have a low parallel resistance that prevents them from seeing enough voltage to switch states. You can only switch one relay at a time, but this works out perfectly for the application under discussion, as that is the goal anyway.

Lastly: Take care soldering these relays. The contacts are held in position internally by plastic bits, and too much heat on the leads when soldering can distort the internal geometry and cause problems. Just like when soldering batteries, use a big tip on a high watt iron, work quickly on each lead. I like to do a couple pins, let things cool, two more, etc. This takes no time at all if you stuff all the relays and stick them down with blu-tack or hot glue prior to soldering. DON'T bend the leads to hold them in place prior to soldering...another good way to tweak them internally.
 
You must log in or register to reply here.

Similar threads

marka-ee
design for an arduino balancer , what do you think ?
Replies
8
Views
1,248
fechter
fechter
T
Wiiciever on Arduino nano - Mods
Replies
2
Views
1,272
andrewhannay
A
S
i2c BMS for hobbyking lipos
2
Replies
31
Views
5,620
dmwahl
dmwahl
battman
Barron Greig's MAX14920 Based Perfboard BMS
Replies
12
Views
5,764
Madhi2023
M
T
FREE Step By Step 6S Electric Longboard Build Guide
2
Replies
42
Views
58,227
torqueboards
T
Back
Top