I originally intended this project to weld thin sheetmetal tabs to stuff to act as solder tabs. The project has not been as easy as I originally thought though. (It also suffered some scope creep) It’s my first crack at 5V logic mixed with line AC voltage, and for rolling my own power supply. I used a step-down transformer, bridge regulator and a capacitor to feed an LDO regulator for the control circuit. With the low current draw of the controller, the voltage input to the regulator was relatively free from any ripple thanks to the capacitor.

I ended up frying a processor, LCD, and a couple other components due to a dumb move while troubleshooting the circuit, and overlooking a capacitor’s voltage rating. 120VAC will eat 5V stuff for lunch.

The control circuit basically modulates the SCR, which is hooked up to the output of the bridge rectifier after a step-down transformer. The controller allows for adjustment of duration of the weld and amount of the rectified AC phase that is delivered to the workpiece. The controller holds off the SCR until a pre-determined time of each half phase to control power delivery. An analog comparator detects the zero point of the phase for timing purposes, via a seperate bridge rectifier that has it’s ouput fed through a large resistor to the comparator. A zener clamps the current-limited voltage at 4.8V so as not to damage the micro’s input. A high-to-low transition on the comparator triggers the zero crossing timer. The threshhold voltage is adjustable by an on-board pot.

I also added an Allegro hall effect current sensor that I had lying around from my alternator current sense project. It’s overkill, but it measures the amount of peak current being delivered and displays it on the LCD.

The controller is an ATmega88PA running at 8Mhz. Firmware is written in C with AVRStudio and AVR-GCC. The micro reads the power and duration settings, displays that on the LCD, along with the max current for the last weld cycle and the temperature of the mega’s on-chip sensor. The controller also handles timing duties, zero crossing detection, and control of the SCR gate. The gate is fired by a P-channel MOSFET, with the FET’s gate driven by an NPN BJT on one of the micro’s pins. A footswitch is used as input to the micro to trigger a weld cycle. Both the footswitch input and the zero crossings are buffered by a simple three-sample debouncing routine to prevent erroneous triggers. The system also checks for the footswitch input on power up and after the weld cycle is complete, and waits if the footswitch is down with a message on the LCD to release the footswitch. This allows for safety as well as eliminating any unintended re-triggers at very short durations. Duration is adjustable from roughly one ac cycle to 60 cycles (1 sec). Power control allows from 5% to 95% of each half phase to be delivered to the workpiece.

The SCR’s cathode voltage is available at PORTC2 as a 10:1 voltage divider, and clamped with a zener to prevent damage to the micro. I didn’t need it, so it’s not used in the code.

