Electronics – Copy Error

Agilent 6632B Repair & Front Panel conversion

Posted on October 2, 2015 by Tom Heiber — 1 Comment ↓

I picked up a “gently used” Agilent 6632B 0-20V, 0-5A Power Supply from Kijiji the other day. Seemed like a kick ass deal so I jumped on it. The power supply was in decent shape, a bit dirty but fully functional. This is my first pro grade DC power supply. Not only it is extremely precise, has remote sense, it can also act as a variable load and it can sink the same 5A that it can dish out.

As this version of the power supply is meant to be used in a rack, the outputs are located on the back. Since I will be using it on the bench, I wanted front mounted binding posts.

As I was cleaning the exterior of the power supply I noticed that the rotary encoder on the front was very wobbly. During power on testing it would intermittently not register the rotation. This was something I needed to fix.

Removing the enclosure on the power supply is very easy. A few visible screws on the side and one screw on each side of the front panel that’s hidden behind a self adhesive strip.

Love the interior of this thing. Massive mains transformer, huge heatsink to dissipate the 100W of load. Massive caps.

Disconnecting the front panel is easy. Just 4 wires to the mains switch and a ribbon cable to the back control board (J210 connector).

Once disconnected removing the control board from the plastic enclosure was just a matter of sliding it off to one side.

Fixing the rotary encoder was very easy. The encoder is built from two parts held by pressed pins. The pins were loose and simply needed to be bent back to retighten the package. Easy stuff.

What was really surprising was the pre-cut holes in the front panel for binding posts. Looks like the same bezel is used in both rack mount and bench models. This makes drilling holes in the bezel easy and not much measurement required.

I had a choice of two types of binding posts to use. I have a premium set of posts that I wanted to use but I realized that the front panel is metallic so using mounting an all metal binding post wasn’t a very good idea. I chose the cheaper but still decent posts instead.

One feature I wanted to implement is to have a local/remote sense option without having to use jumpers which is what the rear panel was designed to do. Instead, I installed a DPST switch (actually DPDT cause I didn’t have the right one) to switch between sensing at the binding post terminals and optionally at the load with the additional binding posts. I used 16AWG stranded wire to which is more than sufficient to carry 100W between the front and back of the power supply. The sense wires could have been thinner but I wanted to keep the internal resistance as low as possible.

Once the binding posts were and installed and the wires soldered on. I labeled the binding posts and switch positions.

The rear connections were crimped using spade connectors. There was enough gap between the terminal strip and the enclosure to run the wires. Even though the edge of the enclosure is rather sharp I’m not too concerned about cutting through insulation as the power supply will see minimal movement.

Note: The sense wires should have been twisted to keep noise to a minimum. I didn’t realize this till after reassembling the power supply and the wires were too short to twist them so I just left it alone for now, I might fix this in the future

Once the connections were made it was just a matter of reassembly and testing. And it tested perfectly. Easy job and now I have a kick-ass bench power supply.

The depth of the Agilent enclosure is perfect. Not even 1/8″ of clearance between the edge of the shelf and the back of the workbench. Almost as if it were meant to be. Can’t wait to use this power supply on my next project (coming really soon)

Baytech RPC3 Remote Power Controller

Posted on April 25, 2014 by Tom Heiber — 10 Comments ↓

Thanks to another great find by members over at Serve The Home forums, I picked up a couple of Baytech RPC-3 remote PDUs for dirt cheap.

Even though the Baytech Units are rated for 20Amps and come with a 20 amp plug, my home feed is only 15A so first order of business is to convert the 20 amp plug to a standard 15A one.

I picked up a couple of heavy duty plugs at Home Depot and went to work.

Simply cut off the existing plug and strip the individual wires

Then simply attach the wires to the new plug (make sure you get the Hot/Neutral/Ground right)

Reassemble the plug, all done.

Once both units were rewired it was time to configure them. One of the switches didn’t come with an IP address sticker and I tried unsuccessfully to discover the IP address manually. It was becoming apparent that I’d have to configure the switch via serial connection.

