项目描述：

用单片机(STC89C52RC)控制两个直流电机，从而实现各种运动形式。

本例中实现功能为：前进 后退 右转 左转。

C语言程序如下：
/*------------------------------------
FileName: main.c
Function: MCU控制两个直流电机组合运动
Description: 向前 向后 右转 左转
Author: Zhang Kaizhou
Date: 2019-6-9 17:28:42
------------------------------------*/
#include "ZKZ.h"

bit dirFlag = 0; // 前进方向标志 0-向前 1-向后
bit turnFlag = 0; // 转向方向标志 0-向右 1-向左

void main(){
	while(1){
		keyScan();
		motorRun();
	}
}

/*软件延时xms函数*/
void delay(uchar xms){
	uchar i, j;
	for(i = xms; i > 0; i--)
		for(j = 110; j > 0; j--);
}

/*键盘扫描函数*/
void keyScan(){
	if(!goAhead){
		delay(5);
		if(!goAhead){
			while(!goAhead);
			dirFlag = 0;
		}
	}
	if(!goBack){
		delay(5);
		if(!goBack){
			while(!goBack);
			dirFlag = 1;
		}
	}
	if(!turnRight){
		delay(5);
		if(!turnRight){
			while(!turnRight);
			turnFlag = 0;
		}
	}
	if(!turnLeft){
		delay(5);
		if(!turnLeft){
			while(!turnLeft);
			turnFlag = 1;
		}
	}
}

/*直流电机运转函数*/
void motorRun(){
	if(!dirFlag){
		MLEn = 1;
		ML1 = 1;
		ML2 = 0;
		MREn = 1;
		MR1 = 1;
		MR2 = 0;
	}else{
		MLEn = 1;
		ML1 = 0;
		ML2 = 1;
		MREn = 1;
		MR1 = 0;
		MR2 = 1;
	}
	if(!turnFlag){
		MLEn = 1;
		MREn = 0;
	}else{
		MLEn = 0;
		MREn = 1;
	}
}

/*------------------------------------
FileName: ZKZ.h
Function: MCU控制两个直流电机组合运动
Description: 向前 向后 右转 左转
Author: Zhang Kaizhou
Date: 2019-6-9 17:28:42
------------------------------------*/
#include <reg52.h>
#define uchar unsigned char
#define uint unsigned int

/*直流电机驱动模块端口定义*/
sbit MLEn = P1^4; // 左边电机驱动端口
sbit ML1 = P1^2;
sbit ML2 = P1^3;
sbit MREn = P1^5; // 右边电机驱动端口
sbit MR1 = P1^6;
sbit MR2 = P1^7;

/*独立按键端口定义*/
sbit goAhead = P3^4; // 向前
sbit goBack = P3^5; // 向后
sbit turnRight = P3^6; // 向右转
sbit turnLeft = P3^7; // 向左转

/*主模块函数声明*/
void delay(uchar xms);
void keyScan();
void motorRun();

一、使用proteus绘制简单的电路图，用于后续仿真





二、编写程序

/********************************************************************************************************************
----	@Project:	LED-74HC595
----	@File:	main.c
----	@Edit:	ZHQ
----	@Version:	V1.0
----	@CreationTime:	20200602
----	@ModifiedTime:	20200603
----	@Description:	用矩阵键盘中的S1键作为启动独立按键，用S5按键模拟左边
----	的开关感应器，用S9按键模拟右边的开关感应器，用S13按键模拟下边的开关感应器。
----	记得把输出线P0.4一直输出低电平，模拟独立按键的触发地GND。
----	开机默认机械手在左上方的原点位置。按下启动按键后，机械手从左边开始往右边移动，当机械手移动
----	到最右边时，机械手马上开始往下移动，最后机械手移动到最右下角的位置时，延时1秒，然后原路返
----	回，一直返回到左上角的原点位置。注意：启动按键必须等机械手处于左上角原点位置时，启动按键的
----	触发才有效。
----	单片机：AT89C52
********************************************************************************************************************/
#include "reg52.h"
/*——————宏定义——————*/
#define FOSC 11059200L
#define T1MS (65536-FOSC/12/1000)   /*1ms timer calculation method in 12Tmode*/


#define	const_voice_short	40	/*蜂鸣器短叫的持续时间*/


#define	const_key_time1	20	/*按键去抖动延时的时间*/

#define	const_sensor	20	/*开关感应器去抖动延时的时间*/

#define	const_1s	500	/*开关感应器去抖动延时的时间*/

/*——————变量函数定义及声明——————*/
/*定义74HC595*/
sbit Hc595_Sh = P2^3;
sbit Hc595_St = P2^4;
sbit Hc595_Ds = P2^5;

/*定义蜂鸣器*/
sbit Beep = P2^7;

/*定义按键*/
sbit Key_S1 = P0^0;	/*定义按键S1，对应S1*/
sbit Key_Left = P0^1;	/*定义开关感应器Left，对应S5*/
sbit Key_Right = P0^2;	/*定义开关感应器Right，对应S9*/
sbit Key_Down = P0^3;	/*定义开关感应器Down，对应S13*/