I’ve also added a power resistor to the output to limit current. I used carbon-carbon as a power resistor (I work in a carbon plant) since it’s free and power resistors are expensive. You only need a few tenths of an ohm to limit the current to a level that won’t destroy the diodes and SCR. I’m overdriving mine at about 130A maximum. It seems to handle it fine for the short bursts.  [Edit: 130A isn't enough though. I may rewire so the diodes/SCR are on the input side and push the current higher by removing or modifying the resistor. Pressure of the electrodes on the joint is also important, still figuring that out.]

Here’s some drive waveforms: yellow is the output voltage (it’s at 50V/div so it looks small), purple is the output current measured by the hall sensor, blue is the FET’s gate that turns on the SCR, and green is the bridge voltage.

This project has got me thinking about modifying my old ”buzzbox” AC welder. I’ve got some big capacitors and IGBTs from a couple old motor drives that could give me a really nice TIG welding power supply. I think I’ve read you can weld high frequency (1-2kHz?) square-wave without needing any HF section. If I remember right square-wave with a positive DC offset is sort of the ultimate TIG welder. Anybody with comments or information about that feel free to drop me a line.

Continue reading for the schematic, PCB layout, and code.

References: Miller Resistance Spot Welding

The schematic: (Click on the picture for full size)

The board: (Click for full-size image)

And the code. I think it’s all correct but I had to rewire a couple things on mine so you might do well to doublecheck the I/O is all correct.

——————————————————————————————————————————

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
//#include <avr/wdt.h> // can’t get the watchdog to work yet

#define F_CPU 8000000; //8MHz

//function declarations
void lcd_write_byte(unsigned char CONTROL, unsigned char DATA);
void initLCD(void);
void updateLCD(void);
void switch_up(void);
void weld_message(void);

//global variables
volatile unsigned int power, duration, temperature;
volatile unsigned char current, max_current;

void main(void)
{
 unsigned int old_power, old_duration= 0; //variables for comparison

 PRR &= ~(1<<PRADC);  //disable ADC power reduction
 ADMUX |= (1<<REFS0); //setup VCC as reference
 ADMUX |= (1<<ADLAR); //left adjust result for 8 bit ADC
 ADCSRA |= (1<<ADPS0)|(1<<ADPS1)|(1<<ADPS2); //prescaler clk/64 125kHz @ 8MHz clock
 ADCSRA |= (1<<ADEN); //enable ADC

 TCCR1B |= (1<<CS10); //enable timer1, no prescale (clk/1)

 ACSR |= (1<<ACIS1); //enable analog comparator falling edge interrupt
 ACSR |= (1<<ACIE); //enable analog comparator interrupt

 DDRC |= (1<<PORTC3); //SCR gate drive
 DDRC &= ~((1<<PORTC0)|(1<<PORTC1)|(1<<PORTC2)); //set as input
 PORTC &= ~((1<<PORTC0)|(1<<PORTC1)|(1<<PORTC2)); //PUD

 DDRD |= (1<<PORTD0)|(1<<PORTD1)|(1<<PORTD2)|(1<<PORTD3)|(1<<PORTD4)|(1<<PORTD5);
 DDRD &= ~((1<<PORTD6)|(1<<PORTD7)); //set as input
 PORTD &= ~((1<<PORTD6)|(1<<PORTD7)); //PUD

 DDRB &= ~(1<<PORTB0);  //footswitch input
 PORTB &= ~(1<<PORTB0);  //PUD

 initLCD(); //set up LCD

 switch_up(); //check footswitch

 max_current= 0×7F;
 updateLCD(); //display settings

// wdt_reset(); //reset the watchdog timer
// WDTCSR |= (1<<WDCE)|(1<<WDE); //clear the system reset/ change enable bits
// WDTCSR |= (1<<WDE)|(1<<WDP0)|(1<<WDP1)|(1<<WDP2); //set new prescaler, 2 seconds

 
 while(1)
 {
  old_power= power;  //set up the comparsison value before getting new value
  ADMUX &= ~((1<<MUX0)|(1<<MUX1)|(1<<MUX2)|(1<<MUX3)); //sample ADC0 (power setting)
  ADCSRA |= (1<<ADSC); //start conversion
  while(ADCSRA & (1<<ADSC)){} //wait for conversion
  power= ADCH;
  power*= 234; //scale power for use later: ((2^8)*234)= 59904 max value
      //59904 clk cycles= (1/8000000)*59904= 7.5ms
      //7.5ms= (.0075/(1/120))*100= 90% of one half wave (60Hz)
      //with these values power can be up to 90% of each half wave,
      //which with the 5% coded into the ISR, yields a range of 5%-95%.

  old_duration= duration;  //set up the comparsison value before getting new value
  ADMUX |= (1<<MUX0);  //sample ADC1 (duration setting)
  ADCSRA |= (1<<ADSC); //start conversion
  while(ADCSRA & (1<<ADSC)){} //wait for conversion
  duration= ADCH; 
  duration= (duration>>1); //convert to 7-bit number, limits duration to ~1 second
  if(duration<=0×0007) duration= 0×0000;
   else duration-= 0×0007; //subtract 7 so duration can’t exceed 3 digits (999ms)

  ADMUX &= ~((1<<MUX0)|(1<<MUX1)|(1<<MUX2));  //set up for ADC8 (temp)
  ADMUX |= (1<<MUX3);
  ADMUX |= (1<<REFS0)|(1<<REFS1);  //1.1V ADC reference
  ADMUX &= ~(1<<ADLAR); //undo left adjust result for 8 bit ADC 
  ADCSRA |= (1<<ADSC); //start conversion
  while(ADCSRA & (1<<ADSC)){} //wait for conversion
  temperature= ADC;
  temperature/= 12;  //scale temp value to degrees C 
  ADMUX |= (1<<ADLAR);  //restore left adjust result 
  ADMUX &= ~(1<<REFS1);  //restore VCC ADC reference

  if(power!=old_power) updateLCD(); //update LCD if values changed
  else if(duration!=old_duration) updateLCD();
  if((!(PINB & (1<<PINB0))) & (duration>0)) //check for footswitch input
  {           
   char j= 0;

      for(j= 0;j< 3;)  //three sample noise filter
   {
    if(!(PINB & (1<<PINB0))) j++;  //increment loop value if PORTC2 (fsw) is low
    else j= 4;  //break out of the loop if high
      }  
                        
      if(j==3)  //should only get here if we got three low samples
   {
    weld_message();
    ADMUX |= (1<<MUX0)|(1<<MUX1)|(1<<MUX2); //sample ADC7 (current sensor)
    ADMUX &= ~(1<<MUX3);
    ADCSRA |= (1<<ADATE); //ADC free runnnng mode
    ADCSRA |= (1<<ADSC); //start conversion
    _delay_us(5); //wait for ADC’s first reading
    max_current= 0×0000;  //reset max current from last cycle
    sei();
    while((!(PINB & (1<<PINB0))) & (duration>0)){}  //wait for zero cross
    cli();
    ADCSRA &= ~(1<<ADATE);  //turn off free running
    switch_up(); //wait for footswitch release
    updateLCD();
   }
  } 
 }
}

 
ISR (ANALOG_COMP_vect)
{ 
 char i= 0;

    for(i= 0;i< 3;)  //three sample noise filter
 {
  if(!(ACSR & (1<<ACO))) i++;  //increment loop value if ACO is low
  else i= 4;  //break out of the loop if high
    }  
                        
    if(i==3)  //should only get here if we got three low samples,  
 {    //which indicates a zero crossing.  
  TCNT1= 0;
  while(TCNT1< power){} //wait for phase rotation
  PORTC |= (1<<PORTC3); //fire SCR
  while(TCNT1< 63333)  //wait for 7.9ms, 95% of one half cycle (60Hz)
  {
   current= ADCH;
   if(current>max_current) max_current= current;  //record the highest value
  } 
  PORTC &= ~(1<<PORTC3);  //turn off SCR gate
  duration–;
 }
}

void initLCD(void)
{
 _delay_ms(250);  // Wait for HD44780
 PORTD &= ~(1<<PORTD4);
 PORTD |= (1<<PORTD1);
 PORTD |= (1<<PORTD0);  
 PORTD |= (1<<PORTD5); // function set
 _delay_ms(2);
 PORTD &= ~(1<<PORTD5);
 _delay_ms(20);  
 PORTD |= (1<<PORTD5); // function set
 _delay_ms(2);
 PORTD &= ~(1<<PORTD5);
 _delay_ms(10);  
 PORTD |= (1<<PORTD5); // function set
 _delay_ms(2);
 PORTD &= ~(1<<PORTD5);
 _delay_ms(10);
 PORTD &= ~(1<<PORTD0);
 PORTD |= (1<<PORTD5); // initialize to 4 bit
 _delay_ms(2);
 PORTD &= ~(1<<PORTD5);
 _delay_ms(10);

 lcd_write_byte(0,0×28);  //set interface width, # of lines, and font size
 lcd_write_byte(0,0×0C);  //display on
 lcd_write_byte(0,0×01);  //clear display
 lcd_write_byte(0,0×06);  //increment address by one, shift cursor at write
}

void lcd_write_byte(unsigned char CONTROL, unsigned char DATA)
{
 if(CONTROL == 1) PORTD |= (1<<PORTD4); else PORTD &= ~(1<<PORTD4);
 if((DATA & 0×80) == 0×80) PORTD |= (1<<PORTD3); else PORTD &= ~(1<<PORTD3);
 if((DATA & 0×40) == 0×40) PORTD |= (1<<PORTD2); else PORTD &= ~(1<<PORTD2);
 if((DATA & 0×20) == 0×20) PORTD |= (1<<PORTD1); else PORTD &= ~(1<<PORTD1);
 if((DATA & 0×10) == 0×10) PORTD |= (1<<PORTD0); else PORTB &= ~(1<<PORTD0);
 PORTD |= (1<<PORTD5);
 _delay_ms(1);
 PORTD &= ~(1<<PORTD5);

 if((DATA & 0×08) == 0×08) PORTD |= (1<<PORTD3); else PORTD &= ~(1<<PORTD3);
 if((DATA & 0×04) == 0×04) PORTD |= (1<<PORTD2); else PORTD &= ~(1<<PORTD2);
 if((DATA & 0×02) == 0×02) PORTD |= (1<<PORTD1); else PORTD &= ~(1<<PORTD1);
 if((DATA & 0×01) == 0×01) PORTD |= (1<<PORTD0); else PORTD &= ~(1<<PORTD0);
 PORTD |= (1<<PORTD5);
 _delay_ms(2);
 PORTD &= ~(1<<PORTD5);
 _delay_ms(10);
}

void updateLCD(void)
{
 unsigned int temp_duration, temp_power, temp_max_current;
 
 temp_duration= (duration*8); //scale duration for BCD conversion to milliseconds          //
 unsigned int duration_BCD= ((((temp_duration/10)+((temp_duration/100)*6))*16)+(temp_duration%10));
 
 unsigned char ONES= 0×00;
 unsigned char TENS= 0×00;
 unsigned char HUND= 0×00;

 if((duration_BCD & 0×0800) == 0×0800) HUND |= 0×08; else HUND &= ~0×08;
 if((duration_BCD & 0×0400) == 0×0400) HUND |= 0×04; else HUND &= ~0×04;
 if((duration_BCD & 0×0200) == 0×0200) HUND |= 0×02; else HUND &= ~0×02;
 if((duration_BCD & 0×0100) == 0×0100) HUND |= 0×01; else HUND &= ~0×01;

 if((duration_BCD & 0×0080) == 0×0080) TENS |= 0×08; else TENS &= ~0×08;
 if((duration_BCD & 0×0040) == 0×0040) TENS |= 0×04; else TENS &= ~0×04;
 if((duration_BCD & 0×0020) == 0×0020) TENS |= 0×02; else TENS &= ~0×02;
 if((duration_BCD & 0×0010) == 0×0010) TENS |= 0×01; else TENS &= ~0×01;

 if((duration_BCD & 0×0008) == 0×0008) ONES |= 0×08; else ONES &= ~0×08;
 if((duration_BCD & 0×0004) == 0×0004) ONES |= 0×04; else ONES &= ~0×04;
 if((duration_BCD & 0×0002) == 0×0002) ONES |= 0×02; else ONES &= ~0×02;
 if((duration_BCD & 0×0001) == 0×0001) ONES |= 0×01; else ONES &= ~0×01;

 ONES |= 0×30;
 TENS |= 0×30;
 HUND |= 0×30;

 lcd_write_byte(0×00, 0×01); //clear screen
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, HUND);
 lcd_write_byte(0×01, TENS);
 lcd_write_byte(0×01, ONES);
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×6D); //’m’
 lcd_write_byte(0×01, 0×69); //’i’
 lcd_write_byte(0×01, 0×6C); //’l’
 lcd_write_byte(0×01, 0×6C); //’l’
 lcd_write_byte(0×01, 0×69); //’i’
 lcd_write_byte(0×01, 0×73); //’s’
 lcd_write_byte(0×01, 0×65); //’e’
 lcd_write_byte(0×01, 0×63); //’c’
 lcd_write_byte(0×01, 0×6F); //’o’
 lcd_write_byte(0×01, 0×6E); //’n’
 lcd_write_byte(0×01, 0×64); //’d’
 lcd_write_byte(0×01, 0×73); //’s’
 temp_power= (power/665);  //scale power for BCD conversion to percent
 temp_power=(95-temp_power);
 unsigned int power_BCD= ((temp_power/10)*16)+(temp_power%10);

 ONES= 0×00;
 TENS= 0×00;

 if((power_BCD & 0×0080) == 0×0080) TENS |= 0×08; else TENS &= ~0×08;
 if((power_BCD & 0×0040) == 0×0040) TENS |= 0×04; else TENS &= ~0×04;
 if((power_BCD & 0×0020) == 0×0020) TENS |= 0×02; else TENS &= ~0×02;
 if((power_BCD & 0×0010) == 0×0010) TENS |= 0×01; else TENS &= ~0×01;

 if((power_BCD & 0×0008) == 0×0008) ONES |= 0×08; else ONES &= ~0×08;
 if((power_BCD & 0×0004) == 0×0004) ONES |= 0×04; else ONES &= ~0×04;
 if((power_BCD & 0×0002) == 0×0002) ONES |= 0×02; else ONES &= ~0×02;
 if((power_BCD & 0×0001) == 0×0001) ONES |= 0×01; else ONES &= ~0×01;

 ONES |= 0×30;
 TENS |= 0×30;

 lcd_write_byte(0×00, 0xC0); //go to second line
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, TENS);
 lcd_write_byte(0×01, ONES);
 lcd_write_byte(0×01, 0×25); //’%’
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×6F); //’o’
 lcd_write_byte(0×01, 0×66); //’f’
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×70); //’p’
 lcd_write_byte(0×01, 0×68); //’h’
 lcd_write_byte(0×01, 0×61); //’a’
 lcd_write_byte(0×01, 0×73); //’s’
 lcd_write_byte(0×01, 0×65); //’e’
 temp_max_current= max_current;
 temp_max_current-= 0×7F;  //remove 2.5V sensor offset
 temp_max_current*= 3; //scaling
 temp_max_current/= 2; //scaling

 unsigned int max_current_BCD= ((((temp_max_current/10)+((temp_max_current/100)*6))*16)+(temp_max_current%10));
 
 ONES= 0×00;
 TENS= 0×00;
 HUND= 0×00;

 if((max_current_BCD & 0×0800) == 0×0800) HUND |= 0×08; else HUND &= ~0×08;
 if((max_current_BCD & 0×0400) == 0×0400) HUND |= 0×04; else HUND &= ~0×04;
 if((max_current_BCD & 0×0200) == 0×0200) HUND |= 0×02; else HUND &= ~0×02;
 if((max_current_BCD & 0×0100) == 0×0100) HUND |= 0×01; else HUND &= ~0×01;

 if((max_current_BCD & 0×0080) == 0×0080) TENS |= 0×08; else TENS &= ~0×08;
 if((max_current_BCD & 0×0040) == 0×0040) TENS |= 0×04; else TENS &= ~0×04;
 if((max_current_BCD & 0×0020) == 0×0020) TENS |= 0×02; else TENS &= ~0×02;
 if((max_current_BCD & 0×0010) == 0×0010) TENS |= 0×01; else TENS &= ~0×01;

 if((max_current_BCD & 0×0008) == 0×0008) ONES |= 0×08; else ONES &= ~0×08;
 if((max_current_BCD & 0×0004) == 0×0004) ONES |= 0×04; else ONES &= ~0×04;
 if((max_current_BCD & 0×0002) == 0×0002) ONES |= 0×02; else ONES &= ~0×02;
 if((max_current_BCD & 0×0001) == 0×0001) ONES |= 0×01; else ONES &= ~0×01;

 ONES |= 0×30;
 TENS |= 0×30;
 HUND |= 0×30;

 lcd_write_byte(0×00, 0×95); //go to third line (DDRAM address 0×15)
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, HUND);
 lcd_write_byte(0×01, TENS);
 lcd_write_byte(0×01, ONES);
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×61); //’a’
 lcd_write_byte(0×01, 0×6D); //’m’
 lcd_write_byte(0×01, 0×70); //’p’
 lcd_write_byte(0×01, 0×73); //’s’
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×28); //’(’
 lcd_write_byte(0×01, 0×6D); //’m’
 lcd_write_byte(0×01, 0×61); //’a’
 lcd_write_byte(0×01, 0×78); //’x’
 lcd_write_byte(0×01, 0×29); //’)’

 unsigned int temperature_BCD= ((temperature/10)*16)+(temperature%10);
 
 ONES= 0×00;
 TENS= 0×00;

 if((temperature_BCD & 0×0080) == 0×0080) TENS |= 0×08; else TENS &= ~0×08;
 if((temperature_BCD & 0×0040) == 0×0040) TENS |= 0×04; else TENS &= ~0×04;
 if((temperature_BCD & 0×0020) == 0×0020) TENS |= 0×02; else TENS &= ~0×02;
 if((temperature_BCD & 0×0010) == 0×0010) TENS |= 0×01; else TENS &= ~0×01;

 if((temperature_BCD & 0×0008) == 0×0008) ONES |= 0×08; else ONES &= ~0×08;
 if((temperature_BCD & 0×0004) == 0×0004) ONES |= 0×04; else ONES &= ~0×04;
 if((temperature_BCD & 0×0002) == 0×0002) ONES |= 0×02; else ONES &= ~0×02;
 if((temperature_BCD & 0×0001) == 0×0001) ONES |= 0×01; else ONES &= ~0×01;

 ONES |= 0×30;
 TENS |= 0×30;

 lcd_write_byte(0×00, 0xD5); //go to fourth line (DDRAM address 0×55)
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, TENS);
 lcd_write_byte(0×01, ONES);
 lcd_write_byte(0×01, 0xDF); //degree symbol
 lcd_write_byte(0×01, 0×43); //’C’
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×63); //’c’
 lcd_write_byte(0×01, 0×61); //’a’
 lcd_write_byte(0×01, 0×73); //’s’
 lcd_write_byte(0×01, 0×65); //’e’
 lcd_write_byte(0×01, 0×20); //space
 lcd_write_byte(0×01, 0×74); //’t’
 lcd_write_byte(0×01, 0×65); //’e’
 lcd_write_byte(0×01, 0×6D); //’m’
 lcd_write_byte(0×01, 0×70); //’p’
}