Unfortunately the baytech units use a non-standard DB9 to RJ-45 cable. Thankfully, Good Guy Baytech supplies the complete pinout in the manual so that you can make your own cable.

Note: The diagram assumes that this cable will be used with a Null Modem (rollover cable) and is pinned out as such

Making the cable is very straight forward. All that was needed was a short Cat-5e Patch cable, a female DB9 connector and some basic soldering skills. Simply cut the end of the patch cable, follow the pinout diagram and match up the wire colors in the opposite end of the cable to the proper DB9 pins. I ended up simply writing down the colors to pin matching so the soldering job went faster

Few minutes later I had a working Baytech cable.

Fortunately the console was not password protected so it was easy to change the admin password. If however the console was passworded here are the reset instructions for Baytech RPC3’s

1. Turn off the power to the RPC3
2. Remove the lid
3. Locate JP1 on the Ethernet board
4. The jumper is placed on pins 1 and 2, move it to 2 and 3
5. Turn power on for 10 seconds
6. Turn power off
7. Return jumper to its original position.

Once the IP address was configured via the serial console, the unit was ready for remote access

One last order of business before racking up the units was to provide a GUI driven interface for the unit. Since the RPC-3 uses basic command line telnet connection it was relatively easy to develop a basic app to control and monitor the unit remotely. Few hours of coding and I came up with a simple app that interfaces with the units.

The app can control individual outlets by right clicking on it, or many at once by selecting the check boxes and invoking an action.

Link to App: http://www.copyerror.com/shared/BaytechControl.zip

Now it’s just a matter of racking it up and plugging everything in.

The only complaint about these boxes is the master on-off button. I wish there would be some sort of cover over the switch as it’d be very easy to accidentally kill the entire pdu dropping all devices.

Manual: U140E125-05_rpc

Another RC Flasher Build

Posted on February 22, 2014 by Tom Heiber — No Comments ↓

I built few more RC flasher boards. Few for friends and one more for another truck of mine. Same design as original but slightly different Arduino code.

RGB Fan Mod

Posted on February 13, 2014 by Tom Heiber — No Comments ↓

Few months ago I used some RGB LED lighting in my room (eBay China special). The setup uses an IR remote control and a control box to control the lighting. Power is supplied via a high current 12V power supply (10A supply)

My “gaming” computer uses green LED fans which looks kind of odd when using any other color on the strip. Changing the color of the computer required swapping the fans for a different color.

So, I decided to modify the fans to sync the colors of the fans with the rest of lighting. I already had tons of RGB LED’s, so it was really a matter of A LOT of soldering. One thing to note is that the LED ligthing system uses common Anode configuration, with a single 12V rail and 3 (RGB) grounds.

Once I pulled the fans from the computer, I had to remove the old green LEDs from the fan.

Fortunately the LEDs are simply pressed into place and not glued. This makes them easy to pop out with just a little bit of force.

The leads for the fans are connected to a small circuit board underneath the sticker on the fan

A quick application of a soldering iron and all the LED leads have been removed. Since the LEDs are no longer supplied with fan voltage rail, the brightness of the LEDs will no longer be tied to the speed of the fans.

The RGB leds a just tiny bit larger than the original LEDs so it took a bit of extra force to press them into the socket.

I used standard ribbon cable to carry the RGB voltages across the LEDs in the fan. The individual current for each fan is very low so the ribbon cable can easily handle the load.

All LEDs were connected via point-to-point connections. This was actually a fair bit of work. The ribbon cable is quite delicate so I had to take extra care when stripping the wire ends as not to cut the lead.

The ribbon cable is nice and flat so it doesn’t affect the overall diameter of the fan much. Still, there would be certain configuration where the fans are too close to an edge where this would be problematic. Fortunately in my case, the fans are spaced sufficiently apart that the ribbon cable doesn’t interfere.