sbit Key_Gnd = P0^4;	/*定义按键模拟地*/

unsigned char ucLED1 = 0;   /*代表16个灯的亮灭状态，0代表灭，1代表亮*/
unsigned char ucLED2 = 0;
unsigned char ucLED3 = 0;
unsigned char ucLED4 = 0;
unsigned char ucLED5 = 0;
unsigned char ucLED6 = 0;
unsigned char ucLED7 = 0;
unsigned char ucLED8 = 0;
unsigned char ucLED9 = 0;
unsigned char ucLED10 = 0;
unsigned char ucLED11 = 0;
unsigned char ucLED12 = 0;
unsigned char ucLED13 = 0;
unsigned char ucLED14 = 0;
unsigned char ucLED15 = 0;
unsigned char ucLED16 = 0;


unsigned char ucLed_update = 1;  /*刷新变量。每次更改LED灯的状态都要更新一次。*/

unsigned char ucLedStatus16_09 = 0;   /*代表底层74HC595输出状态的中间变量*/
unsigned char ucLedStatus08_01 = 0;   /*代表底层74HC595输出状态的中间变量*/

unsigned int uiRunTimeCnt = 0;	/*运动中的时间延时计数器变量*/
unsigned char ucRunStep = 0;	/*运动控制的步骤变量*/

unsigned char ucKeySec = 0;	/*被触发的按键编号*/

unsigned int	uiKeyTimeCnt1 = 0;	
unsigned char	ucKeyLock1 = 0;	

unsigned int	uiLeftCnt1 = 0;	/*左边感应器软件抗干扰所需的计数器变量*/
unsigned int	uiLeftCnt2 = 0;
unsigned char	ucLeft = 0;	/*左边感应器经过软件抗干扰处理后的状态标志*/

unsigned int	uiRightCnt1 = 0;	/*右边感应器软件抗干扰所需的计数器变量*/
unsigned int	uiRightCnt2 = 0;
unsigned char	ucRight = 0;	/*右边感应器经过软件抗干扰处理后的状态标志*/

unsigned int	uiDownCnt1 = 0;	/*下边感应器软件抗干扰所需的计数器变量*/
unsigned int	uiDownCnt2 = 0;
unsigned char	ucDown = 0;	/*下边感应器经过软件抗干扰处理后的状态标志*/

unsigned int uiVoiceCnt = 0;	/*蜂鸣器鸣叫的持续时间计数器*/


/**
* @brief  定时器0初始化函数
* @param  无
* @retval 初始化T0
**/
void Init_T0(void)
{
	TMOD = 0x01;                    /*set timer0 as mode1 (16-bit)*/
	TL0 = T1MS;                     /*initial timer0 low byte*/
	TH0 = T1MS >> 8;                /*initial timer0 high byte*/
}
/**
* @brief  外围初始化函数
* @param  无
* @retval 初始化外围
**/
void Init_Peripheral(void)
{
	ET0 = 1;/*允许定时中断*/
	TR0 = 1;/*启动定时中断*/
	EA = 1;/*开总中断*/

}

/**
* @brief  初始化函数
* @param  无
* @retval 初始化单片机
**/
void	Init(void)
{
	Key_Gnd = 0;
	Beep = 1;
	
	Init_T0();
}
/**
* @brief  延时函数
* @param  无
* @retval 无
**/
void Delay_Long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  /*内嵌循环的空指令数量*/
          {
             ; /*一个分号相当于执行一条空语句*/
          }
   }
}
/**
* @brief  延时函数
* @param  无
* @retval 无
**/
void Delay_Short(unsigned int uiDelayShort)
{
   unsigned int i;
   for(i=0;i<uiDelayShort;i++)
   {
		 ; /*一个分号相当于执行一条空语句*/
   }
}

