imsolidstate » Electronics

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<

Flatbed scanner panoramic camera

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

I’ve always loved panoramic pictures, especially when they’re printed up big. I’m not new to panoramics, as I’ve done quite a few stitched sequences, as well as true panoramic film photography. A while back I was wondering if I could repurpose the scanning head part of a scanner into a rotating head panoramic camera. After an initial trial with mediocre results, I did some digging and found out that people have made these before. There’s quite a few issues though: fitting a new lens, an IR filter, the proper speed rotating part, etc. An added difficulty with flatbed scanners is the scanning head scans over a white strip before every scan to calibrate the sensor, so if you don’t have something white for the scan head to look at right at the beginning of the scan, you get some really goofy color stripes. Sheet feed scanners aren’t supposed to do this, so I tried one of those but quickly tired of fooling all of the little switches. It always thinks there’s a paper jam.

The scan head sensor is actually pretty cool, and by definition it’s a line scan camera. It would still be cool to set it up as a line scan camera to play with.

After seeing this rig at HAD, I’m convinced I’m wasting my time. Moving forward I will be designing a stepper-driven tripod mount for my camera and use stitching software instead. If anybody has any suggestions on good software to try let me know. I’ve been using Panorama Maker or whatever the Nikon bundled program was called. It just doesn’t always do a very good job, even with the special mount I made that’s supposed to eliminate parallax. I get a lot of blurring at the upper and lower edge stitches. I would also like to experiment with multi-row so I can use longer lenses.

Build a 9-digit Pulse Counter for under $20

imsolidstate — Thu, 29 Apr 2010 21:30:56 +0000

Recently I was fixing a piece of equipment and wanted a pulse counter to verify a stepper motor system. The existing linear slide was failing, but had a non-standard TPI. The step output was already programmed into a PLC. I had a programmable motor drive, but needed to know how many steps were commanded for a given linear move so I could electronically gear the system to a new linear slide.

That’s when I found the MC14453 3-digit BCD counter from ON semiconductor. ON semi has integrated three decade counters with an oscillator that multiplexes the 3 digits of an LED display. You pair it with an MC14543 7-segment decoder to have a three segment counter. You can cascade as many of these two chips as necessary by using the overflow output to clock the next stage, and feeding the first scan clock to the next multiplexer. I made a 9-digit counter, but you can do any multiple of three.

I used a MAX232 to drive the input of the counter. It’s a bit of a waste of the MAX232’s abilities, but the MAX232 does a great job of handling a wide range of input signals and it’s only about a buck. The chip can handle inputs from +30V to -30V, and still triggers between .5 and 1.5V with a 5V digital output. It also offers +/-15kV ESD protection on the inputs. With this capability you can sample a variety of different signals without any level shifting (even AC). With a few more input components (current limit resistor, zener clamp, series capacitor) you could capacitively couple the signal and measure anything. I wanted good low frequency performance so I skipped that part.

The parts cost about $6 per 3-digit stage. They are all available at Digi-Key. Part numbers:
MC14453: MC14553BCPGOS-ND
MC14543: MC14543BCPGOS-ND
MAX232: 296-6940-5-ND
7-Seg display: 160-1544-5-ND

The only problem with this arrangement is that the MC14543 is driving the LED segments, so it’s limited to less than 10mA drive current. That makes the segments a bit dimmer than I’d like for easy viewing. If I was doing it again I’d get some cheap transistors to run more current. The display is capable of 20mA.

The schematic can be found in the datasheet for the MC14553. Keep reading for the layout and schematic for my build.

Click images for full-size. I mixed up the bias for the hold and reset inputs, if you use momentary off-on switches replace reset with R25 and hold with R26. Otherwise make sure the switches are normally closed.

Trailer turn signal update

imsolidstate — Thu, 29 Apr 2010 21:29:43 +0000

If anyone was interested in my trailer turn signal project, (there was a lot of haters on that one, esp. on Hackaday) Pacman left a comment on that post about an RV turn signal adapter for towing a car at etrailer.com. I bought one of these to try it out. Turns out it does seperate the brake signal from the left and right turn composite signal. So it would work for what I was trying to do. The only thing it doesn’t do that mine did was let the light also act as a clearance light. With my design, the light would be on if the clearance lights were on and flash off to indicate a signal. Not really a big deal though, because you can buy clearance/signal lights to replace the existing clearance lights and use both signals with the same light.

I wasn’t expecting much, but out of curiosity I milled off the top of the plastic box. You can see two relays sticking out of the epoxy potting.

PCB layouts and schematics for my CNC

imsolidstate — Thu, 25 Mar 2010 19:59:57 +0000

I’ve received some email and comment requests for the layouts and schematics of the electronics running my CNC machine. I’ve pulled together what I can find for this article.

Power Filter Boards

I made these power filters for a few reasons. One is to protect the stepper motor drives from the inductive spikes that can come off of the motors. They can be pretty big. Another reason was that I wanted to use a switch-mode power supply to run the drives. There’s a lot of good reasons for this:

1. Switch-mode power supplies are cheaper than linear power supplies.

2. Switch-mode power supplies are smaller than linear supplies for equivalent output power.

3. Switch-mode power supplies come in a wide range of voltages, so you can run the stepper motors at the highest voltage possible. (The highest voltage your controller supports) This allows for more torque from any motor because a higher voltage will push more current through the inductance of the motor than a lower voltage. It will also do it quicker, so you should get a little more speed too.

However, I wasn’t sure that the chopper-style stepper driver would be okay with a switch mode supply, as it pretty much shorts out the supply every time the chopper turns on. So I needed a buffer.