Once all the LEDs were electrically connected they had to be terminated via current limiting resistors. During bench testing I found that the 470ohm resistors provided the best brightness to current ratio at 12V. Since the LED receives power on a common Anode and each color draws slightly different amount of current, it’s important to place the resistors on the individual color leads. Putting the resistor on the anode pin will not work properly when using more than one color at a time.

With the first fan completed I did some testing to see how the setup will stack up. I wasn’t sure if the RGB LEDs will be bright enough.

At 12V the individual colors only draw about 30mA per fan.

With all the colors lit, the draw was just 90mA. Which works out to under 500mA for the whole computer. A negligible load on the control box for the ambient lighting.

To connect the fans to the LED strip I bought some JST 4 pin connectors. It’s surprisingly difficult to find small 4 pin connectors locally, so I had to do another China eBay order and wait another month for them to show up.

To complete the connection, all the resistors were then wrapped via heatshrink and soldered to the connectors. I gave each fan about 8″ of wire to make the connections between the fans easy.

To connect all the fans together and to connect them to the LED strip I braided few 24 gauge wires to make a nice flat cable. This cable will run outside of the computer via a hole (meant for water cooling hose) in the computer case.

Once all the fans were soldered up, I installed them back into the computer. My wire organization skills are certainly not the best, but then again this is just a Mini ATX case so not heck a lot of room to stash the cabling.

Last step was to connect the supply cable to the LED strip and turn it all on.

Here’s a short video of the LED system, with the light mode set to cycle all colors.

Minuteman RPM1601 Smart Power Switch

Posted on December 7, 2013 by Tom Heiber — 2 Comments ↓

I did another border run recently to pick up some more eBay goodies.

Over the last month or so I scored some incredible deals on server hardware. Picked up a couple of Intel SR1680MV Dual node servers, my favorite in 1U config right now. A really cheap HP Storageworks MSA70 with 25 Trays and some other items.

Also picked up a pair of Minuteman Remote Power Management switches. These babies use to sell for over $800 a piece, I picked them up for about $20 each. Now granted these are most likely VERY old devices. I’ve never heard of Minuteman but for that price I was very much willing to give them a shot.

Each switch can manage 8 power ports. Each port can be designated for remote operation (via HTTP, Telnet or SNMP) or local only.

The switches come with 8 power ports each rated for a total of 12A @ 120V. Unfortunately the switches do not report actual power draw at port or total. Each power port comes with it’s own RJ11 port that can be use to interface with a respective UPS or Computer, a feature I’ll most likely never use.

The switches were both “supposed” to come with a management card but the seller screwed up and sent me only one. Since I already considered this a pretty good deal I didn’t want to send them back even though the seller offered a full refund.

The lack of a second management module isn’t a big deal since these devices can be chained and managed from a single card, but more on that later.

First order of business is to try to log into the thing. Unfortunately the devices came with no instructions or passwords of any kind. So, I connected the switch to my lab network and checked to see if by any chance the device is set for DHCP. No luck, DHCP lease list didn’t show any new devices on the network. A quick search for a manual on the Minuteman site and I came across SNMP based discovery snmp32_utility.

Once again ran into a small issue as the software doesn’t seem to work under Windows 7 and up (network list is empty).

Fortunately I have an old toughbook kicking around that has Windows XP 32 bit installed. A quick install and bingo! the device shows up. Attempting to access the device resulted in a password prompt. Once again I lucked out since the password was simply set to “admin” and it only took me 3 tries to figure it out.

I cleared the password and set the device for DHCP.

Once web access got enabled I fired up my browser and pointed it at the device IP. Crap! Another password prompt. This time no amount of defaults was able to bypass this login screen.

Fortunately, through a lot of web searching I found a procedure to factory reset the management card which clears any passwords on it. The process is as follows

* Remove the screws holding the management card in place
* Using a small tool press the "Reset" button on the management card and hold
* While holding the reset button pull the management card out of the switch unit
* Continue holding the reset button, wait a few second then re-insert the card to power it up.
* Continue holding the reset button for another 40 seconds and release.
The management card has been fully reset.