/**
* @brief  开关感应器软件抗干扰处理函数
* @param  无
* @retval 放在定时中断里
* 开关感应器的抗干扰处理，本质上类似按键的去抖动处理。唯一的区别是：
* 按键去抖动关注的是IO口的一种状态，而开关感应器关注的是IO口的两种状态。
* 当开关感应器从原来的1状态切换到0状态之前，要进行软件滤波处理过程，一旦成功地
* 切换到0状态了，再想从0状态切换到1状态的时候，又要经过软件滤波处理过程，符合
* 条件后才能切换到1的状态。通俗的话来说，按键的去抖动从1变成0难，从0变成1容易。
* 开关感应器从1变成0难，从0变成1也难。这里所说的"难"是指要经过去抖处理。
**/
void Sensor_Scan(void)
{
	if(Key_Left == 1)	/*左边感应器是高电平，说明有可能没有被接触*/
	{
		uiLeftCnt1 = 0;	/*在软件滤波中，非常关键的语句！！！类似按键去抖动程序的及时清零*/
		uiLeftCnt2 ++;
		if(uiLeftCnt2 > const_sensor)
		{
			uiLeftCnt2 = 0;
			ucLeft = 1;	/*说明感应器确实没有被接触*/
		}
	}
	else
	{
		uiLeftCnt2 = 0;	
		uiLeftCnt1 ++;
		if(uiLeftCnt1 > const_sensor)
		{
			uiLeftCnt1 = 0;
			ucLeft = 0;	/*说明感应器确实被接触到了*/
		}
	}
	
	if(Key_Right == 1)	/*右边感应器是高电平，说明有可能没有被接触*/
	{
		uiRightCnt1 = 0;	/*在软件滤波中，非常关键的语句！！！类似按键去抖动程序的及时清零*/
		uiRightCnt2 ++;
		if(uiRightCnt2 > const_sensor)
		{
			uiRightCnt2 = 0;
			ucRight = 1;	/*说明感应器确实没有被接触*/
		}
	}
	else
	{
		uiRightCnt2 = 0;	
		uiRightCnt1 ++;
		if(uiRightCnt1 > const_sensor)
		{
			uiRightCnt1 = 0;
			ucRight = 0;	/*说明感应器确实被接触到了*/
		}
	}
	
	if(Key_Down == 1)	/*下边感应器是高电平，说明有可能没有被接触*/
	{
		uiDownCnt1 = 0;	/*在软件滤波中，非常关键的语句！！！类似按键去抖动程序的及时清零*/
		uiDownCnt2 ++;
		if(uiDownCnt2 > const_sensor)
		{
			uiDownCnt2 = 0;
			ucDown = 1;	/*说明感应器确实没有被接触*/
		}
	}
	else
	{
		uiDownCnt2 = 0;	
		uiDownCnt1 ++;
		if(uiDownCnt1 > const_sensor)
		{
			uiDownCnt1 = 0;
			ucDown = 0;	/*说明感应器确实被接触到了*/
		}
	}
}

