imsolidstate » ATMega

Pressure mapping with DIY foam load cells

imsolidstate — Mon, 30 Aug 2010 17:54:03 +0000

I had an idea a while back to make a pressure sensing pad for testing saddle fit on horses. The intent was to create an array of pressure sensing cells, which could then be used to produce a pressure map that would represent any pinch points on a horse’s back. I found that you can buy this sort of thing, but it’s way too expensive for the average guy. I decided to try and make my own for cheap. I ended up making one from a handful of copper-clad PCBs and 1/4″ shipping foam.

The active area of the pad is approximately 2′ x 2′. I think the foam is polyurethane open-cell foam but I’m not sure. It’s the stuff you use to pack shipping crates. The load cells are made by sandwiching the foam in between 1″ circle cutouts of copper-clad FR4 PC board. I used single sided board and a hole saw with the pilot bit removed (use a drill press and a clamp). The capacitance varies as the foam compresses, and the amount of capacitance is directly related to the thickness and density of the foam, as well as the area of the copper conductors (plates). So you can create any size or thickness load cell you want really. A bigger plate results in more capacitance, as does placing the plates closer together. I estimated the capacitance I would have in my application with this calculator I found at Daycounter engineering services.

I created an array of 64 cells by making 8 rows and 8 columns, each with 8 copper-clad discs. Wherever the row/column discs align a load cell is created. An AVR typically has eight available ADC inputs along with another eight control outputs, so this way you can scan down through the rows and columns to measure each cell. A square wave is sequentially output on the columns, and after some analog proccessing the AVR’s ADC scans each row. The analog voltage present represents the amount of pressure (capacitance) at each site.

The square wave generator is the old two op-amp ramp generator/comparator circuit. This is fed to one side of the cell. The output from the other side is coupled through whatever capacitance is available at the cell, and results in a triangle wave with amplitude proportional to the capacitance thanks to a transimpedance amplifier. Then it is fed to a peak detector and amplified. The signal is then sent to the ADC. There are more than a few examples out on the web for capacitance sensing, here is a good one.

The AVR outputs the 64 values on a serial port. I used excel’s surface chart to represent the data. The chart posted here is a map of an english saddle.

It works fairly well, but my analog section needs some improvement. Sensitivity is sufficient for this test, but it’s relatively poor. Response time also suffers because of noise; my prototype could definitely use improvement in that area and I had to decrease the response time of the amplifier to get consistent output. This is unfortunate because I had planned on trying to make a movie by recording real-time data while riding a horse. I even designed it to run on a 9V battery for this purpose. Maybe if I have enough free time next summer (unlikely) I’ll try and tune it up a bit.

SMS remote control

imsolidstate — Sat, 17 Jul 2010 02:42:23 +0000

I’ve been expirimenting with cheap GSM cell phones as remote control devices. I wanted to be able to control stuff at my house just by sending a text from my phone. I also wanted to use an AVR since the options are pretty limitless as to what you can control. I started off simple with relay outputs for stuff like the garage door, outside lights, etc. It could also be useful for the AVR to send texts based on events, but I haven’t messed with this yet.

I planned on just having the AVR recognize a particular text string, like “open garage” if I wanted to let someone in my house when I’m not there without giving them a key for example. It’s not overly secure, but you could add a number sequence as a prefix to the command that would be like a password. Then you could periodically change your password if you wanted.

I’m using cell phones from Siemens. They are older phones with true serial comms. You can score one for $20 or so from ebay. The only thing that sucks about these phones is they use PDU mode for text messages. It’s a really inconvenient way to send text strings. There’s a ton of setup to each packet and each character is encoded in seven bits. I haven’t been able to get my code working with the PDU method yet. It gets stuck trying to decode the received message. I’m going to post it here to see if anyone has any suggestions. I’m all self-taught in C. I’ve never tried comparing strings before, so that bit is a little cumbersome. I don’t like using the built-in libraries to do that kind of stuff until I figure out how it works. The only thing I think turned out nice in the code is the unpacking function.

Obviously, you’d be ahead of the game if you found a serial-interface phone that used the regular text mode instead of PDU. I couldn’t find any phones that did text mode and didn’t have a USB interface. (at least not for cheap) Programming a USB host interface is beyond my capabilities on the AVR.

References: Developer’s Home SMS Tutorial

#include 
#include 

#define unpack_state1 0
#define unpack_state2 1
#define unpack_state3 2
#define unpack_state4 3
#define unpack_state5 4
#define unpack_state6 5
#define unpack_state7 6
#define unpack_state8 7
#define F_CPU       8000000
#define BAUD   9600
#define MYUBRR  (F_CPU/(BAUD*(unsigned long)16))-1

void init_USART(void);
void init_timer0(void);
void turnoff_timer0(void);
void init_timer1(void);
void check_sms(void);
void decode_sms(void);
char unpack(unsigned char octet);
void USART_write(unsigned char *buf);