Once the card resets, reconfigure the card for DHCP again and use blank login/password on the site credentials and *boom* we’re in.

Now that we have access to the card, time to figure out how to chain the two. Based on the manual for the device. The switch comes with an “iLink” cable and a terminator plug. I received no cable and only one plug.

I picked up a 6 lane RJ11 cable and plugged it into the boxes as described by the manual. However, no matter how I placed the cable and the one terminator plug, the device would never see the second box.

My first assumption was that I need a second terminator plug to close the loop. Since I only had one I decided to figure out how it works and build another one. I was pretty sure that due to the small size of the plug only passive circuitry is used inside. A quick run-through with a multi meter confirmed my theory and I determined the internal connections in the plug.

The pins on the terminator plug are simply connected via 1K and 5K resistors.

All I had to do was build a similar plug. I quickly whipped up a ghetto plug for testing and confirmed that it works since the master switch behaves slightly differently with it plugged in.

Once again ran into a roadblock. The addition of the second terminator did not result in connectivity between the two switches. Upon closer inspection of the cable I realized that the wires in the cable are not straight-through but rather reversed.

I snipped the cable, reversed the wires and put another RJ11 plug on it and EUREKA! Both switches are accessible via the management interface. It also turns out that the terminators seem to be unnecessary in this configuration as the switches had no problem operating with the terminators removed.

I will probably toss these into one of my data centers where I’ll be able to reboot machines without having to drive for over an hour.

Files for this product:
snmp32_utility
SNMP-32-SL_manual
RPM_manual

New Project Idea!

Posted on September 11, 2013 by Tom Heiber — No Comments ↓

Ok. Not much detail yet. But I have a couple of Beaglebone Blacks and a couple of Raspberry PIs on the way. Guess I should brush up on my Python…..

Update: Sept 12, 2013
The BeagleBone and RasPi boards have arrived. Really looking forward to seeing what they can do. I still can’t get over how tiny those things are.

RC Flasher Project

Posted on June 10, 2013 by Tom Heiber — No Comments ↓

My RC Flasher Project is complete. I’ve done a write up of it here.

Gauge Pod 2.0 – Sender (pt 2)

Posted on March 9, 2013 by Tom Heiber — No Comments ↓

I’ve spent about 2 days on dealing with the ADC (Analog to Digital Converter) of the Arduino platform. Turns out there’s more problems to overcome when dealing with taking analog signal from a sensor and converting it to meaningful digital reading.

The issue is that even with a constant input voltage the ADC reading sampling error rate is larger than I’d like (~1.2%) with some random spikes in excess of 3%.

I built a test rig to troubleshoot the issue. Using constant input voltage and a potentiometer to simulate the analog input from a sensor.

Goal:

– At least 4 sample updates per second. (Smooth gauge updates)
– Stable voltage regardless of outside interference.

Things I found:
– Arduino Atmel chip uses a single ADC and multiplexes the input pins.
– Switching read pin on the ADC causes noise in the system. Solution to read the first value and totally discard it. Then wait at least 10ms before sampling actual data.
– Sample accuracy is inversely proportional to the delay between samples. Shorter delay between reads, less drift. But over a static period of time, the error rate is the same.
– ADC is quite sensitive to electronic noise. Adjacent pins seem to affect reading.

Things I tried:

– Average voltage over multiple samples (currently 11 samples per read)
– Add delay between readings (1 to 12 ms) (currently 2ms)
– Discard top and bottom values and average the rest (currently discard 25%)
– Add a delta value, discard new value if difference is less than delta (currently 0.011V)
– vary delay on multiplex debounce (currently 10ms)

Current sampling rate: 3.7 samples / second.

Final Arduino Code:

const int LED_RED = 9;
const int LED_GREEN = 8;
const int LED_BLUE = 7;
const int LED_ACT = 11;
const int INPUT_REF = 22;
const int INPUT_RATE = 20;

int refPins[4] = {19, 17, 18, 16};
int sensePins[4] = {15, 13, 14, 12};
double lastRefVolts[4] = { 0, 0, 0, 0 };
double lastSenseVolts[4] = { 0, 0, 0, 0 };

const float LOW_VOLTAGE = 4.5; //alert voltage for 5V bus

const int MAX_SAMPLES = 50; //max sample on trim pot
const float DISCARD_PCT = 0.25; //percent of samples to discard (top and bottom)
const float MAX_DELTA = 0.011; //ignore changes less than this
const int SAMPLE_DELAY = 2; //delay MS between sample reads
const int INITIAL_DELAY = 10; //delay MS on pin change


void setup()
{
  
  //set pin IO modes
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_BLUE, OUTPUT);
  pinMode(LED_ACT, OUTPUT);
  
  for (int pin = 0; pin < 4; pin++) 
  {
    pinMode(refPins[pin], INPUT);
    pinMode(sensePins[pin], INPUT);
  }
  
  pinMode(INPUT_REF, INPUT);
  pinMode(INPUT_RATE, INPUT); 
  
  //cycle leds
  digitalWrite(LED_RED, HIGH);
  digitalWrite(LED_BLUE, HIGH);
  digitalWrite(LED_GREEN, HIGH);

  setLED(LOW, HIGH, HIGH);
  delay(200);
  setLED(HIGH, LOW, HIGH);
  delay(200);
  setLED(HIGH, HIGH, LOW);
  delay(200);
  setLED(LOW, LOW, LOW);
  delay(200);
  setLED(HIGH, HIGH, HIGH);

  //emulated serial, speed ignored  
  Serial.begin(38400);
  
}

void loop()
{
    
   //read serial to clear buffer
  if (Serial.available() > 0)
  {
    Serial.flush(); 
  }

  //get number of samples to read
  int readCount = getReadCount();

  //write +5V bus voltage
  writeRefVoltage(readCount);

  //write all input sensors
  for (int pin = 0; pin < 4; pin++) {
    writeSerialVoltage(pin, readCount);
  }
  
}

void writeSerialVoltage(int pin, int readCount) 
{

  digitalWrite(LED_BLUE, HIGH); //blue off - start sending
  digitalWrite(LED_ACT, LOW); //internal off
    
  //ref volt, seems more volatile
  float refVolt = getVoltage(refPins[pin], readCount);
  float newRefVolt = processRefVoltage(pin, refVolt);

  //get sensor voltage
  float senseVolt = getVoltage(sensePins[pin], readCount);
  float newSenseVolt = processSenseVoltage(pin, senseVolt);


  Serial.print("IN");  //write identifier
  Serial.print(pin);
  Serial.print("\t");
  Serial.print(newRefVolt, 4); 
  Serial.print("\t");
  Serial.print(newSenseVolt, 4);
  Serial.print("\r");
  Serial.println("");
  
  digitalWrite(LED_ACT, HIGH); //internal on
  digitalWrite(LED_BLUE, LOW); //blue on - sending done

}

//do a delta comparison on Ref voltage
float processRefVoltage(int Pin, float refVolt) 
{
  
  float lastRefVolt = lastRefVolts[Pin];

   if (abs(refVolt - lastRefVolt) < MAX_DELTA)
     refVolt = lastRefVolts[Pin];
   else
     lastRefVolts[Pin] = refVolt;  
    
    return refVolt;

}

//do delta comparison on sensor voltage
float processSenseVoltage(int Pin, float senseVolt) 
{
  
  float lastSenseVolt = lastSenseVolts[Pin];

   if (abs(senseVolt - lastSenseVolt) < MAX_DELTA)
      senseVolt = lastSenseVolts[Pin];
  else 
     lastSenseVolts[Pin] = senseVolt;
    
    return senseVolt;
}