/**
* @brief  扫描按键
* @param  无
* @retval 放在定时中断里
**/
void Key_Scan(void)
{
	if(Key_S1 == 1)	/*IO是高电平，说明按键没有被按下，这时要及时清零一些标志位*/
	{
		ucKeyLock1 = 0;
		uiKeyTimeCnt1 = 0;
	}
	else if(ucKeyLock1 == 0)	/*有按键按下，且是第一次被按下*/
	{
		uiKeyTimeCnt1 ++;	/*累加定时中断次数*/
		if(uiKeyTimeCnt1 > const_key_time1)
		{
			uiKeyTimeCnt1 = 0;
			ucKeyLock1 = 1;	/*自锁按键置位,避免一直触发*/
			ucKeySec = 1;
		}
	}
}
/**
* @brief  按键服务的应用程序
* @param  无
* @retval 无
**/
void Key_Service(void)
{
	switch(ucKeySec)	/*按键服务状态切换*/
	{
		case 1:	/*启动按键，对应S1*/
			if(ucLeft == 0)	/*处于左上角原点位置*/
			{
				ucRunStep = 1;	/*启动*/
				uiVoiceCnt = const_voice_short;	/*按键声音触发，滴一声就停。*/				
			}
			ucKeySec = 0;	/*响应按键服务处理程序后，按键编号清零，避免一致触发*/
		break;
	}
}
/**
* @brief  595驱动函数
* @param  无
* @retval * 两个联级74HC595的工作过程：
* 每个74HC595内部都有一个8位的寄存器，两个联级起来就有两个寄存器。ST引脚就相当于一个刷新
* 信号引脚，当ST引脚产生一个上升沿信号时，就会把寄存器的数值输出到74HC595的输出引脚并且锁存起来，
* DS是数据引脚，SH是把新数据送入寄存器的时钟信号。也就是说，SH引脚负责把数据送入到寄存器里，ST引脚
* 负责把寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来。
**/
void HC595_Drive(unsigned char ucLedStatusTemp16_09, unsigned char ucLedStatusTemp08_01)
{
	unsigned char i;
	unsigned char ucTempData;
	Hc595_Sh = 0;
	Hc595_St = 0;	
	
	ucTempData = ucLedStatusTemp16_09;	/*先送高8位*/
	for(i = 0; i < 8; i ++)
	{
		if(ucTempData >= 0x80)
		{
			Hc595_Ds = 1;
		}
		else
		{
			Hc595_Ds = 0;
		}
		Hc595_Sh = 0;	/*SH引脚的上升沿把数据送入寄存器*/
		Delay_Short(15); 
		Hc595_Sh = 1;
		Delay_Short(15); 	
			
		ucTempData = ucTempData <<1;
	}
	ucTempData = ucLedStatusTemp08_01;	/*再先送低8位*/
	for(i = 0; i < 8; i ++)
	{
		if(ucTempData >= 0x80)
		{
			Hc595_Ds = 1;
		}
		else
		{
			Hc595_Ds = 0;
		}
		Hc595_Sh = 0;	/*SH引脚的上升沿把数据送入寄存器*/
		Delay_Short(15); 
		Hc595_Sh = 1;
		Delay_Short(15); 	
			
		ucTempData = ucTempData <<1;
	}
	
	Hc595_St = 0;	/*ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来*/
	Delay_Short(15);
	Hc595_St = 1;
	Delay_Short(15);
	
	Hc595_Sh = 0;	/*拉低，抗干扰就增强*/
	Hc595_St = 0;
	Hc595_Ds = 0;
}
/**
* @brief  LED更新函数
* @param  无
* @retval 
* 把74HC595驱动程序翻译成类似单片机IO口直接驱动方式的过程。
* 每次更新LED输出，记得都要把ucLed_update置1表示更新。
**/
void LED_Update()
{
	if(ucLed_update == 1)
	{
		ucLed_update = 0;	/*及时清零，让它产生只更新一次的效果，避免一直更新。*/
		if(ucLED1 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x01;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xfe;
		}
		if(ucLED2 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x02;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xfd;
		}
		if(ucLED3 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x04;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xfb;
		}
		if(ucLED4 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x08;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xf7;
		}		
		if(ucLED5 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x10;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xef;
		}
		if(ucLED6 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x20;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xdf;
		}
		if(ucLED7 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x40;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xbf;
		}
		if(ucLED8 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x80;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0x7f;
		}
		if(ucLED9 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x01;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xfe;
		}
		if(ucLED10 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x02;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xfd;
		}
		if(ucLED11 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x04;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xfb;
		}
		if(ucLED12 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x08;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xf7;
		}		
		if(ucLED13 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x10;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xef;
		}
		if(ucLED14 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x20;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xdf;
		}
		if(ucLED15 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x40;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xbf;
		}
		if(ucLED16 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x80;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0x7f;
		}
		HC595_Drive(ucLedStatus16_09, ucLedStatus08_01);
	}
}
/**
* @brief  机械手变化函数
* @param  无
* @retval 无
**/
void Left2Right(void)
{
	ucLED1 = 1;	/*1代表左右气缸从左边移动到右边*/
	ucLed_update = 1;	
}
void Right2Left(void)
{
	ucLED1 = 0;	/*0代表左右气缸从右边移动到左边*/
	ucLed_update = 1;	
}
void Up2Down(void)
{
	ucLED2 = 1;	/*1代表左右气缸从上边移动到下边*/
	ucLed_update = 1;	
}
void Down2Up(void)
{
	ucLED2 = 0;	/*0代表左右气缸从下边移动到上边*/
	ucLed_update = 1;	
}
/**
* @brief  设备自动控制程序
* @param  无
* @retval 无
**/
void Run(void)
{
	switch(ucRunStep)
	{
		case 0:	
			/*机械手处于左上角原点的位置，待命状态。此时触发启动按键ucRunStep=1，就触发后续一些列的连续动作。*/
		break;
		case 1:	/*机械手从左边往右边移动*/
			Left2Right();
			ucRunStep = 2;
		break;
		case 2:	/*等待机械手移动到最右边，直到触发了最右边的开关感应器。*/
			if(ucRight == 0)	/*右边感应器被触发*/
			{
				ucRunStep = 3;
			}
		break;
		case 3:	/*机械手从上往下移动*/
			Up2Down();
			ucRunStep = 4;
		break;
		case 4:	/*等待机械手从右上边移动到右下边，直到触发了右下边的开关感应器。*/
			if(ucDown == 0)
			{
				uiRunTimeCnt = 0;	/*时间计数器清零，为接下来延时1秒钟做准备*/
				ucRunStep = 5;
			}
		break;
		case 5:
			if(uiRunTimeCnt > const_1s)
			{
				/*该步骤计数器不用清零*/
				ucRunStep = 6;
			}
		break;
		case 6:
			Down2Up();
			ucRunStep = 7;
		break;
		case 7:	/*原路返回，等待机械手移动到最右边的感应开关*/
			if(ucRight == 0)
			{
				ucRunStep = 8;
			}
		break;
		case 8:	/*原路返回，等待机械手从右边往左边移动*/
			Right2Left();
			ucRunStep = 9;
		break;
		case 9:	/*原路返回，等待机械手移动到最左边的感应开关，表示返回到了原点*/
			if(ucLeft == 0)	/*返回到左上角的原点位置*/
			{
				ucRunStep = 0;
			}
		break;
	}
}

/**
* @brief  定时器0中断函数
* @param  无
* @retval 无
**/
void ISR_T0(void)	interrupt 1
{
	TF0 = 0;  /*清除中断标志*/
  TR0 = 0; /*关中断*/
	
	if(uiRunTimeCnt < 0xffff)	/*设定这个条件，防止uiTimeCnt超范围。*/
	{
		uiRunTimeCnt ++;		
	}
	
	Key_Scan();	
	Sensor_Scan();
  if(uiVoiceCnt != 0)
  {
     uiVoiceCnt--; /*每次进入定时中断都自减1，直到等于零为止。才停止鸣叫*/
     Beep=0;  /*蜂鸣器是PNP三极管控制，低电平就开始鸣叫。*/
  }
  else
  {
     ; /*此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。*/
     Beep=1;  /*蜂鸣器是PNP三极管控制，高电平就停止鸣叫。*/
  }	
	
	TL0 = T1MS;                     /*initial timer0 low byte*/
	TH0 = T1MS >> 8;                /*initial timer0 high byte*/
  TR0 = 1; /*开中断*/	
}

