motor.h

机器人部分C语言编码 c语言 供大家参考学习

// *********************************************************************************** //
//
//	Filename		:   motor.h
//	Title        	:   TowerBuilder Motor Control
//	Author			:   Fung Tin Ching&fym
//	Created Date	:   2007.11.2
//	Revisited Date	:   2008.01.16
//	Description		:   This source file responsible for the motor control
//	Version         :   1.2
//
//  Copyright (c) 2008, All rights reserved.
// *********************************************************************************** //

#ifndef _MOTOR_H
#define _MOTOR_H
#include "Global.h"

// ================================================================================================================= //
// =========================                           Constants                           ========================= //
// ================================================================================================================= //

#define motor_period          40
#define motor_timer_value     0xFF19

#ifndef MOTOR_MODE
	  // **Already define in the Global.h
	#define MOTOR_MODE_FORWARD     0
	#define MOTOR_MODE_BACKWARD    1
	#define MOTOR_MODE_BREAK       2
	#define MOTOR_MODE_FREEWHEEL   3
#endif

#define MOTOR_LEFT_FORWARD()        ML1=1;ML2=0;MLD=1
#define MOTOR_LEFT_BACKWARD()       ML1=0;ML2=1;MLD=1
#define MOTOR_LEFT_BREAK()          ML1=1;ML2=1;MLD=1
#define MOTOR_LEFT_FREEWHEEL()      MLD=0

#define MOTOR_RIGHT_FORWARD()       MR1=1;MR2=0;MRD=1
#define MOTOR_RIGHT_BACKWARD()      MR1=0;MR2=1;MRD=1
#define MOTOR_RIGHT_BREAK()         MR1=1;MR2=1;MRD=1
#define MOTOR_RIGHT_FREEWHEEL()     MRD=0

// ================================================================================================================= //
// =========================                            Variables                          ========================= //
// ================================================================================================================= //

volatile unsigned char motor_left=0;       // Left Motor Speed       
volatile unsigned char motor_right=0;       // Right Motor Speed
volatile unsigned char motor_left_mode=MOTOR_MODE_BREAK;  // Left Motor Mode; 0: FORWARD 1:BACKWARD 2:BREAK 3:FREEWHEEL
volatile unsigned char motor_right_mode=MOTOR_MODE_BREAK;  // Right Motor Mode; 0: FORWARD 1:BACKWARD 2:BREAK 3:FREEWHEEL

unsigned char motor_count=0;

 
// ================================================================================================================= //
// =========================                          Function Body                        ========================= //
// ================================================================================================================= //

  
void init_timer0(void)
{
	TMOD |= 0x01; // Set the Timer 0 to  Mode 1
	TR0 = 0;      // Stop Time 0
	TL0  = low_byte(motor_timer_value); 
	TH0  = high_byte(motor_timer_value);    
	TF0 = 0;      // Clear Time 0 Overflow Flag
	ET0 = 1;      // Enable Time 0 Interrupt
    EX0 = 0;      // Disable Time 0 Exterenal Interrupt
	PT0 = 1;      // Make the Timer 0 interrupt Become highest Priority 
	TR0 = 1;      // Run Time 0
}


// Interrupt Services Routine for Timer 0 
void T0_int(void) interrupt TF0_VECTOR using 1
{
	TF0 = 0;     // Clear the Timer 0 Overflow Flag
	TL0  = low_byte(motor_timer_value); 
	TH0  = high_byte(motor_timer_value);
	motor_ISR();
}

void init_motor(void)
{
	MCOUNTL=MCOUNTR=1;
	MOTOR_LEFT_BREAK();
	MOTOR_RIGHT_BREAK();
	init_timer0();
}




void motor_ISR(void)
{
	if(motor_count<motor_period)
		motor_count++;
	else
		motor_count=0;


	if (motor_left_mode==MOTOR_MODE_BREAK)
	{
		MOTOR_LEFT_BREAK();										
	} 
	else if (motor_left_mode==MOTOR_MODE_FREEWHEEL)
	{
		MOTOR_LEFT_FREEWHEEL();
	}
	else {

		//  Motor L PWM
		if (motor_count < motor_left)
		{
			switch (motor_left_mode)
			{
				case MOTOR_MODE_BACKWARD:
											MOTOR_LEFT_BACKWARD();
											break;
				case MOTOR_MODE_FORWARD:
											MOTOR_LEFT_FORWARD();
											break;	
			}

		}
		 else
		  {
			MOTOR_LEFT_BREAK();
		   }
	}


	if (motor_right_mode==MOTOR_MODE_BREAK)
	{
		MOTOR_RIGHT_BREAK();										
	} 
	else if (motor_right_mode==MOTOR_MODE_FREEWHEEL)
	{
		MOTOR_RIGHT_FREEWHEEL();
	}
	
	    else {

		//  Motor L PWM
		if (motor_count < motor_right)
		{
			switch (motor_right_mode)
			{
				case MOTOR_MODE_BACKWARD:
											MOTOR_RIGHT_BACKWARD();
											break;
				case MOTOR_MODE_FORWARD:
											MOTOR_RIGHT_FORWARD();
											break;	
			}

		}
		 else
		  {
			MOTOR_RIGHT_BREAK();
		  }
	}
}


void set_left_motor(u08 mode, u08 speed)
{
		motor_left_mode=mode;
		motor_left=speed;
}

void set_right_motor(u08 mode, u08 speed)
{
		motor_right_mode=mode;
		motor_right=speed;
}

void go_forward(u08 speed)
{
	 set_left_motor(MOTOR_MODE_FORWARD,speed);
	 set_right_motor(MOTOR_MODE_FORWARD,speed);
	 motor_ISR();
}
void go_back(u08 speed)
{
	 set_left_motor(MOTOR_MODE_BACKWARD,speed);
	 set_right_motor(MOTOR_MODE_BACKWARD,speed);
	 motor_ISR();
}
void go_right_fast(u08 speed)
{
	 set_left_motor(MOTOR_MODE_FORWARD,speed);
	 set_right_motor(MOTOR_MODE_BACKWARD,speed);
	 motor_ISR();
}
void go_left_fast(u08 speed)
{
	 set_left_motor(MOTOR_MODE_BACKWARD,speed);
	 set_right_motor(MOTOR_MODE_FORWARD ,speed);
	 motor_ISR();
}
void go_right_slow(u08 speed)
{
	 set_left_motor(MOTOR_MODE_FORWARD,speed);
	 set_right_motor(MOTOR_MODE_BREAK,speed);
	 motor_ISR();
}
void go_left_slow(u08 speed)
{
	 set_left_motor(MOTOR_MODE_BREAK,speed);
	 set_right_motor(MOTOR_MODE_FORWARD ,speed);
	 motor_ISR();
}
void stop()
{
		motor_left_mode=MOTOR_MODE_BREAK;
		motor_right_mode=MOTOR_MODE_BREAK;
		motor_ISR();
}
#endif