//send bus voltage to host
void writeRefVoltage(int readCount) {
  
  float refVoltage = getVoltage(INPUT_REF, readCount);
  
  if (refVoltage < LOW_VOLTAGE) 
  {
    digitalWrite(LED_RED, LOW);
    digitalWrite(LED_GREEN, HIGH);
  }
  else
  {
    digitalWrite(LED_RED, HIGH);
    digitalWrite(LED_GREEN, LOW);
  }
    
  Serial.print("REF\t");
  Serial.print(refVoltage, 4);
  Serial.println("");
}

//read value from ADC (0-1023) and convert to voltage (0-5)
float getVoltage(int PIN, int samples) {
  
  //allow ADC to stablize
  analogRead(PIN); //ignore value
  delay(INITIAL_DELAY); //wait for debounce
  
  float sampleList[samples]; 

  //read samples
  for (int i = 0; i < samples; i++) 
  {
    float voltage = (float)analogRead(PIN) * (5.0 / 1024.0);
    //round to 2 decimals
    sampleList[i] = (ceil(voltage * 100.0)) / 100.0;
    delay(SAMPLE_DELAY);
  }
  
   //sort array (shitty bubble sort, cause i'm lazy)
    float swapper;
    for (int o = samples-1; o > 0; o--) {
        for (int i = 1; i <= o; i++) {
          if (sampleList[i-1] > sampleList[i]) {
          swapper = sampleList[i-1];
          sampleList [i-1] = sampleList[i];
          sampleList[i] = swapper;
        }
      }
    }
      
      //discard % of top and bottom values, average the rest
      int avgStart = max(samples * DISCARD_PCT, 1); //array start
      int avgEnd = min(samples * (1.0 - DISCARD_PCT), samples); //array end
      
      int avgSamples = 0;
      float ret = 0;
      
      //average out the values
      for (int cntr = avgStart; cntr < avgEnd; cntr++) 
      {
        avgSamples++;
        ret += sampleList[cntr];
      }
     
      return ret / (float)avgSamples;
}

//read trim pot, get average samples
int getReadCount() {
 
  analogRead(INPUT_RATE);
  int readCount = analogRead(INPUT_RATE);
  return map(readCount, 0, 1023, 4, MAX_SAMPLES);
  
}


//set RGB led values
void setLED(int RED, int GREEN, int BLUE) {
digitalWrite(LED_RED, RED);
digitalWrite(LED_GREEN, GREEN);
digitalWrite(LED_BLUE, BLUE);
}

Binary sketch size: 7,196 bytes (of a 32,256 byte maximum)
Estimated memory use: 103 bytes (of a 2,560 byte maximum)

This is probably as close as I can get to get an accurate reading that doesn't jump around too much. Filters most noise while giving a decent sample rate. Currently reading all 4 inputs. Technically could reduce to 3 inputs since 4th won't be used for a while. Will see how well Gauge Pod software deals with current feed rate.

Gauge Pod 2.0 – Sender

Posted on March 5, 2013 by Tom Heiber — No Comments ↓

I’ve started working on Gauge Pod 2.0 for the Challenger. The original version had some issues as described here.

The original sender was located under the dash. Currently utilizes three sensors (AFR, Boost and Fuel Pressure). The box was built to support more sensors but in the end I ended up using only those three. I used 3 pin molex connectors which turned out to the a bad idea as the connections weren’t very secure. Additionally I had to make some last minute modifications to feed a 5V signal to the sensors. In the end the box was way too bulky and not terribly efficient.

Due to the fact that the Arduino Diecimila uses pin connections (as it’s more for prototyping), the connections weren’t very good. While I had no problem with the connections themselves, I didn’t feel that this was sufficient for long term use. The next sender will have everything properly soldered.

The enclosure I used was also too large even for the size of the board. The new Arduino board (Teensy) is tiny compared to the original board. Teensy is actually more powerful than the Diecimila board, as it offers double the RAM (whooping 2K), double the Flash (32K) and a lot of PWM outputs and Analog inputs. Additionally, the Teensy board can act as native USB device, no need for serial port emulation. It’s also quite cheaper than the official Arduino.