/*——————主函数——————*/
/**
* @brief  主函数
* @param  无
* @retval 实现LED灯闪烁
**/
void main()
{
	/*单片机初始化*/
	Init();
	/*延时，延时时间一般是0.3秒到2秒之间，等待外围芯片和模块上电稳定*/
	Delay_Long(100);
	/*单片机外围初始化*/	
	Init_Peripheral();
	while(1)
	{
		/*设备自动控制程序*/
		Run();
		/*LED更新函数*/
		LED_Update(); 
		/*按键服务的应用程序*/
		Key_Service();
	}
}



三、仿真实现

 




                        
                        
51单片机实现用LED灯和按键来模拟工业自动化设备的运动控制
                    

 

原文地址：http://bbs.elecfans.com/forum.php?mod=viewthread&tid=544143
此帖子现在有一个后续版本，实现了手机端的蓝牙程序控制小车运动以及接收小车状态并展示，链接地址：http://bbs.elecfans.com/forum.ph
 ... d&tid=544299&page=1

最初的想法是做一个红外遥控的装置，链接地址： http://bbs.elecfans.com/forum.ph
 ... d&tid=540165&extra=
我只需要前进和停止，二路遥控，想使用模拟电路搭建，但最后也没能完成，这个想法依然在，现在只能留带以后是否有想法再做了。

第二个想法是想做一个小车，小车的功能如下： 前进，后退，转弯，遥控控制，自主智能运转。 上某宝买了一个小车的底座(4驱动的，带电机)， 买了两个L298N驱动模块用来驱动小车，买了蓝牙模块(HC05)用来充当遥控。

实践篇：
1，首先根据51单片机的最小系统的电路图，焊接了一个最小系统板，使用的STC89c52的单片机(晶振6Mhz，带复位电路，复位指示灯显示)，为了便于测试，又焊接了一个发光二极管连接一个I/O口，用于测试最小系统。
2，然后开始测试最小系统，不过我很多年没有用过keil和下载器了，就上网寻找了一下关于这方面的帖子，过程总结如下：

最小系统测试篇：
要测试最小系统，首先需要编译代码的工具(我用的keil)，下载代码到单片机的工具(stc-isp)，usb转ttl硬件设备(某宝上2块多钱买的)，串口调试助手(使用的是单片机多功能调试助手PortHelper.exe)，于是从网上下载了keil4破解版本，stc-isp下载软件，单片机多功能调试助手三个软件。
第一步：测试usb转ttl是否可用(就4个引脚，5v，GND， TX， RX)
打开串口调试助手，设置波特率，打开，发现打开失败，比较郁闷，为何呢？ 极有可能是串口号不对，于是打开我的电脑-》管理-》设备管理器，找到串口的条目，查看它的串口号，我的竟然是串口号12.于是设置串口号，重新打开，OK。 如何测试usb转ttl呢？ 我的想法是如果发送数据的话，对应的tx引脚应该有信号，如果将TX和RX连接到一起，那么发送出去的应该自己可以接收到。我没有示波器，就简单的使用万用表量它的TX引脚的电压，点击发送按钮，发现TX引脚的电压有波动即可。
第二步： 将usb转ttl的四个引脚接入到单片机的对应引脚即可(其实就是VCC接VCC，GND接GND，TX接RX，RX接TX)。没有采用外部供电，直接利用usb转ttl进行的5v供电
第三步：在keil中写代码，对单片机的某一个I/O进行翻转电平的操作，代码如下
sbit LED=P0^0;
while(1){
    LED = !LED
    Delay10ms(100);
}
第四步：编译程序，生成HEX文件
第五步：打开stc-isp下载工具，选择单片机型号，hex程序位置，点击下载即可，如果识别了单片机的话，会出现给MCU重新上电的字样，这个时候只需要关闭再打开MCU的电源开关即可，就会出现烧写程序的过程。
最小系统测试篇遇到的问题，回忆篇：
51单片机的电源供电问题，忘了接单片机的VCC引脚了（如果是这方面的问题，就检查几个关键地方，vcc和地接好了吗，tx和rx接好了吗，晶振接好了吗，复位电路先不用管，我是使用的万用表一个个的量的）
晶振的电路没焊好（万用表搞定）
usb转ttl找不到串口（软件问题的话，容易解决，也有可能是usb转ttl硬件有问题，驱动没有安装成功，导致识别不了硬件）
第六步： 用万用表量P0^0口，查看电压是否1秒一次变化即可。

3，蓝牙模块工作篇
从某宝上花了17大洋买了一个HC05蓝牙主从模块，有6个引脚(VCC,GND,TX,RX,AT,STATUS)，前4个引脚与usb转ttl的接法相同(注意RX，TX交叉接线接入到单片机)，AT和STatus引脚是我自己命的名字。 AT引脚高电平有效，用于蓝牙模块进入AT状态(所谓AT状态，即是其他程序可以通过它的引脚向蓝牙模块发送AT控制命令，例如设置波特率，查看版本号，设置主从模式)，AT引脚悬空默认为低电平。Status引脚用于显示配对的状态(配对成功输出高电平，未配对输出低电平)