void switch_up(void)
{
 if(!(PINB & (1<<PINB0)))
 {
  lcd_write_byte(0×00, 0×01); //clear screen
  lcd_write_byte(0×01, 0×20); //space
  lcd_write_byte(0×01, 0×20); //space
  lcd_write_byte(0×01, 0×72); //’r’
  lcd_write_byte(0×01, 0×65); //’e’
  lcd_write_byte(0×01, 0×6C); //’l’
  lcd_write_byte(0×01, 0×65); //’e’
  lcd_write_byte(0×01, 0×61); //’a’
  lcd_write_byte(0×01, 0×73); //’s’
  lcd_write_byte(0×01, 0×65); //’e’
  lcd_write_byte(0×01, 0×20); //space
  lcd_write_byte(0×01, 0×66); //’f’
  lcd_write_byte(0×01, 0×6F); //’o’
  lcd_write_byte(0×01, 0×6F); //’o’
  lcd_write_byte(0×01, 0×74); //’t’
  lcd_write_byte(0×01, 0×73); //’s’
  lcd_write_byte(0×01, 0×77); //’w’
  lcd_write_byte(0×01, 0×69); //’i’
  lcd_write_byte(0×01, 0×74); //’t’
  lcd_write_byte(0×01, 0×63); //’c’
  lcd_write_byte(0×01, 0×68); //’h’
  while(!(PINB & (1<<PINB0))){};
 }
}