Sensor voltage is supplied via an RC BEC board from Castle Creations. The BEC can be programmed for any output voltage. Originally the board was programmed for 5.1V from factory. The BEC is most likely type of MOSFET voltage regulator instead of the more traditional linear regulator. This does introduce a bit of noise into the system as the PWM system typically operates in the Khz range. Though, with bench testing I didn’t see any significant problems with this.

I didn’t actually realize right away that I had a programmer for the BEC. I picked one up last year for my Mamba Pro ESC. With just a few clicks of a button I was able to program it for 5V.

One of my theories for the flactuating voltage is that one or more sensors was putting too much load on the BEC. During testing I noticed that with higher amperages the BEC supplied voltage would drop. At 0.7A the voltage dropped to almost 4V. This was quite unusual since the BEC is rated at 10A. To mitigate this problem I’m using some inline, low ohm resistors to current limit the supply. This should prevent excessive load on the BEC.

For the input voltage and sensors I’m using 2 and 4 pin barrel connectors.

Connector Pinouts:

Sensor Input Barrel Connector:
1 – Black – Ground
2 – Red – +5V
3 – Blue – +5V (Current Limited)
4 – Green – Sense In

Power In Barrel Connector
1 – Black – Ground
2 – Red – +12V (ACC)

Teensy Sensor Pins:

Input	Sense Pin	Ref Pin
Input 1	15	19
Input 2	13	17
Input 3	14	18
Input 4	12	16

I’m also using an RGB LED for status indicator. The LED uses a common anode, so the LED turns on when driving Teensy pin LOW.

LED Pins on Teensy:
Common Anode: 5V
Red: 9
Green: 8
Blue: 7
Internal: 11

The Blue indicator blinks when new voltage data is sent. The Green indicator is on when the sensor supply voltage is above 4.5V. The Green indicator changes to Red if the voltage drops below 4.5V

I’m using a small perf board to solder all the components on. There’s not much to it. A few 1/4W resisitors for current limiting sensors, few resistors for the RGB LED and a trim pot for adjusting data rate.

The box all done. There’s a small hole on the side for the mini-USB connector that will connect via USB cable to the carputer. This will in turn be read by the Gauge Pod software, parsed and displayed as an analog gauge on the screen.

Last step was to solder up some of the female connectors that will be spliced into the Challenger itself. Just three sensor connections for now. I might add oil pressure sensor later down the line.

Thanks to the use of the reference voltage on each input any fluctuations of supply voltage and ADC error will be smoothed out. The Arduino sketch is very simple. The sender simply sends tab delimited data to the USB device in the format:

{INPUT}\t{REF_VOLT}\t{SENSE_VOLT}\r\n

e.g. IN1\t5.00\t2.00\r\n

This is repeated for each sensor input and finally sends the supply voltage: REF\t5.00\r\n

Final Features:
* USB HID Device. No more COM ports, no drivers needed.
* Reference Voltage on all inputs
* Reference supply voltage for each sensor
* Variable sending speed via trim pot
* Low Supply Voltage Indicator (less than 4.5V)
* Serial sending / Keep Alive Indicator
* Vibration proof screw-in type connectors
* Dual Current limited/non-limited sensor connectors

With the sender box complete, the next step is to re-write the Gauge Pod software to fix some of the issues and add some additional features.

Traxxas Slash + 1W LEDs

Posted on February 10, 2013 by Tom Heiber — No Comments ↓