蓝牙模块测试篇：
第一步：蓝牙模块既然包含串口，那么它应该可以跟usb转ttl直接连接，使用电脑向蓝牙模块发送命令。于是连接蓝牙模块与usb转ttl的对应引脚。
第二步：将AT引脚悬空，使用手机搜索周围的蓝牙设备，发现有HC05的蓝牙(因为这个蓝牙模块默认是从模块，可以被收到)
第三步：将AT引脚拉高电平，使其进入AT状态(按照文档描述，如果上电之后再置位AT，指示灯无变化，依旧是，如果上电之前拉高AT，指示灯转为1秒一次)，然后通过电脑串口发送AT+VERSION?(注意需要换行)查看版本号，使用AT+UART?查看波特率（默认9600，不带校验）
此文档有用： ATK-HC05-V11用户手册_V1.0.pdf
第四步：实验了一下，我的模块有问题，就是上电之前拉高AT，模块不接受AT命令，只有上电后拉高AT才有用，不过不影响使用。
第五步：将蓝牙模块和usb转ttl连接后，AT保持悬空，即蓝牙模块为从模块，手机安装蓝牙串口助手，打开手机蓝牙，然后搜索HC05，配对，然后打开手机端的蓝牙串口助手软件，向HC05发送消息，如果蓝牙模块工作正常，那么电脑端的串口调试助手应该收到手机发送的消息。同样的也可以通过电脑端发送消息，到手机端。
消息传递流程如下： 手机端蓝牙串口助手 -> 手机蓝牙 ->空气  -> HC05蓝牙模块 -> USB转ttl模块 -> 电脑的串口调试助手，反过来也是可行的(注意线路连接方式都是RX与TX交叉连接)

蓝牙模块与单片机集成调试篇：
上面的测试已经证明了蓝牙模块是可以发送接收手机端消息的，现在开始将蓝牙模块与单片机的TX，RX接口连接起来，通过程序控制蓝牙模块与手机蓝牙进行沟通，从而达到利用手机蓝牙进行遥控的目的。

main函数如下，主要设置串口波特率，以及开启串口中断
//PCON:SMOD位默认为0，串行口波特率加倍位
PCON = 0x80;                //SMOD=1;

TMOD=0x20;          //8位自动加载计数器
//TH1=0xfd;  TL1=0xfd;   for 11.0592MHZ and SMOD=0, 
TH1 = 0xf3;//2400bps
TL1 = 0xf3;
TR1=1;    // T1
//SCON: 0x50=SM0=0, SM1=1,REN=1
REN=1;   
SM0=0;
SM1=1; //串口
EA=1; //中断
ES=1; 

串口中断函数
void serial() interrupt 4
{
         char sbuf;
         sbuf=SBUF;
         switch (sbuf)
         {
                 case 'f': direc=4; break;
                 case 'b': direc=5; break;
                 case 'l': direc=6; break;
                 case 'r': direc=7; break;
                 case 's': direc=-1; break;
                 default : LED = !LED; //LED为一个I/O引脚，控制发光二极管
         }
         RI=0;
} 

遇到的问题：
利用手机给蓝牙HC05发送消息，如果不是switch中的几个case的话，那么LED灯会明暗变化，但是刚开始的测试却始终不如意。而后仔细查看了代码，并没有发现什么错误，后来怀疑是波特率的问题，因为我的晶振是6Mhz的，蓝牙模块的波特率是9600. 我手动计算了一下：
采用波特率倍频，那么计算如下 6*1000000*2 / 12 / 32 / 9600 = 3.255， 取整为3. 然后使用3反代入到此式子中
6*1000000*2 / 12 / 32 /3 = 10416.7 与9600相差1000多，这个似乎差距太大了。我又尝试了其他几个参数，像4800,19200,38400都相差挺大的，估计就是这个原因。于是继续尝试，发现2400的话，相差不多。6*1000000*2/12/32/2400
 = 13.02 ，然后使用13代入进去结果为2403.8，与2400的波特率相差很小，估计是可以用的。但是看蓝牙模块的文档，发现它说不支持2400的，我不甘心，就使用usb转ttl模块设置了一下2400，没想到AT命令还真的返回OK了，单片机程序也可以正常工作了。


4，小车驱动篇：
将两个L298N模块与单片机的P2口直接相连（小车4轮驱动，每个电机需要两个输入引脚，以及一个使能引脚，那就是12个引脚，我刚开始并不想支持调速的功能，因此使能引脚直接高电平了，就连接了8个I/O口）。注意L298N的GND引脚一定要和单片机的GND共地。

关于L298N： 它的EN引脚用于使能，EN为高电平，才使能。另外两个输入引脚IN1,IN2根据电平的组合变化会有4种情况(00,10,01,11)，电机相应的在00和11停止(这个停止是带电的，类似于锁死的感觉)，在10正转，01反转。可以直接使用单片机的VCC和GND连接L298N的IN1和IN2，同时将EN端接VCC，看电机转不转就可以测试L298N模块了。

编写程序，控制轮子的正转，翻转，停止等。基本上就是以下的这种代码
void wheelForward(uchar which)
{
        switch(which)
        {
                case 1:
                {        
                        wheel_1_1 = 0;
                        wheel_1_2 = 1;
                        break;
                }
                case 2:
                {
                        wheel_2_1 = 0;
                        wheel_2_2 = 1;
                        break;
                }
                case 3:
                {
                        wheel_3_1 = 0;
                        wheel_3_2 = 1;
                        break;                
                }
                case 4:
                {
                        wheel_4_1 = 0;
                        wheel_4_2 = 1;
                        break;
                }
        }
}

遇到的问题：
问题1： 刚开始L298N直接连接P0口，死活不转，而直接引出高低电平到某一个电机的IN1，IN2口，电机正常运转。于是猜测是I/O有问题，使用万用表测量，发现P0的I/O在输出高电平的时候，根本不是高电平，而后发了帖子，询问了一下才知道P0口在高电平是呈现高阻态的，需要外部焊接电路加上拉电阻才可工作。我不想焊接过多的电路，就将其I/O换到P2口，可以正常工作
帖子链接地址： http://bbs.elecfans.com/forum.ph
 ... 8&page=1#pid4108114
问题2： 我使用的是路由器的9v直流电源，使用其带动两个L298N，同时将L298N的输出的一个5V高电平接到单片机上给单片机供电，启动4轮驱动，电机只会翁的一声，然后啥也没有，二轮驱动也不转。 上网查看了不少资料，基本上都是电源功率过低，需要将单片机与L298N分别供电才可以。
 于是使用笔记本的usb口给单片机供电，使用9v直流电源给电机供电，比刚才好了一些，两轮可以转，但是4个轮子还是转不了。没办法，想到自己有一个小的卡片相机，有镍氢电池8节，然后上网买了一个电池盒，装上去，电机转的吼吼叫，同时L298N给单片机供电也没问题。
问题3：
关于L298N同时给单片机供电的问题，大家可以在启动轮子转动的时候量一量单片机的电源电压，会发现在电机启动的一刹那，单片机的电压有一个瞬时的拉低，这样单片机就会复位了。

5，蓝牙遥控小车汇总篇
第一步：部署小车，L298N，镍氢电池盒，蓝牙模块组装到一起
第二步：编写代码，本来可以使用EN口进行调速控制的，但是考虑到还需要使用额外的I/O口，就先不打算做了。
代码完成的功能：
小车前进，后退，停止，左转，右转
小车单个轮子的转动(用于测试)
小车当前状态的获取(用于后期给小车增加其他模块的时候，例如温度模块，就可以读取温度了)
小车命令帮助

代码思路：
首先完成单个轮子的控制
再完成小车的控制
再加入串口接收中断，收到不同命令，设置方向变量
main程序读取方向变量控制不同的方向

6，思路篇
一些比较有特点的思路：
思路1：一个棘手的问题想实现这样的功能：
 用户按键，小车才走，用户松开按键，小车停止。
我的想法如下： 小车使用一个定时器T0，控制定时器的延时时间为100ms，用户每发送一个前进信号，小车会前进100ms，但是这100ms内小车还需要能够响应外部的命令。例如如果用户在t=0ms发送前进命令，然后在t=50ms发送左转命令，小车能够立刻左转，而不是继续前进100ms，然后才执行左转的命令。基本的代码思路是用户的每一个命令，都会重置timer0，timer0的超时中断函数会将小车停止。这样用户只要以连续的小于100ms间隔发送前进命令，小车就会一直前进，也就是说timer0的中断没有执行，如果用户间隔100ms还没有发送命令，那么小车停止。
 当前我使用的蓝牙串口助手它的按键不支持连续发送，只能按下松开手，才会发送消息，这样我现在就把时间间隔设置为1000ms，用户只要以小于1000ms的间隔连续按键，小车就会一直前进，如果不按键，小车会继续前进1000ms才会停止。 后期打算找到蓝牙串口调试助手的源代码，修改它的源代码，设置成如果用户按下不丢，小车前进命令能够一直发送。
思路2： 既然有了手机蓝牙，那么小车再想展示一些状态信息，就没必要使用像1602,12864之类的东东了，直接定时发给手机蓝牙模块就OK了。我现在并没有实现定时发送，不过支持了命令获取的功能。
 当用户发送命令h到单片机，单片机会返回一个帮助界面，告知如何控制小车，例如"f"控制小车前进，"b"控制小车后退，当用户发送命令i到单片机，单片机会返回小车的一些状态信息，我当前只返回了一些简单的变量状态（后面想加入距离，温度，光敏都是可行的）。