volatile unsigned char rcv_buf[128];
volatile unsigned char rcv_buf_idx;
volatile unsigned char check_message, check_online;

void main(void)
{
 DDRD |= 0x03;
 PORTD &= ~0x03;
 DDRC |= 0x3F;
 PORTC &= ~0x3F;
 DDRB |= 0x3F;
 PORTB &= ~0x3F;
 init_USART();
 init_timer0();
 sei();

 while(check_online<0xF7)
 {
  rcv_buf_idx= 0x00;
  USART_write("at");
  while((rcv_buf_idx<0x08)&(check_online<0x30)) {}
  if( rcv_buf[0x05]==0x4F &
   rcv_buf[0x06]==0x4B)
  {
   PORTB &= ~(1<> 8);
}

void init_timer0(void)
{
 TCCR0B |= (1<0x2F) & (rcv_buf[offset+lenSMSC]<0x3A))
  len_sender_number+= (rcv_buf[offset+lenSMSC] &= ~0x30);
 else if(rcv_buf[offset+lenSMSC]=='A') len_sender_number+= 10;
 else if(rcv_buf[offset+lenSMSC]=='B') len_sender_number+= 11;
 else if(rcv_buf[offset+lenSMSC]=='C') len_sender_number+= 12;
 else if(rcv_buf[offset+lenSMSC]=='D') len_sender_number+= 13;
 else if(rcv_buf[offset+lenSMSC]=='E') len_sender_number+= 14;
 else if(rcv_buf[offset+lenSMSC]=='F') len_sender_number+= 15;
 if(len_sender_number%2) len_sender_number++;
 rcv_buf_idx= (0x1B+lenSMSC);
 unsigned char i= len_sender_number;
 while(i)
 {
  unsigned char *sender_number= rcv_buf[++rcv_buf_idx];
  sender_number++;
  *sender_number= rcv_buf[--rcv_buf_idx];
  sender_number++;
  rcv_buf_idx += 0x02;
  i-= 0x02;
 }
 offset= 0x35;
 unsigned char num_septets= ((rcv_buf[offset+lenSMSC+len_sender_number] &= ~0x30)*10);
 offset= 0x36;
 if((rcv_buf[offset+lenSMSC+len_sender_number]>0x2F) & (rcv_buf[offset+lenSMSC+len_sender_number]<0x3A))
  num_septets+= (rcv_buf[offset+lenSMSC+len_sender_number] &= ~0x30);
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='A') num_septets+= 10;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='B') num_septets+= 11;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='C') num_septets+= 12;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='D') num_septets+= 13;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='E') num_septets+= 14;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='F') num_septets+= 15;
 offset= 0x37;
 rcv_buf_idx= (offset+lenSMSC+len_sender_number);
 unsigned char loop= 0;
 unsigned char message[16];
 unsigned char message_idx= 0x00;
 offset= 0x1C;
 while(rcv_buf_idx<=(offset+lenTPDU+lenSMSC))
 {
  unsigned char octet= 0;
  if(rcv_buf[rcv_buf_idx]=='A') octet |= 0xA0;
  else if(rcv_buf[rcv_buf_idx]=='B') octet |= 0xB0;
  else if(rcv_buf[rcv_buf_idx]=='C') octet |= 0xC0;
  else if(rcv_buf[rcv_buf_idx]=='D') octet |= 0xD0;
  else if(rcv_buf[rcv_buf_idx]=='E') octet |= 0xE0;
  else if(rcv_buf[rcv_buf_idx]=='F') octet |= 0xF0;
  else octet= ((rcv_buf[rcv_buf_idx] &= ~0x30)*10);
  rcv_buf_idx++;
  if(rcv_buf[rcv_buf_idx]=='A') octet |= 0x0A;
  else if(rcv_buf[rcv_buf_idx]=='B') octet |= 0x0B;
  else if(rcv_buf[rcv_buf_idx]=='C') octet |= 0x0C;
  else if(rcv_buf[rcv_buf_idx]=='D') octet |= 0x0D;
  else if(rcv_buf[rcv_buf_idx]=='E') octet |= 0x0E;
  else if(rcv_buf[rcv_buf_idx]=='F') octet |= 0x0F;
  else octet+= (rcv_buf[rcv_buf_idx] &= ~0x30);
  rcv_buf_idx++;
  message[message_idx]= unpack(octet);
  message_idx++;
  if(++loop==7)
  {
   message[message_idx]= unpack(0x00);
   message_idx++;
   loop=0;
  }
 }
 if( message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='1' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='n') {PORTB &= ~(1<>7);
   remain_val= (octet & 0xC0);
   unpack_state= unpack_state3;
   break;
  case unpack_state3:
   masked_val= (octet & 0x1F);
   septet= (masked_val<<2) | (remain_val>>6);
   remain_val= (octet & 0xE0);
   unpack_state= unpack_state4;
   break;
  case unpack_state4:
   masked_val= (octet & 0x0F);
   septet= (masked_val<<3) | (remain_val>>5);
   remain_val= (octet & 0xF0);
   unpack_state= unpack_state5;
   break;
  case unpack_state5:
   masked_val= (octet & 0x07);
   septet= (masked_val<<4) | (remain_val>>4);
   remain_val= (octet & 0xF8);
   unpack_state= unpack_state6;
   break;
  case unpack_state6:
   masked_val= (octet & 0x03);
   septet= (masked_val<<5) | (remain_val>>3);
   remain_val= (octet & 0xFC);
   unpack_state= unpack_state7;
   break;
  case unpack_state7:
   masked_val= (octet & 0x01);
   septet= (masked_val<<6) | (remain_val>>2);
   remain_val= (octet & 0xFE);
   unpack_state= unpack_state8;
   break;
  case unpack_state8:
   septet= (remain_val>>1);
   unpack_state= unpack_state1;
   break;
 }
 return septet;
}