void weld_message(void)
{
  lcd_write_byte(0×00, 0×01); //clear screen
  lcd_write_byte(0×01, 0×20); //space
  lcd_write_byte(0×01, 0×20); //space
  lcd_write_byte(0×01, 0×77); //’w’
  lcd_write_byte(0×01, 0×65); //’e’
  lcd_write_byte(0×01, 0×6C); //’l’
  lcd_write_byte(0×01, 0×64); //’d’
  lcd_write_byte(0×01, 0×69); //’i’
  lcd_write_byte(0×01, 0×6E); //’n’
  lcd_write_byte(0×01, 0×67); //’g’
  lcd_write_byte(0×01, 0×2E); //’.’
  lcd_write_byte(0×01, 0×2E); //’.’
  lcd_write_byte(0×01, 0×2E); //’.’
}

The MAX4173 is available in either an SOT23 or SO8 package, and only requires a decoupling capacitor and a sense resistor to operate. There are three different preset gains available so by combining that with the sense resistor value you can achieve a variety of current ranges.
I used the device in a 4-20mA control loop, with a 20X gain and a 10Ω resistor for a 0.8-4V output into an ATtiny 13’s ADC with a 5V reference. The 10Ω sense resistor is small enough that the loop won’t be affected and large enough to provide good signal range and sensitivity.
For future projects I will probably be using the higher gain version with a smaller sense resistor on the input power line and just leave the MAX4173 output on a header for diagnostic measurement if I don’t have a spare ADC pin. This will limit circuit loading but provide an output for measuring actual circuit current draw.
There is another similar version of the MAX4173, the MAX4080. It can handle higher common-mode voltages and bidirectional current. It’s also a bit more accurate than the 4173, but I haven’t tried it out yet.

