Tachometer Project is Complete! (kinda)

Since my last posting, a lot has happened.  I received the new tachometer board, populated it, programmed it, and then tested it.  Below is an image of the testing set-up.

Prototyped Tach Board in Test

In the image above, you can see the oscilloscope to the left which is hooked up to the photogate signal.  I have a motor spinning an incremental encoder wheel (a disk with slots on it) from an old ball mouse.  You can also see the RPM is being displayed on the serial display.

The current code works by counting the number of 'highs' within 250 ms (1/4 sec) and doing some simple math to compute the RPM.  Although the code is working and I can call this one 'completed', I'm not too happy with the accuracy.  It is slightly inaccurate because of the method I used (as described above).  The more accurate method involves measuring the time between 'highs' (or teeth in my case).  That way there are no rounding errors.

The current method rounds down, so if the chip has counted 55 highs and is 95% to the next high, just as the time ticks to 250ms, it only sees 55.  So the extra 0.95 high is not counted.  If your gear has very few teeth, the time between teeth increases and your error becomes bigger.  The high to high counting does not have this issue.

This whole project started off by wanted to provide an RPM measurement for my dad's Mini-Mill from Grizzly.com (the G0463).  Finally, the project is at a phase where we can integrate it to the machine and I can update the program later (if I get the energy).

The images below show the mini-mill's gears which I plan on hooking my magnetic tooth sensor too.

G0463 Mini-Mill with gear cover removed

Below are the spindle and drive gears with the number of teeth marked on each.  I will obviously need the number of teeth per revolution to program into the chip.  It was not obvious to me, at lease not right away, that after you know the number of teeth per revolution, it does not matter which gear, big or small, you place the sensor next too.  Ponder it... you'll figure it out. (it's not like belts and pulleys). 

G0463 Mini-Mill Spindle and drive gears

And next I had planned to include an image of the populated board and all of the external parts (display, tooth sensor, and battery clip), but apparently I forgot to take a picture before handing the assembly over to my dad.... well, you'll have to wait.

Tachometer Board and Programming

Since the last post, I have been working on getting version 1.0 tachometer board up and running.  It turns out that creating the schematic and laying out the board in one night is too fast for a novice like me.  I made a number of simple mistakes that doomed the board from the schematic level.

Bad Schematic (REV -)

The two areas boxed in red were incorrect. VDD is positive 5V and VSS is ground. Apparently the PIC16F688 does not work well when it is not grounded properly. However, it does show some life.  For whatever reason, I was still able to blink an led. The delay between blinks was 5X slower than it should have been, but it did work.  This played havoc with my programming because I was convinced the board was working properly.  Finally, after a bit of programming help from the Sourceboost C forum (my thread), I managed to get Timer 1 working properly. I also have fixed my current board, shown below.

Fixed Board

The schematic has been updated to fix the errors, as well as add holes to connect to the unused pins.  I wanted this in order to use the board for prototyping in the future.

Updated Schematic (Rev A)

Updated Layout

Tachometer board has arrived

I ordered three boards on March 25th and six show up on April 14th... Thank You BatchPCB!  After about 30 minutes of soldering, the board was fully populated.

Populated Tack Board

My desk after soldering

Best of all, I plugged my PicKit2 into the board and it was recognized!  All I need to do now is fix the code so that it works on this PIC16F688.  I developed working code on the PIC16F877, which I do most of my programming on.  Unfortunately, I did not realize the vast differences between the two... not quite plug-n-play.

Tachometer board has been ordered

Last night, I managed to get the tachometer programming and circuit all figured out.  Before I knew it, I had the schematic and then the board laid-out.

Tachometer Schematic

Tachometer Board Lay-Out

After about two hours of playing around with the schematic and moving the components around on the board, I decided I was done.  I then placed an order with BatchPCB.  This board is 1.17x1.54 inches, and cost $4.51 each with a $10 handling fee.

I also placed an order with Digi-Key which contained the gear tooth sensor which will be mounted within the gear box of the mini mill.  That order is below.

Digi-Key Order

PIC16F877A Interrupt Code

During my attempt to program my tachometer, I decided to make things simpler by creating code for an external interrupt, timer 0 interrupt (TMR0), and timer 1 (TMR1) interrupt.  I figured this might be useful to someone in the future, so here it is!

NOTE: I program my code using Sourceboost C complier.

External Interrupt Code on the PIC16F877A

//External Interrupt Test,  

//RoboSlave.Blogspot.com, 1/2011

//Includes

#include <system.h>

//PIC16F877A

#pragma DATA _CONFIG, _PWRTE_OFF & _BODEN_OFF & _WDT_OFF & _LVP_ON & _CPD_OFF & _DEBUG_OFF & _XT_OSC & _CP_OFF

#pragma CLOCK_FREQ 4000000 //Set clock frequency

//Define

#define button1 portb.0

#define led1 portd.0

//Interrupts

void interrupt( void )

{

if( intcon & (1<<INTF) ) //Handle external interrupt

{

clear_bit( intcon, INTF );

led1 = !led1;

}

}

//Main Code

void main( void )

{

trisb = 0x00; //Configure port B

trisd = 0x00; //Configure port D

portb = 0x00; //Initialize port B

portd = 0x00; //Initialize port D

intcon = 0xB0; //Enable interrupts (External, Timer0)

while( 1 ) //Endless loop

{}

}

 Timer0 Interrupt Code on the PIC16F877A

//Timer0 Interrupt Test 

//RoboSlave.Blogspot.com, 1/2011

//Includes

#include <system.h>

//PIC16F877A

#pragma DATA _CONFIG, _PWRTE_OFF & _BODEN_OFF & _WDT_OFF & _LVP_ON & _CPD_OFF & _DEBUG_OFF & _XT_OSC & _CP_OFF

#pragma CLOCK_FREQ 4000000 //Set clock frequency

//Define

#define led1 portd.0

//Interrupts

void interrupt( void )

{

if( intcon & (1<<T0IF) ) //Handle timer0 interrupt

{

clear_bit( intcon, T0IF ); //clear timer 0 interrupt bit

led1 = !led1;

}

}

//Main Code

void main( void )

{

trisd = 0x00; //Configure port D

portd = 0x00; //Initialize port D

intcon = 0xB0; //Enable interrupts (External, Timer0)

//Set Timer0 mode

clear_bit( option_reg, T0CS ); //configure timer0 as a timer

//Set prescaler assignment

clear_bit( option_reg, PSA ); //prescaler is assigned to timer0

//Set prescaler rate

set_bit( option_reg, PS2 ); //prescaler rate 1:128

set_bit( option_reg, PS1 );

set_bit( option_reg, PS0 );

//Set timer0 source edge selection

set_bit( option_reg, T0SE ); //increment on high-to-low transition on RA4/T0CKI pin

while( 1 ) //Endless loop

{}

}

  Timer1 Interrupt Code on the PIC16F877A

//Timer1 Interrupt Test, 

//RoboSlave.Blogspot.com, 1/20111

//Includes

#include <system.h>

//PIC16F877A

#pragma DATA _CONFIG, _PWRTE_OFF & _BODEN_OFF & _WDT_OFF & _LVP_ON & _CPD_OFF & _DEBUG_OFF & _XT_OSC & _CP_OFF

#pragma CLOCK_FREQ 4000000 //Set clock frequency

//Define

#define led1 portd.0

//Interrupts

void interrupt( void )

{

//if( pir1 & (1<<TMR1IF) ) //Handle timer1 interrupt

if (pir1.TMR1IF == 1)

{

clear_bit( pir1, TMR1IF ); //clear timer 1 interrupt bit

led1 = !led1;

}

}

//Main Code

void main( void )

{

trisd = 0x00; //Configure port D

portd = 0x00; //Initialize port D

intcon.GIE = 1;

intcon.PEIE = 1;

pie1.TMR1IE = 1;

t1con= 0b00000001; //set timer1 configs and start

while( 1 ) //Endless loop

{}

}

Project 4 - Tachometer

Its been over a month since my last post... I did not work much on the others, but I did manage to add another project to my list.

Enter Project 4, the tachometer.  This project was spawned from my father buying a mini milling machine from Grizzly Industrial Inc.  The machine is model G0463 which is a variation of other mini mills on the market.

Grizzly Mini Mill Model G0463

The more expensive mini mill model comes with a number of bells and whistles which may or may not pay for themselves, one of them being an RPM gauge.  After a bit of discussion, I decided to take on the task of making a tachometer to determine the RPM of the spindle.  The range is from 0 to 2000 RPM.  I will probably use a sensor to measure the passing teeth on the drive gear beneath the upper cover... but we'll see how that goes.

Below you can see the current breadboard assembly.  I am using a PIC16F877A for now and will switch to something with less pins when I get the time.  I am also using an old mouse encoder wheel mounted to a motor which I can use to simulate the spindle (bottom right).  The sensor is a simple photogate, which has one LED pointing at a light sensor (all in infrared).

Tachometer Breadboard Set-Up

I bought the following from Sparkfun to display the four digit RPM.

Sparkfun Display Order

I managed to send the numbers via serial communication but was not getting the correct range of RPM... I need to play with the code, the delay_ms(time) function in Sourceboost C may be inaccurate.  I don't have any pictures of that quite yet.

The plan, for now, is to use 1 pin to send the RPM to the display instead of 28 pins.  I did not want the hassle of connecting up each led in each segment and then having to control the mess in the code.  That may happen in a later addition and maybe even if I layout a board for this project.