void USART_write(unsigned char *buf)
{
 while(*buf)
    {
       while ( !( UCSR0A & (1<

Build a spot welder from a battery charger

imsolidstate — Thu, 11 Mar 2010 04:53:39 +0000

I ran across a battery charger a while ago that was collecting dust. I looked inside and saw the transformer, heatsinks, high current bridge rectifier and SCR and knew I could do something with it. So I turned it into a spot welder.

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
#include
#include
//#include // 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< ADMUX |= (1< ADMUX |= (1< ADCSRA |= (1< ADCSRA |= (1<

TCCR1B |= (1<

ACSR |= (1< ACSR |= (1<

DDRC |= (1< DDRC &= ~((1< PORTC &= ~((1<

DDRD |= (1< DDRD &= ~((1< PORTD &= ~((1<

DDRB &= ~(1< PORTB &= ~(1<

initLCD(); //set up LCD

switch_up(); //check footswitch

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

// wdt_reset(); //reset the watchdog timer
// WDTCSR |= (1< // WDTCSR |= (1<

while(1)
{
  old_power= power; //set up the comparsison value before getting new value
  ADMUX &= ~((1<   ADCSRA |= (1<   while(ADCSRA & (1<   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<   ADCSRA |= (1<   while(ADCSRA & (1<   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<   ADMUX |= (1<   ADMUX |= (1<   ADMUX &= ~(1<   ADCSRA |= (1<   while(ADCSRA & (1<   temperature= ADC;
  temperature/= 12; //scale temp value to degrees C
  ADMUX |= (1<   ADMUX &= ~(1<

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

      for(j= 0;j< 3;)  //three sample noise filter
   {
    if(!(PINB & (1<     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<     ADMUX &= ~(1<     ADCSRA |= (1<     ADCSRA |= (1<     _delay_us(5); //wait for ADC’s first reading
    max_current= 0×0000; //reset max current from last cycle
    sei();
    while((!(PINB & (1<0)){}  //wait for zero cross
    cli();
    ADCSRA &= ~(1<     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<   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<   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<   duration–;
}
}

void initLCD(void)
{
_delay_ms(250);  // Wait for HD44780
PORTD &= ~(1< PORTD |= (1< PORTD |= (1< PORTD |= (1< _delay_ms(2);
PORTD &= ~(1< _delay_ms(20);
PORTD |= (1< _delay_ms(2);
PORTD &= ~(1< _delay_ms(10);
PORTD |= (1< _delay_ms(2);
PORTD &= ~(1< _delay_ms(10);
PORTD &= ~(1< PORTD |= (1< _delay_ms(2);
PORTD &= ~(1< _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< if((DATA & 0×80) == 0×80) PORTD |= (1< if((DATA & 0×40) == 0×40) PORTD |= (1< if((DATA & 0×20) == 0×20) PORTD |= (1< if((DATA & 0×10) == 0×10) PORTD |= (1< PORTD |= (1< _delay_ms(1);
PORTD &= ~(1<

if((DATA & 0×08) == 0×08) PORTD |= (1< if((DATA & 0×04) == 0×04) PORTD |= (1< if((DATA & 0×02) == 0×02) PORTD |= (1< if((DATA & 0×01) == 0×01) PORTD |= (1< PORTD |= (1< _delay_ms(2);
PORTD &= ~(1< _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< {
  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< }
}

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); //’.’
}

How much electric current does a truck really use?

imsolidstate — Tue, 25 Aug 2009 03:08:41 +0000

So, a while back my truck was getting slow to start. I checked the battery voltage with the truck running, and it was only 11 volts or something. I started the troubleshooting process by replacing the alternator with one from the local parts store, but it didn’t fix the problem. I changed both batteries. Still didn’t fix the problem. So I did some diagnostics with an ammeter and a voltmeter and figured out that my brand-new alternator was bad. I took it back to the parts store, where they gave me another one. I had them test it, and it failed on their bench tester. So did the next one. They finally gave me my money back and I bought one from Ford. It worked just fine.

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 
#include 

#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;

}