I know I am asking a lot, I understand some C but this is pushing my limits. Is there anyone out there that can help me understand this a little more. I have done my homework, for micro-stepping you need to control the current in the motor windings in a certain order. The LMD18245 is a chopper driver chip with a built in DAC to process the binary data it gets from a micro-controller. The code below is code I found on a site that uses the LMD18245 to control a stepper. I would like to be able to understand this a little more in-depth. Is there anyone out there that I can pick their brain that understands this stuff, especially the C code itself.
http://www.ti.com/lit/ds/snvs110d/snvs110d.pdf
http://www.embeddedtronics.com/public/Electronics/microstep/schematics/microstep_schematic.pdf
edit: I posted the code here because it is only available in a zip file that must be downloaded. Can be found here: http://www.embeddedtronics.com/public/Electronics/microstep/microstep_source.zip
http://www.ti.com/lit/ds/snvs110d/snvs110d.pdf
http://www.embeddedtronics.com/public/Electronics/microstep/schematics/microstep_schematic.pdf
Code:
/* C program for National Semi LMD18245/PIC microstepping driver board.
IRQ version for Step input.
****16F627 version*****
Embedded Acquisition Systems
www.embeddedtronics.com
copyright 2004-2006
Compiled with PCW PIC Compiler Version 3.242
July 27, 2006
Note:
If you see any errors, please contact me. jimf at embeddedtronics dot com
Use this code at your own risk, no guarantee that it will work for you.
This source code is for Non-commercial personal use only.
If you want to use this code for any other purpose,
please contact [email protected] for a commercial license.
If you modify/enhance this program, please send me a copy. Thanks.
Approximate motor performance speeds:
Microstep10 routine runs about 25% slower due to the longer step calculation routine.
Microstep10 about 1400RPM.
Microstep8 about 2000rpm (53Khz step input rate).
Microstep4 about 3500rpm (46Khz step input rate).
Halfstep about 3000rpm (20Khz step input rate).
Tested results with a Superior Electric M091-FD09 at 44volts motor supply. TurboCNC on P2-500 PC.
Maximum rpm speeds will vary depending on motor type and computer speed.
Changlog
April 7, 2005 Added current reduction code, driver output current reduced after 3 minutes.
Changed microstep10 pulse routine for faster step rate.
Added new sine wave lookup tables, microstep8new and microstep10new.
The lookup table is offset by a few degrees. These need to be tested to see if they work better.
July 27, 2006 Version 2.0
There is a internal hardware bug in the LMD18245 chip causing it to switch incorrectly. This makes
the motor have less torque in one direction at higher speeds, however the motor does not loose step position.
You can only switch the LMD chip direction lines (DIR A and DIR B) when the DAC value is zero. This bug was found by
RadekCX, a CNCZONE member and verified by [email protected] (PICSTEP)
My quick fix is to make a new updated sine table that is sent to the stepper motor when the Direction
input line is high.
Bug fix only for halfstep_torque, microstep4, microstep8 and microstep10 lookup tables.
Removed microstep8new and microstep10new lookup tables since they don't work any better.
PIC F627 Pin definition.
pin17 RA0 Motor Driver A, DAC M1 Output
pin18 RA1 Motor Driver A, DAC M2 Output
pin1 RA2 Motor Driver A, DAC M3 Output
pin2 RA3 Motor Driver A, DAC M4 Output
pin3 RA4 unused
pin6 RB0 STEP Input
pin7 RB1 DIR Input
pin8 RB2 Motor Driver A Direction Output
pin9 RB3 Motor Driver B Direction Output
pin10 RB4 Motor Driver B, DAC M1 Output
pin11 RB5 Motor Driver B, DAC M2 Output
pin12 RB6 Motor Driver B, DAC M3 Output
pin13 RB7 Motor Driver B, DAC M4 Output
CS OUT current sense resister
(Vref x D/16) / (250e-6 x R) = A
R=18.75K 1amp
R=9.38K 2amp
R=7.5K 2.5amp
R=6.25K 3amp
1/4 watt
Maximum driver rating 3amps @ 55volts
16bit Timer1 overflow calculation.
For 20Mhz clock prescale is 5,000,000/T1_DIV_BY_X
T1_DIV_BY_8 1.6us >>> 2^16 * 1.6us = .1049 seconds b4 overflow
T1_DIV_BY_1 200ns >>> 2^16 * 200ns = .013 seconds b4 overlow
*/
#include <16F627.h>
#use delay(clock=20000000)
#fuses HS,NOWDT,MCLR,NOPROTECT,BROWNOUT,NOLVP
#byte PORT_A = 5
#byte PORT_B = 6
static char pos = 0;
static int16 timer_count=0; // timer1 overflow counter
#define step_input PIN_B0
#define dir_input PIN_B1
//Choose step input configuration
//#define fullstep
//#define halfstep
//#define halfstep_torque
//#define microstep4
//#define microstep8
#define microstep10
//Comment out if step multiplier is NOT needed, routine yet not tested.
//#define step_multiply
//#define step_x 2 //Number of steps to multiply.
//
#ifdef fullstep
#define STEPS 4
//full step drive
//200 steps rev
byte PBF[4] = {
0b11111000,
0b00000000,
0b11110100,
0b00001100
};
byte PBR[4] = {
0b11111000,
0b00000000,
0b11110100,
0b00001100
};
byte PA[4] = {
0b0000,
0b1111,
0b0000,
0b1111
};
#endif
#ifdef halfstep
//half step drive without torque compensation
//400 steps rev
#define STEPS 8
byte PBF[8] = {
0b11111000,
0b11111000,
0b00000000,
0b11110000,
0b11110100,
0b11110100,
0b00001100,
0b11111100
};
byte PBR[8] = {
0b11111000,
0b11111000,
0b00000000,
0b11110000,
0b11110100,
0b11110100,
0b00001100,
0b11111100
};
byte PA[8] = {
0b0000,
0b1111,
0b1111,
0b1111,
0b0000,
0b1111,
0b1111,
0b1111
};
#endif
#ifdef halfstep_torque
//half step drive with torque compensation
//400 steps rev
#define STEPS 8
byte PBF[8] = {
0b00001100,
0b10111100,
0b11111000,
0b10111000,
0b00000000,
0b10110000,
0b11110100,
0b10110100
};
byte PBR[8] = { //fix for LMD bug
0b00001100,
0b10111100,
0b11111100, //LMD bug fix, changed DIR A to 1
0b10111000,
0b00001000, //LMD bug fix, changed DIR B to 1
0b10110000,
0b11110000, //LMD bug fix, changed DIR A to 0
0b10110100
};
byte PA[8] = {
0b1111,
0b1011,
0b0000,
0b1011,
0b1111,
0b1011,
0b0000,
0b1011
};
#endif
#ifdef microstep4
//quarter step drive
//800 steps rev
#define STEPS 16
byte PBF[16] ={
0b00001100,
0b01101100,
0b10111100,
0b11101100,
0b11111000,
0b11101000,
0b10111000,
0b01101000,
0b00000000,
0b01100000,
0b10110000,
0b11100000,
0b11110100,
0b11100100,
0b10110100,
0b01100100
};
byte PBR[16] ={ //fix for LMD bug
0b00001100,
0b01101100,
0b10111100,
0b11101100,
0b11111100, //LMD bug fix, changed DIR A to 1
0b11101000,
0b10111000,
0b01101000,
0b00001000, //LMD bug fix, changed DIR B to 1
0b01100000,
0b10110000,
0b11100000,
0b11110000, //LMD bug fix, changed DIR A to 0
0b11100100,
0b10110100,
0b01100100
};
byte PA[16] = {
0b1111,
0b1110,
0b1011,
0b0110,
0b0000,
0b0110,
0b1011,
0b1110,
0b1111,
0b1110,
0b1011,
0b0110,
0b0000,
0b0110,
0b1011,
0b1110
};
#endif
#ifdef microstep8
//eight step drive
//1600 steps rev
#define STEPS 32
byte PBF[32] ={
0b00001100,
0b00111100,
0b01101100,
0b10001100,
0b10111100,
0b11001100,
0b11101100,
0b11111100,
0b11111000,
0b11111000,
0b11101000,
0b11001000,
0b10111000,
0b10001000,
0b01101000,
0b00111000,
0b00000000,
0b00110000,
0b01100000,
0b10000000,
0b10110000,
0b11000000,
0b11100000,
0b11110000,
0b11110100,
0b11110100,
0b11100100,
0b11000100,
0b10110100,
0b10000100,
0b01100100,
0b00110100
};
byte PBR[32] ={ //fix for LMD bug
0b00001100,
0b00111100,
0b01101100,
0b10001100,
0b10111100,
0b11001100,
0b11101100,
0b11111100,
0b11111100, //LMD bug fix, changed DIR A to 1
0b11111000,
0b11101000,
0b11001000,
0b10111000,
0b10001000,
0b01101000,
0b00111000,
0b00001000, //LMD bug fix, changed DIR B to 1
0b00110000,
0b01100000,
0b10000000,
0b10110000,
0b11000000,
0b11100000,
0b11110000,
0b11110000, //LMD bug fix, changed DIR A to 0
0b11110100,
0b11100100,
0b11000100,
0b10110100,
0b10000100,
0b01100100,
0b00110100
};
byte PA[32] ={
0b1111,
0b1111,
0b1110,
0b1100,
0b1011,
0b1000,
0b0110,
0b0011,
0b0000,
0b0011,
0b0110,
0b1000,
0b1011,
0b1100,
0b1110,
0b1111,
0b1111,
0b1111,
0b1110,
0b1100,
0b1011,
0b1000,
0b0110,
0b0011,
0b0000,
0b0011,
0b0110,
0b1000,
0b1011,
0b1100,
0b1110,
0b1111
};
#endif
#ifdef microstep10
//ten step drive
//2000 steps rev
#define STEPS 40
byte PBF[40] ={
0b00001100,
0b00101100,
0b01011100,
0b01111100,
0b10011100,
0b10111100,
0b11001100,
0b11011100,
0b11101100,
0b11111100,
0b11111000,
0b11111000,
0b11101000,
0b11011000,
0b11001000,
0b10111000,
0b10011000,
0b01111000,
0b01011000,
0b00101000,
0b00000000,
0b00100000,
0b01010000,
0b01110000,
0b10010000,
0b10110000,
0b11000000,
0b11010000,
0b11100000,
0b11110000,
0b11110100,
0b11110100,
0b11100100,
0b11010100,
0b11000100,
0b10110100,
0b10010100,
0b01110100,
0b01010100,
0b00100100
};
byte PBR[40] ={ //fix for LMD bug
0b00001100,
0b00101100,
0b01011100,
0b01111100,
0b10011100,
0b10111100,
0b11001100,
0b11011100,
0b11101100,
0b11111100,
0b11111100, //LMD bug fix, changed DIR A to 1
0b11111000,
0b11101000,
0b11011000,
0b11001000,
0b10111000,
0b10011000,
0b01111000,
0b01011000,
0b00101000,
0b00001000, //LMD bug fix, changed DIR B to 1
0b00100000,
0b01010000,
0b01110000,
0b10010000,
0b10110000,
0b11000000,
0b11010000,
0b11100000,
0b11110000,
0b11110000, //LMD bug fix, changed DIR A to 0
0b11110100,
0b11100100,
0b11010100,
0b11000100,
0b10110100,
0b10010100,
0b01110100,
0b01010100,
0b00100100
};
byte const PA[40] ={
0b1111,
0b1111,
0b1110,
0b1101,
0b1100,
0b1011,
0b1001,
0b0111,
0b0101,
0b0010,
0b0000,
0b0010,
0b0101,
0b0111,
0b1001,
0b1011,
0b1100,
0b1101,
0b1110,
0b1111,
0b1111,
0b1111,
0b1110,
0b1101,
0b1100,
0b1011,
0b1001,
0b0111,
0b0101,
0b0010,
0b0000,
0b0010,
0b0101,
0b0111,
0b1001,
0b1011,
0b1100,
0b1101,
0b1110,
0b1111
};
#endif
void step(char dir)
{
#if !defined (microstep10)
pos = (steps + pos + dir) & (STEPS-1); //works only for STEPS of 4,8,32
#else
pos = (pos + STEPS + dir) % STEPS; //for microstep10, this one works for any STEPS length value but takes longer to calculate
#endif
PORT_A = PA[pos]; //output to drivers
PORT_B = PBF[pos];
}
void stepper_off() //Turn off power to all windings.
{
PORT_A = 0;
PORT_B = 0;
}
void init_stepper() //Move a few to register correct step position.
{
int i;
for (i=0;i<8;i++){
step(-1);
delay_ms(100);
}
for (i=0;i<8;i++){
step(1);
delay_ms(100);
}
}
#INT_EXT //Pin B0 interrupt service routine for Step input Active low
void ext_isr() {
//read dir input and advance motor
signed int dir,i,temp;
dir=input(dir_input);
#if !defined (microstep10)
if (dir==0){
dir=-1;}
#endif
//Step Multiply routine, not fully working. In testing stage.
#ifdef step_multiply
for (i=0;i<step_x;i++){
step(dir);
delay_us(5); //Note: May need to increase or decrease this delay depending on how slow your motor is.
}
#else
#if !defined (microstep10)
pos = (steps + pos + dir) & (STEPS-1); //works only for STEPS of 4,8,32
#else
if(dir==0){ //faster microstep10 routine
pos = (pos + 1);
if (pos==40) {
pos=0;
}
}
else{
if (pos==0) {
pos=40;
}
pos = (pos - 1);
}
#endif
//output to drivers
if(dir==0){
PORT_B = PBF[pos];}
else{
PORT_B = PBR[pos];
}
PORT_A = PA[pos];
#endif
timer_count=0; //reset timer1 counter
}
#int_timer1 //This function is called everytime
timer_isr() { //the timer1 overflows (2^16).
timer_count++;
}
void main() {
setup_timer_1( T1_INTERNAL | T1_DIV_BY_8 ); //init timer1
enable_interrupts(INT_TIMER1); //turn on timer1 interrupt
setup_counters(RTCC_INTERNAL,RTCC_DIV_2);
ext_int_edge(H_TO_L); //init interrupt edge triggering for B0, Active Low
enable_interrupts(INT_EXT); //turn on external B0 interrupt
enable_interrupts(GLOBAL);
set_tris_a(0x10); //set port A&B for correct data i/o directions
set_tris_b(0x03);
#use fast_io (A)
#use fast_io (B)
stepper_off(); //No current to motor.
delay_ms(1000); //1 second turn on delay.
init_stepper();
loop:
if (timer_count>1700){ //Shutdown motor drivers after 3 minutes when no step pulse activity
PORT_A = 0b0010; //Set current level at 12% hold
PORT_B = (PBF[pos] & 0b00001111) | 0b00100000;
}
goto loop; //keep looping, waiting for interrupt request
}edit: I posted the code here because it is only available in a zip file that must be downloaded. Can be found here: http://www.embeddedtronics.com/public/Electronics/microstep/microstep_source.zip
Last edited:
