stepper.c

在linux下通过298N控制的步进电机驱动程序

                        else
                        {
                                stepper_move(motor, stepnum-motor->current_step);
                        }
		}
	}
}


static void stepper_move(Stepper *motor, int steps)
{
	int i,move;	
	int use_accel=0;

	int progress=0, ramp=0;
		
	if (motor->accelerate && motor->delay<motor->accelerate_min)
		use_accel = 1;
	//printf("debug stepper_move: %d\n", steps);

	if (steps<0)
	{
		move = -steps;
		if (use_accel) { delay=motor->accelerate_from; }
		for (i=0; i>steps; i--)
		{
			if (use_accel) {
				progress++; 
				if (progress<move/2) // accelerating phase
				{
					delay-=motor->accelerate_step; 
					if (delay<motor->delay) { delay=motor->delay; } else { ramp++; }

				}
				else  // decelerating phase
				{
					if (move-progress<=ramp)
					{			
						delay+=motor->accelerate_step;
						if (delay>motor->accelerate_from) { delay=motor->accelerate_from; }
					}
				}
			}
		step_back(motor,delay);
		motor->current_step--;
		}		
	}
	else
	{
		move = steps;
		if (use_accel) { delay=motor->accelerate_from; }
		for (i=0;i<steps;i++)
		{
			if (use_accel) {
				progress++;
				if (progress<move/2) // accelerating phase
				{ 
					delay-=motor->accelerate_step; 
					if (delay<motor->delay) { delay=motor->delay; } else { ramp++; }
				}
				else  // decelerating phase
				{
					if (move-progress<=ramp)
					{
						delay+=motor->accelerate_step;
						if (delay>motor->accelerate_from) { delay=motor->accelerate_from; }
					}
				}
			}
		step_forward(motor,delay);
		if(i>=3)
			motor->current_step += 0;
		else	
			motor->current_step++;
		}
	}
}


static int stepper_open(struct inode *inode,struct file *filp)
{       
	//int result; 	
	//static int counter = 0;
	if(Device_Open) 
	return -EBUSY;
	printk("Opening in WR mode for stepper device\n");
	Device_Open++;		
	MOD_INC_USE_COUNT; 
	
	motor=NULL;	
	motor = stepper_create();	 
	return 0;
}


static int stepper_release(struct inode *inode,struct file *filp)
{       
	printk("Closing stepper...\n");
	Device_Open --;
	MOD_DEC_USE_COUNT;
		
	kfree(motor);		
	return 0;
}

/*static  ssize_t  stepper_write(struct file *file,const char *buffer, size_t len,loff_t *offset)
{
//        char  data;
        int  steps;	
        get_user(steps,(int*)buffer); //get steps from userspace
        printk("stepper steps is %d\n",steps);
	 stepper_move(motor,steps);
	 
	 return 1;
}
*/

static int stepper_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg )
{
	int result,steps,tmp;
	//mode=cmd;
	switch (cmd)  {
		case Stepper_On:
			printk("Stepper is on\n");
			result=(inl(rPCOND)& ~0xffff)| 0x5555;
			outb(result,rPCOND); /*config the port D,control stepper*/
			//result=inl(rPUPD)|0xff;
			//outb(result,rPUPD);
			break;
	   	
  		case Stepper_Off:
			printk("Stepper is off\n");
			outb(0x00,motor->io_address);               
			break;
						
		case Stepper_Full:
			printk("Full-Step mode initialized\n");
			j=0;
			motor->half_stepping = 0;
			break;
						
		case Stepper_Half:
			printk("Half-Step mode initialized\n");
			j=1;
			motor->half_stepping = 1;
			break;
										
		case Stepper_Front:
			printk("Stepper running front\n"); /*clockwise*/
			i=2;
			motor->curve = 0;
			//if(copy_from_user(&steps, (int*)arg,sizeof(int)))
			//return -EFAULT;
			//get_user(steps,(int*)arg);	
			steps= arg;
			printk("stepper steps is %d\n",steps);
			stepper_move(motor,steps);
			break;
						
		case Stepper_Back:
			printk("Stepper running back\n");/*anticolokwise*/
			i=2;
			//if(copy_from_user(&steps, (int*)arg,sizeof(int)))
			//return -EFAULT;	
			//get_user(steps,(int*)arg); 
			steps= arg;
			printk("stepper steps is %d\n",steps);
			stepper_move(motor,steps);
			break;
						
		case Stepper_Left:
			printk("Stepper turn left\n");
			i=3;
			motor->curve = 0;
			//if(copy_from_user(&steps, (int*)arg,sizeof(int)))
			//return -EFAULT;	
			//get_user(steps,(int*)arg);
			steps= arg;
			printk("stepper steps is %d\n",steps);
			stepper_move(motor,steps);
					 
			tmp=get_angle(motor,steps);    /* get the stepper turn left angles*/
			return tmp;
			break;
						
		case Stepper_Right:
			printk("Stepper turn right\n");
			i=4;
			motor->curve = 0;
			//if(copy_from_user(&steps, (int*)arg,sizeof(int)))
			//return -EFAULT;
			//get_user(steps,(int*)arg);
			steps= arg;
			printk("stepper steps is %d\n",steps);
			stepper_move(motor,steps);
				  
			tmp=get_angle(motor,steps);    /* get the stepper turn right angles*/
			return tmp;
			break;
			
		case Stepper_Left_Curve:
			printk("stepper turn left curve\n");
			motor->curve = 1;
			i = 0;
			steps = arg;
			printk("stepper steps is %d\n",steps);
			stepper_move(motor,steps);
			break;

		case Stepper_Right_Curve:
			printk("stepper turn right curve\n");
			motor->curve = 1;
			i = 1;
			steps = arg;
			printk("stepper steps is %d\n",steps);
			stepper_move(motor,steps);
			break;
			
		case Use_Accel:
			printk("stepper run accelerate\n");
			motor->accelerate=arg;
			break;

		case Accel_From:
			printk("stepper accelerates from this delay\n");
			motor->accelerate_from=arg;
			break;

		case Accel_Min:
			printk("stepper accelerates with min delay\n");
			motor->accelerate_min=arg;
			break;

		case Accel_Step:
			printk("stepper accelerates with this delays\n");
			motor->accelerate_step=arg;
			break;

		case Limit_Speed:
			printk("stepper's delay is this set_speed\n");
			motor->delay = arg;
			break;
			
		case Average_Speed:
			printk("stepper runs this average speed\n");
			delay =arg;
			break;
			
		case Set_ShortPath:
			printk("config shortpath\n");
			motor->short_path = arg;
			break;
			
		case Set_Zero:
			printk("config motor current step\n");
			motor->current_step=0;
			break;
			
		case Goto_Step:
			printk("go to step\n");
			steps = arg;
			stepper_gotostep(motor, steps);
			break;				
        	}
		return 0;
}


static struct file_operations stepper_fops={
	open:         stepper_open,
	//write:         stepper_write,
	release:  stepper_release,
	ioctl:          stepper_ioctl,
};


int init_stepper(void)
{
	int result;
        result = register_chrdev(Major, DEVICE_NAME, &stepper_fops);
        if (result ==-1) {
           printk("<1>Registering the stepper device failed with %d\n",Major);
           return Major;
        }
       else{ 
        printk("############################################\n");
        printk("Hello,I'm in kernel mode,this is stepper device\n");
        printk("<1>Registered, Major no= %d\n",Major);
        printk("############################################\n");
        printk("writen by xiao gang\n");
        printk("############################################\n");
       }
	return 0;
}

static void cleanup_stepper(void)
{
        printk("<1>Unregistered\n");
	 printk("Hello, I'm going to out,good bye,stepper\n");
        unregister_chrdev(Major,DEVICE_NAME);
}

module_init(init_stepper);
module_exit(cleanup_stepper);