While I was looking for alternators, I found some high output models. This sounds cool, but do you really need it? I pull a trailer pretty regularly, and I imagined that the trailer lights and brakes would be a pretty good additional load on the electrical system. I had also read that people buying these “high output” alternators had been disappointed with their actual output, so I thought it might be good to find out.

I wasn’t sure how dirty the output of the alternator would be, or how quickly the output might fluctuate which ruled out the use of an inductive current clamp. So I looked around and found a hall-effect current sensor from Allegro Microsystems. The manufacturer’s part number is ACS758KCB-150B-PFF-T. This sensor has a maximum current rating of 150 Amps, and outputs a linear 0-5V signal proportional to the current that passes through the device. It’s fast enough to record transients and will faithfully reproduce both AC and DC currents. The output of the sensor was fed to an Atmel ATMega8, which did ADC duties and sent the data out it’s UART to a MAX232 level converter. I just picked up the data stream with hyperterminal on my laptop. Excel let me manipulate the raw data and make some pretty graphs. I made the circuit with my CNC machine. Here’s what it looks like.

The output of the alternator was alot cleaner than I had expected. I thought there would be more of a rectified three phase look due to the phases generated inside the alternator. This picture of the scope shows the trace of the output of the sensor at idle.

Here is a graph of the data from an engine start up. The Y-axis values are actual current draw in Amps. Time is shown on the X-axis, but the numbers represent the conversion events of the ADC, which happen at approximately 15Hz. This equates to about 40 seconds. The noise is real as far as I can tell. I didn’t use a ground plane, but the trace from the sensor output to the Mega’s ADC input is only about a quarter of an inch. I added a large filter capacitor to the sensor’s output and the waveform didn’t change at all.