A while ago I was browsing parts in a local hobby store and I came across an RPM part for my Traxxas Slash. It’s an offroad light bar (RPM #80922). The product is meant to be used with typical 3mm LED’s, in fact, RPM sells an LED kit that fits the canisters. Looking at the LEDs I knew the LEDs were for show only as the LEDs included don’t do much for illumination, typical 3mm LEDs produce between 1500 and 3000 mcd of light intensity with a rather narrow beam of light. Looks pretty, but that’s about it.

As soon as I saw this I knew I could take it to the next level. As I always say, if something is worth doing, it’s worth overdoing. So as soon as I got home I went on eBay and picked up a set of these puppies.

These are 1W Ultra Bright LEDs with built in heatsinks. These babies produce over 8000 mcd of light. Not only that, they have an extremely wide angle of view. These LEDs are blindingly bright, a perfect choice for some illumination for the truck.

First step is to determine the best heat/brightness ratio. I did this by trying various values of resistors to get best brightness while maintaining heat at constant temperature. The LEDs in the canister will not be able to sink any heat. I used a thermal probe to get a reading on both the resistor and the LEDs heatsink. I ended up going with 22 ohm 1/4W resistors. After an hour under load the temperature was stable at 50C on the resistor and about 44C on the LED’s heatsink with ambient temperature of about 26C (toasty next to the servers).

I was having trouble finding some low gauge wire that I could use for the individual LEDs. The only thing I could find on spools was 24AWG which was still bit too thick for my liking. I stumbled across a roll of ribbon cable with what looked like 30AWG wire. It was perfect.
Soldering the LEDs was very quick and painless as the built in heatsink on the LED took care of protecting the LED from the heat from the soldering iron. The L#D canisters have a small hole in the back, the ribbon wire had no trouble passing through.

The next step is to solder the resistors inline. The best way I figured is to stagger the resistors so that when held together they don’t create a fat bundle.

After that it’s just a matter of going to town with heatshrink to isolate all connections

Before permanently affixing the LEDs in their respective canisters I needed to test the connections and make sure all LEDs light up.

Once I confirmed that all LEDs are working properly, it was time to affix the LEDs to the canisters. I decided to use 30 minute Epoxy to give me plenty of time to align the LEDs properly.

What I missed though is that mixing a larger batch of epoxy causes a MUCH shorter curing time. In fact, the epoxy started to set just minutes after mixing the batch. I tried to work quickly applying the epoxy to each canister before the batch became unusable. The results were less than stellar. At least I still had time to align the LEDs but it was too late to try to remove some surplus.

The RPM kits came with lenses that can be used with the LED canisters. Unfortunately due to the size of the 1W LED, the lens can not be used in this configuration. Which I don’t think it’s a big deal, I can see the cheap plastic lens getting scratched and becoming opaque in very little time.

The grilles on for the canister fir perfectly though. Good thing too because it hides some of the ugly spillover epoxy inside the canisters. Mixed a much smaller batch this time so I had plenty of time to align the grilles.

Once the epoxy has cured it was time to attach the bar to the body and do final testing. The light bar actually fits very nicely on the truck.

Shortly after I did this build I decided to take another step and add the bumper lights. Plus a friend asked me to do a set for him too. Back onto eBay to pick up RPM #80982 and few extra LEDs.

The process was pretty much the same as building the top light bar.

Once all wiring was done. It was time again to test the new LED arrays. Once again, zero problems with soldering these things. Just 8 LEDs in an array gobbled up a full 1 AMP of current. Having 10 LEDs on the truck will definitely put the receiver connection at a strain.

Just like the top bar, the lenses were skipped due to LED size, but the grilles went on without issues.

Last step was to solder up some Futaba/JR connectors to the LEDs for easy connections. I’ve used some servo extensions to do the job. Just cut off the male connector and solder the female to the LED leads.

Time to do final mounting to the truck. Routed the wiring through the H frame.

The RPM kit fits perfectly in the bumper using existing screw holes. The LEDs are definitely bright. It huts my eyes just looking at them.

Some night shots. The camera really doesn’t do it justice. These LEDs are very, very bright.

Some quick snaps showing just how much illumination these things provide. Other than the little night light these were taken in near perfect darkness.

Can’t wait to try these out night racing.