I found this article at EETimesAsia by John Betten from TI. I modified the circuit for the voltage levels I wanted to run, and also found a suitable replacement for the FET since I couldn’t find one at the time. Here is the original schematic:

I’m using an IR IRFP9140N in place of Q1. I also replaced D2 with a 56V TVS from ON semi, 1.5KE56A. I used 56V because the LMD18245 motor driver IC I have has a continuous rating of 55V and an absolute max of 60V. I also oversized the output capacitor just to be on the safe side since I had some big ones laying around anyway. They are 22000uF 100V Panasonics. They are overkill, the voltage is rock-solid even when the motors are running at full clip. I wanted to be able to recycle the boards though if I ever upgrade to a bigger machine and have bigger motors. Here’s the layout for my circuit:

Opto-isolated Parallel Interface Board

I designed this parallel interface board after killing a parallel port with a breakout board that I bought off the internet. I think it just pulled too much current from the port. I designed this board to pull the smallest amount of current from the parallel port as possible, while also providing good drive characteristics for outputs. This board is customized to my application, so the voltages and bias might not be appropriate for all. Check to make sure your inputs will work before using the values here. I couldn’t find the schematic, just the layout but it’s not too complicated to figure out if you have the datasheets for the TLP2631 and the SN74LS244N.

The 74244 is just a buffer; high impedance inputs and good drive characteristics. All inputs and outputs have RC filters. Adjust these values to suit your application. The 2631 is an opto-isolator that keeps the PC’s voltage potentials isolated from the CNC machine’s voltage. That way no voltage spikes hit the PC and there are no ground loops with the power supplies. Complete isolation! You just have to run power over from a spare drive connector on the PC to wherever you put this board.

The astute observer will notice a fried resistor on the board. That’s the board doing just what it was designed to do, protect my computer from dumb screw-ups. I accidentally miswired one of my limit switches during the build and the little resistor took a hike. I could have just replaced the resistor, but I’m not using all of the inputs so I just moved the wire over and remapped the limit input pin. Here’s the layout. Click to view full size.

Stepper Motor Controller

I used the “Microstep” from EAS Electronics. It’s worked well, but the switching frequency is low enough to create an obnoxious whine when the motors aren’t moving. I read in the LMD18245 datasheet that you can adjust the chopping frequency, but I haven’t bothered to try. It’ s loud enough anyway when my router “spindle” is turning that it’s not too important to me.

It’s PIC based and the source is available if you want to modify it to do custom stuff. The microstep ranges are 10,8,4,half, and full step.

My next machine will use Automation Direct’s stepper drivers. They aren’t as cheap as building your own, but they are pretty close. I used two of their STP-DRV-4035 drives in a project at work along with their stepper motors and was pleased with the results. If you need really fine step rate control, they have one that is programmable but it costs more.

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

MAX4173 Current sense amplifier

imsolidstate — Mon, 18 Jan 2010 21:35:48 +0000

I just built a current sensing application based on a MAX4173. I am suitably impressed with this device. It is extremely versatile and cheap. The MAX4173 allows you to measure the current across a sense resistor with a 28V common-mode range and provides a ground-referenced output proportional to the current across the resistor. I will probably be using one on most of my projects from now on since I do a lot of prototype work and having a cheap and easy way to sense current draw is pretty useful.

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.

LED backlit desk sign

imsolidstate — Mon, 18 Jan 2010 18:20:12 +0000

I was messing around a while ago with my CNC and some of the various engraving bits I’ve tried for routing PCB traces. I had a piece of acrylic lying around, so I made myself a sign for my desk at work. I don’t really have that job title, it’s technically “intern” since I’m doing the college thing; but it would be my title if a job title was based on what you did. The description next to my name in the office’s roster is actually “special projects”, but it didn’t sound as interesting.

I used a NUD4001 constant-current LED driver from ON Semiconductor and some OSRAM SideLEDs. The NUD4001 is really quick and easy to implement as it only requires an external resistor to set the current level. The unit is fused, and powered by a 9V AC/DC wall wart. I tried a couple different colors, but this amber looked the best.

As a side note, I really like using ON semiconductor parts. They have excellent datasheets that usually have really good examples.

Turn signals for a trailer

imsolidstate — Tue, 29 Dec 2009 21:22:25 +0000

I’ve been working intermittently on a project to come up with a way to add turn signals to the side of a trailer without needing any extra wiring from the truck. The way people normally do this is by tapping the side markers into the turn signal wires. However, that makes the side markers turn on and off with the brakes which makes for a confusing signal. There is no shortage of patents for adding this type of capability, but they usually require a unique transmitter aboard the truck that communicates with another unique receiver on the trailer. Since the 6 pin standard is ubiquitous, that type of system will likely not be available or popular for some time. I didn’t want to add any special hardware to the truck either. So I’ve been working on a solution that taps into the trailer’s main electrical harness and creates an extra side turn signal for each side of the trailer and also functions as a clearance light.

You can use any standard clearance light and it will function as a clearance light when the lights are on, and also flash that light when the appropriate turn signal is on. The brakes will not cause the side markers to flash. You can add new lights, or simply intercept the wiring to existing clearance lights. The only modification is to the trailer, and it will work the same for any truck. The only requirement is that the trailer has electric brakes and the truck has a brake controller.

My code is running on an ATtiny24, on a board I prototyped just for this. I built an in-line harness for testing that passes the signals from the 6 pin connector to the trailer, but taps into those signals for the logic. My device has two standard LED clearance lamps attached as left and right turn signals for testing. This system is an add-on to the existing trailer wiring, so in the event of a failure nothing is compromised.

It has been tough getting this working, as there’s not exactly a manual for how the truck and the brake controller handle the signals. It’s taken a few months, as evidenced by the tarnished PCB. If I remember right I made it this summer.