Then I took the truck for about a ten minute drive. I had the lights on, but not the radio or anything extra.

It’s interesting to note how much power the transmission consumes when it’s in gear. The first plot is idling in park, the second plot again shows the truck idling in park at the end of the plot. It’s a clear 20 Amp drop from when the truck was in drive.

I hooked up my horse trailer, but even with all the lights on and everything it only shifted the curve up 10 Amps. The trailer brakes (which I thought would be a significant load) didn’t even show up. I’m still curious about this, as the trailer brake control wiring is usually about 10-12 guage, which is almost the same gauge wire the alternator output has to connect it to the battery. Why bother to wire trailer brake wiring with wire that has an ampacity of 100 Amps or so if it only uses a few amps? There must be more to the story.

Here is the schematic. Sorry it’s not all labelled but I didn’t expect to be posting it at the time. Right click and open the image to view full size.

And here’s the layout.

I neglected to add a header for ISP. I was in a hurry to get it done and forgot. The target supply voltage in this application is 11-14V, but supply voltage could be extended to +45V with the appropriate version of the 7805.

Here’s the source code for the Mega8. Compiles with AVR Studio and AVR GCC. It’s a timer-driven interrupt, that starts an ADC conversion of the sensor output and then sends the result to the UART. It uses standard 9600 8N1. The result is left-adjusted so it’s only 8 bit. If you don’t need both positive and negative current measurements, then it would be best to remove the offset of the sensor and use the internal 2.5V ADC reference for better accuracy. The decimal to BCD routine at the end is something I figured out so I can just do a file capture in hyperterminal and import it directly into Excel.   