思路3：有了蓝牙，这个小车就可以被我们随心所欲的控制了。你既可以推命令到单片机，控制它，你又可以把单片机内部的当前状态拉出来。单片机本身又可以定期将它的状态向你的手机进行推送。这个我感觉还是很好玩的，有了这个代码的基本框架，后面有可能的话像实现一个小车的扩展功能，加上红外对管让它不撞墙，加上超声波让它测距，加上麦克风让它向着声音跑，加上人体感应让它做一个跟屁虫，甚至于加上一个智能化点的程序，让它能够在一个屋子里随便的转悠，然后记录屋里的情况。还想做的是加入一个wifi模块，能将它的状态信息上传到路由器里面(手里有一个坏的路由器华为hg255d，正在修理中，还没有摸清楚如何修)，这样远在千里之外都可以访问小车上面传感器的情况了。还想加的是一个摄像头模块，不过单片机的处理能力有限，摄像头的解码对它是个大问题，估计很难办到(手头有优龙fs2401开发板，刚修好它的电源模块，正在研究中，不过前天它突然bios引导不起来了，也不知道是什么问题，关于这种arm的东西，还没有接触过，完全不懂刷bios，uboot等等的东西，看情况是要重新刷bios了)。

数控机床的可编程功能分为两类：一类用来实现刀具轨迹控制即各进给轴的运动，如直线/圆弧插补、进给控制、坐标系原点偏置及变换、尺寸单位设定、刀具偏置及补偿等，这一类功能被称为准备功能，以字母G以及两位数字组成，也被称为G代码。另一类功能被称为辅助功能，用来完成程序的执行控制、主轴控制、刀具控制、辅助设备控制等功能。在这些辅助功能中，Tx x用于选刀，Sx x x x用于控制主轴转速。其它功能由以字母M与两位数字组成的M代码来实现。
1. 常用G代码功能
G00     定位（快速移动）
G01     直线插补（进给速度）
G02     顺时针圆弧插补
G03     逆时针圆弧插补
G04     暂停，精确停止
G09     精确停止
G17     选择X Y平面
G18     选择Z X平面
G19     选择Y Z平面
G27     返回并检查参考点
G28     返回参考点
G29     从参考点返回
G30     返回第二参考点
G40     取消刀具半径补偿
G41     左侧刀具半径补偿
G42     右侧刀具半径补偿
G43     刀具长度补偿＋
G44     刀具长度补偿－
G49     取消刀具长度补偿
G52     设置局部坐标系
G53     选择机床坐标系
G54     选用1号工件坐标系
G55     选用2号工件坐标系
G56     选用3号工件坐标系
G57     选用4号工件坐标系
G58     选用5号工件坐标系
G59     选用6号工件坐标系
G60     单一方向定位
G61     精确停止方式
G64     切削方式
G65     宏程序调用
G66     模态宏程序调用
G67     模态宏程序调用取消
G73     深孔钻削固定循环
G74     反螺纹攻丝固定循环
G76     精镗固定循环
G80     取消固定循环
G81     钻削固定循环
G82     钻削固定循环
G83     深孔钻削固定循环
G84     攻丝固定循环
G85     镗削固定循环
G86     镗削固定循环
G87     反镗固定循环
G88     镗削固定循环
G89     镗削固定循环
G90     绝对值指令方式
G91     增量值指令方式
G92     工件零点设定
G98     固定循环返回初始点
G99     固定循环返回R点
2. 常用M代码功能
M00     程序暂停
M01     条件程序停止
M02     程序结束
M03     主轴正转
M04     主轴反转
M05     主轴停止
M06     刀具交换
M08     冷却开
M09     冷却关
M18     主轴定向解除
M19     主轴定向
M29     刚性攻丝
M30     程序结束并返回程序头
M98     调用子程序
M99     子程序结束返回／重复执行
3. 常用算术
加法：#i=#j+#k
减法：#i=#j-#k
乘法：#i=#j*#k
除法：#i=#j/#k
正弦：#i=SIN[#j]
反正弦：#i=ASIN[#j]
余弦：#i=COS[#j]
反余弦：#i=ACOS[#j]
正切：#i=TAN[#j]
反正切：#i=ATAN[#j]
平方根：#i＝SQRT[#j]
绝对值：#i＝ABS[#j]
舍入：#i＝ROUND[#j]
上取整：#i＝FIX[#j]
下取整：#i＝FUP[#j]
自然对数：#i＝LN[#j]
指数函数：#i＝EXP[#j]
或：#i＝#jOR#k
异或：#i＝#jXOR#k
与：#i＝#AND#k
从BCD转为BIN：#i＝BIN[#j]
从BIN转为BCD：#i＝BCD[#j]
4. 逻辑运算符
EQ：等于
NE：不等于
GT：大于
GE：大于或等于
LT：小于
LE：小于或等于
5. 程序转移和循环
无条件转移：GOTO
条件转移：IF [条件表达式]
IF [条件表达式] GOTO n，如果条件同行群：528550242满足，则跳转至程序段n
IF [条件表达式] THEN，如：IF [#I=#J] THEN #K=0
6. 循环语句
WHILE [条件表达式] Dom (m=1,2,,3)
…
ENDm
如果条件满足则执行Dom至ENDm之间的程序(直到条件不满足)，否则转而执行ENDm后面的程序。