imsolidstate » PCB

CNC version 2.0

imsolidstate — Fri, 01 Jul 2011 17:32:30 +0000

I finally finished putting together my second CNC machine. Again this one is put together with surplus parts, but they are much better surplus parts. I have the luxury of three linear slides from Newmark Systems, that have dual profile rails and recirculating ball slides, along with 16TPI precision screws and recirculating ball guides. In short, the new machine is solid as a rock, and has more torque.

I used a dremel this time instead of a router, since the router was pretty much overkill for engraving anything. I made a mount for the dremel by cutting up the little plastic guide that comes with it. It has an approximate O.D. of 1″ and acts as a nut that you can clamp with a shaft collar, and still unscrew the dremel from the mount if you need to get it out. I welded the shaft collar to a stainless steel bracket.

I haven’t made any boards yet to see if the dremel has much z-axis play.

There’s nothing special about this machine electronics-wise. Since I have NEMA23 steppers and 16TPI lead screws I don’t need a really high voltage drive or anything special. I’m using a 24VDC linear power supply with two automation direct stepper drives and one from Schneider. I didn’t connect the home and limit switches as I don’t think they have much value on machines this small. It’s a lot of work to do proper limit switches that disable the drive and signal the controller that a limit has been reached. Also to have home and limit switches on each axis you need two parallel ports. TurboCNC, being run in DOS, can only use the onboard parallel port so you can’t use PCI parallel port cards with TurboCNC. Only Mach3 can recognize inputs on the extra card since it’s address will map outside of the legacy range.

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<

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

0.008″ PCB trace isolation on my CNC

imsolidstate — Sun, 20 Sep 2009 21:32:13 +0000

Due to a new design that I am working on, I needed to use a component from TI that only came in a 6SC70 package. It’s a boost converter (TPS61221) that operates from an input voltage as low as 0.7V and has 80% or better efficiency in the 1-10mA range. It’s trimmed at 3.3V, which I’m using to run an ATtiny45V. The ATtiny45 comes in a fine-pitch package as well, an 8TSSOP that requires 0.009″ isolation between pads. I haven’t been able to get much better than 0.020″ with the tooling I have, so I have been looking for alternatives.

I found some mechanical engraving bits at Think & Tinker which is actually here in Colorado at Palmer Lake. Their URL descriptor says they offer “Instrument and PCB prototyping equipment”. They also sell carbide engraving bits, and the particular one I selected was the 60° cutter, part number #EM2E8-0625-60V. The bits came in a nice container and are labelled as having a 0.005″ tip. The shipping was also wicked fast. Granted, it’s only a few hours away from my location but I ordered them and got them in the next day.

I’ve only cut one board, but I’m really happy with the results. I successfully achieved 0.008″ isolation between the pads of the devices, and now I can finally route traces inbetween the pads of 0.1″ headers. I couldn’t do that before.

My homebuilt CNC machine

imsolidstate — Tue, 25 Aug 2009 23:02:10 +0000

I finally assembled enough surplus parts and scrap material to build a halfway decent CNC machine. I have been looking forward to actually completing this task for some time, but the appropriate parts and materials are prohibitively expensive for the individual on a budget. This spring I managed to complete the project.

Most of the machine is made out of either aluminum or acrylic. These materials are both easy to work with when all you have available is various hand tools and a drill press with a cross slide vise. The motors are NEMA 23 high torque, the threaded rods are 1/2-10 precision ACME and the nuts are anti-backlash. This results in pretty decent X-Y movement. I made the slides from extruded aluminum profiles available at the hardware store and some strips of Teflon.

I made all of the electronics that support the machine. I made the optical home and limit switches, as well as both parallel port interface boards. I also assembled the stepper motor drivers and built power filters/regulators for the input to the stepper motor drives on all three axes. This prevents inductive feedback spikes from the motors ruining the stepper motor control ICs. I need this because I’m running the motors at 48VDC and the controller IC has an absolute maximum voltage rating of 60VDC. I also wanted to keep any switching noise and voltage dips from the switch-mode power supply out of the stepper drives. Each filter has a FET-regulated output that clamps the voltage and then sends it out to some big capacitors to prevent the voltage from dropping.

The parallel interface boards completely isolate the controlling PC from the drives and other electronics. Buffers handle all the appropriate levels and opto-isolators keep the ports safe.

I’ve run it extensively with TurboCNC, but I don’t get any of the limit and home functionality because TurboCNC only supports legacy port addresses, and most parallel port PCI cards can’t map to legacy addresses. This leaves me with only the one on-board parallel port, which is mostly used up by the 3 axis step and direction signals. It works in Mach3 CNC, but I can’t afford to buy that program right now. So I’ve used it in evaluation mode for doing simple text engraving on plastics and acrylic. Oddly enough I couldn’t get it to work at all in Mach2. The pulse train output to the stepper drives was inconsistent enough that the motors would stall. I even tried it on a few different computers, one of which was a brand new XP install.

The machine mostly cranks out PC boards thanks to Eagle CAD and PCB2GCode. I’ve made quite a few since the machine was finished. It does a pretty good job, and holds flatness to a couple thousandths. It’s enough to get routine 0.020″ isolation on traces and pads, and clean 0.012″ trace widths. It’s a bit slow because of the low-buck slides, the motors stall if I speed it up much. It’s not exactly a high precision machine, so I can live with slow.

I’ve got some better parts since I built this one, and I’m planning on building another one with much better accuracy in the near future. This machine won’t handle the fine traces necessary to make boards with the newer components.

Here’s a video of the machine in action:

You can see more videos at youtube: imsolidstate’s CNC machine