——————————————————————————————————————————

#include <avr/io.h>
#include <avr/interrupt.h>

#define F_CPU 8000000

#define USART_BAUDRATE 9600
#define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)

void main(void)
{

UCSRB |= (1 << RXEN) | (1 << TXEN);  // Turn on the UART
UCSRC |= (1 << URSEL) | (1 << UCSZ0) | (1 << UCSZ1);  // Use standard 8N1
UBRRL = BAUD_PRESCALE; 	       // Load lower 8-bits of the baud rate value
                               // into the low byte of the UBRR register
UBRRH = (BAUD_PRESCALE >> 8);  // Load upper 8-bits of the baud rate value
                               // into the high byte of the UBRR register

TIMSK |= (1 << TOIE1);	       // Enable Timer1 overflow interrupt
TCCR1B |= (1 << CS11);	       // Turn on Timer1, CLK/8 prescale

ADMUX |= (1 << REFS0);	       // Select VCC reference
ADMUX |= (1 << ADLAR); 	       // Left adjust ADC result
ADCSRA |= (1 << ADEN) | (1 << ADIE);    // Turn on ADC and enable
                                        // conversion complete interrupt
ADCSRA |= (1 << ADPS1) | (1 << ADPS2);	// ADC prescale of CLK/64

sei();

while(1); {}

}

ISR(TIMER1_OVF_vect)
{

ADCSRA |= (1 << ADSC);	       // Start ADC conversion

}

ISR(ADC_vect)
{
unsigned long VOLTAGE = ((((ADCH/10)+((ADCH/100)*6))*16)+(ADCH%10));

unsigned int ONES = 0x00;
unsigned int TENS = 0x00;
unsigned int HUND = 0x00;

if((VOLTAGE & 0x0800) == 0x0800) HUND |= 0x08; else HUND &= ~0x08;
if((VOLTAGE & 0x0400) == 0x0400) HUND |= 0x04; else HUND &= ~0x04;
if((VOLTAGE & 0x0200) == 0x0200) HUND |= 0x02; else HUND &= ~0x02;
if((VOLTAGE & 0x0100) == 0x0100) HUND |= 0x01; else HUND &= ~0x01;

if((VOLTAGE & 0x0080) == 0x0080) TENS |= 0x08; else TENS &= ~0x08;
if((VOLTAGE & 0x0040) == 0x0040) TENS |= 0x04; else TENS &= ~0x04;
if((VOLTAGE & 0x0020) == 0x0020) TENS |= 0x02; else TENS &= ~0x02;
if((VOLTAGE & 0x0010) == 0x0010) TENS |= 0x01; else TENS &= ~0x01;

if((VOLTAGE & 0x0008) == 0x0008) ONES |= 0x08; else ONES &= ~0x08;
if((VOLTAGE & 0x0004) == 0x0004) ONES |= 0x04; else ONES &= ~0x04;
if((VOLTAGE & 0x0002) == 0x0002) ONES |= 0x02; else ONES &= ~0x02;
if((VOLTAGE & 0x0001) == 0x0001) ONES |= 0x01; else ONES &= ~0x01;

ONES |= 0x30;
TENS |= 0x30;
HUND |= 0x30;

UDR = HUND;				// Send the ADC results to the UART
while ((UCSRA & (1 << UDRE)) == 0) {}; 	// Wait for UDR to clear
UDR = TENS;
while ((UCSRA & (1 << UDRE)) == 0) {};
UDR = ONES;
while ((UCSRA & (1 << UDRE)) == 0) {};
UDR = 0x0D;				// Send new line
while ((UCSRA & (1 << UDRE)) == 0) {};
UDR = 0x0A;

}