基于某51单片机的四足机器人.docx

基于某51单片机的四足机器人.docx

《基于某51单片机的四足机器人.docx》由会员分享，可在线阅读，更多相关《基于某51单片机的四足机器人.docx（34页珍藏版）》请在冰豆网上搜索。

基于某51单片机的四足机器人

大学期末考试试卷

开/闭卷

开卷

A/B卷

N/A

课程编号

1303270001

1303270002

课程名称

EDA技术与实践〔2〕

学分

2.0

命题人（签字）审题人（签字）2015年10月20日

题号

一

二

三

四

五

六

七

八

九

十

基此题总分

附加题

得分

评卷人

设计考试题目：

完成一个集成电路或集成系统设计项目

根本要求：

2-3位同学一组，完成一个完整的集成电路设计项目或是一个集成系统设计项目。

规格说明：

1.题目自定。

1）集成电路设计项目

i.假设为IC设计项目需要完成IC设计的版图。

ii.假设采用FPGA实现数字集成电路设计，需要进展下板测试。

2）集成系统设计项目，需使用FPGA开发板或嵌入式开发板，完成一个完整的集成系统作品。

3）作品需要课堂现场演示，最后提交报告，每个小组单独一份报告，但需阐述各个成员的工作。

2.评分标准：

评价

好

较好

一般

未完成

完成度

40

30

25

15

演示效果

30

25

20

15

报告评分

30

25

20

15

2015年第二学期，建议作品容：

∙完成一个行走机器人，根本要求

o2-8只脚

o能行走

o可以用单片机，嵌入式，FPGA方案

一、设计目的：

通过设计一个能够走动的机器人来增加对动手能力，和对硬件电路设计的能力，增强软件流程设计的能力和对设计流程实现电路功能的能力，在各个方面提升自己对电子设计的能力。

二、设计仪器和工具：

本设计是设计一个能走动的机器人，使用到的仪器和工具分别有：

sg90舵机12个、四脚机器人支架一副、单片机最小系统一个、电容电阻假设干、波动开关一个、超声遥控模块一对、杜邦线假设干、充电宝一个。

三、设计原理：

本次设计的机器人是通过51单片机控制器来控制整个电路的。

其中，舵机的控制是通过产生一个周期为20毫秒的高电平带宽在ms之间的pwm信号来控制。

12路Pwm信号由单片机的定时器来产生。

51单片机产生12路pwm信号的原理是：

以20毫秒为周期，把这20毫秒分割成ms，因为，每个pwm信号的高电平时间最多为ms，然后在前六个ms中分别输出两个pwm信号的高电平，例如，在第一个ms中输出第一个和第二个pwm信号的高电平时，首先开始时，把信号S1、S2都置1，然后比拟两个高电平时间，先定时时间短的高电平时间，把高电平时间短的那个信号置0，再定时两个高电平时间差，到时把高电平时间长的按个信号置0，然后，定时-较长那个高电平时间〕，在第二个2.5ms开始时，把S3、S4置1，接下来和上面S1、S2一样，以此类推，在六个ms中输出12路pwm信号来控制舵机。

原理图如图1.

第一个ms

通过超声模块来控制机器人前进、后退、向前的左转、向前的右转、向后的左转、向后的右转几个动作。

控制模块电路，D0,D1，D2,D3分别为超声承受模块的输出，输出为高电平，要加NPN作为开关。

四、设计步骤：

1、设计好硬件电路，焊接51单片机的最小系统和各个硬件电路。

2、设计好软件的流程图，如图2。

3、写产生12路控制舵机的pwm信号的程序并在proteus中测试，如图3。

4、设计出行走步态，四脚机器人的步态是采用对角的相互前进来实现的，如图4。

5、写出流程图中各个模块的软件，包括前进函数、后退函数、左转和

右转的函数，并逐个烧到单片机中测试。

6、按流程图把各个函数组合到主函数中，完成所有软件的编写，并烧到单片机中测试，并不断的调试。

proteus里测试并调试pwm信号

初始状态：

先迈一对脚迈另一对并

另一对支撑身体前进

图4，行走步态

五、遇到的问题与解决：

1、此设计的pwm信号输出使用定时器来产生每个信号的高电平和低电平，每次定时时间到，都会会关掉定时器并执行中断函数，在此过程中会消耗一定的时间，等到给定时器赋值下一次定时时间并开始定时时，就会产生一定的时间延时，造成每次高电平时间都会变长一点，且总的加起来会使20ms周期变长，因此，需要稍微减小高电平的定时时间，并结合proteus仿真确定最准确值。

2、由于机器人的四个脚都是自己组装的，可能会有存在不平衡和对称，当对角的两只脚同时向前迈同一个角度时，会使机器人向一个方向偏转而不沿直线前进，这时要结合实际测试来调整机器人的各个脚的前迈角度来使机器人平衡的沿直线前进，比如，一只脚迈多点，另一边的脚迈少点。

六、心得与体会：

通过这次设计，我更加的熟悉根本的硬件电路和软件的设计，特别是软件的流程图设计。

更加熟悉软硬件电路结合的测试与调试。

六、实验实物图:

设计代码：

#include

#defineucharunsignedchar

#defineuintunsignedint

uintpwm[12],p_min1,p_max1,p_min2,p_max2,p_min3,p_max3,p_min4,p_max4,p_min5,p_max5,

p_min6,p_max6,p1,p2,p3,p4,p5,p6,p11,p21,p31,p41,p51,p61;//高电平带宽

sbits0=P2^0;//12路输出信号

sbits1=P2^1;

sbits2=P2^2;

sbits3=P2^3;

sbits4=P2^4;

sbits5=P2^5;

sbits6=P2^6;

sbits7=P2^7;

sbits8=P0^6;

sbits9=P0^4;

sbits10=P0^2;

sbits11=P0^0;

sbitup=P1^0;

sbitright=P1^4;

sbitleft=P1^2;

sbitdown=P1^6;

uchars_num,f,b,r,l,back_flag;forward_flag;

voidback（）;//后退

voidforward（）;//前进

voidback_right（）;//后右转、前左转

voidback_left（）;//后左转、前右转

voidscan_key（）;//遥控监控

voidlabor_init（）;//机器人的初始状态

voiddelay（uinti）//延时函数，延时一秒

{

uintj;

for（i;i>0;i--）

for（j=110;j>0;j--）;

}

voidinit（void）//中断初始函数

{

TMOD=0x01;

TR0=1;

ET0=1;

EA=1;

}

voidrate（uintp[12]）//pwm的排序函数

{

p_min1=（p[0]<=p[1]?

（p[0]）:

（p[1]））-40;

p_max1=p[0]>p[1]?

（p[0]）:

（p[1]）;

p_min2=（p[2]<=p[3]?

p[2]:

p[3]）-64;

p_max2=p[2]>p[3]?

p[2]:

p[3];

p_min3=（p[4]<=p[5]?

p[4]:

p[5]）-64;

p_max3=p[4]>p[5]?

p[4]:

p[5];

p_min4=（p[6]<=p[7]?

p[6]:

p[7]）-64;

p_max4=p[6]>p[7]?

p[6]:

p[7];

p_min5=（p[8]<=p[9]?

p[8]:

p[9]）-64;

p_max5=p[8]>p[9]?

p[8]:

p[9];

p_min6=（p[10]<=p[11]?

p[10]:

p[11]）-64;

p_max6=p[10]>p[11]?

p[10]:

p[11];

p1=p_max1-p_min1-21;

p2=p_max2-p_min2-42;

p3=p_max3-p_min3-42;

p4=p_max4-p_min4-42;

p5=p_max5-p_min5-42;

p6=p_max6-p_min6-42;

p11=2400-p_max1;

p21=2400-p_max2;

p31=2400-p_max3;

p41=2400-p_max4;

p51=2400-p_max5;

p61=15500-p_max6;

TH0=-p_min1/256;

TL0=-p_min1%256;

s_num=0;

s0=1;

s1=1;

init（）;

}

voidscan_key（）

{

if（P1!

=0xff）

{

delay（5）;

if（up==0）

{

f=0;

}

if（down==0）

b=0;

if（right==0）

r=0;

if（left==0）

l=0;

}

}

voidtime0（）interrupt1//中断产生12路pwm信号

{

TR0=0;

switch（s_num）

{

case0:

if（pwm[0]<=pwm[1]）

{

if（pwm[0]==pwm[1]）

{s0=0;s1=0;s_num++;TH0=-（p1-0）/256;TL0=-（p1-0）%256;break;}

else

s0=0;

}

else

s1=0;

TH0=-p1/256;

TL0=-p1%256;

s_num++;

break;

case1:

if（pwm[0]>pwm[1]）

s0=0;

else

s1=0;

TH0=-p11/256;

TL0=-p11%256;

s_num++;

break;

case2:

s2=1;

s3=1;

TH0=-p_min2/256;

TL0=-p_min2%256;

s_num++;

break;

case3:

if（pwm[2]<=pwm[3]）

{

if（pwm[2]==pwm[3]）

{s2=0;s3=0;s_num++;TH0=-p2/256;TL0=-p2%256;break;}

else

s2=0;

}

else

s3=0;

TH0=-p2/256;

TL0=-p2%256;

s_num++;

break;

case4:

if（pwm[2]>pwm[3]）

s2=0;

else

s3=0;

TH0=-p21/256;

TL0=-p21%256;

s_num++;

break;

case5:

s4=1;

s5=1;

TH0=-p_min3/256;

TL0=-p_min3%256;

s_num++;

break;

case6:

if（pwm[4]<=pwm[5]）

{

if（pwm[4]==pwm[5]）

{s4=0;s5=0;s_num++;TH0=-p3/256;TL0=-p3%256;break;}

else

s4=0;

}

else

s5=0;

TH0=-p3/256;

TL0=-p3%256;

s_num++;

break;

case7:

if（pwm[4]>pwm[5]）

s4=0;

else

s5=0;

TH0=-p31/256;

TL0=-p31%256;

s_num++;

break;

case8:

s6=1;

s7=1;

TH0=-p_min4/256;

TL0=-p_min4%256;

s_num++;

break;

case9:

if（pwm[6]<=pwm[7]）

{

if（pwm[6]==pwm[7]）

{s6=0;s7=0;s_num++;TH0=-p4/256;TL0=-p4%256;break;}

else

s6=0;

}

else

s7=0;

TH0=-p4/256;

TL0=-p4%256;

s_num++;

break;

case10:

if（pwm[6]>pwm[7]）

s6=0;

else

s7=0;

TH0=-p41/256;

TL0=-p41%256;

s_num++;

break;

case11:

s8=1;

s9=1;

TH0=-p_min5/256;

TL0=-p_min5%256;

s_num++;

break;

case12:

if（pwm[8]<=pwm[9]）

{

if（pwm[8]==pwm[9]）

{s8=0;s9=0;s_num++;TH0=-p5/256;TL0=-p5%256;break;}

else

s8=0;

}

else

s9=0;

TH0=-p5/256;

TL0=-p5%256;

s_num++;

break;

case13:

if（pwm[8]>pwm[9]）

s8=0;

else

s9=0;

TH0=-p51/256;

TL0=-p51%256;

s_num++;

break;

case14:

s10=1;

s11=1;

TH0=-p_min6/256;

TL0=-p_min6%256;

s_num++;

break;

case15:

if（pwm[10]<=pwm[11]）

{

if（pwm[10]==pwm[11]）

{s10=0;s11=0;s_num++;TH0=-p6/256;TL0=-p6%256;break;}

else

s10=0;

}

else

s11=0;

TH0=-p6/256;

TL0=-p6%256;

s_num++;

break;

case16:

if（pwm[10]>pwm[11]）

s10=0;

else

s11=0;

TH0=-p61/256;

TL0=-p61%256;

s_num++;

break;

case17:

s0=1;

s1=1;

s_num=0;

TH0=-p_min1/256;

TL0=-p_min1%256;

break;

}

scan_key（）;

TR0=1;

}

{

uchari;

for（i=0;i<12;i++）

pwm[i]=1500;

}

voidlabor_init（）//机器人的初始状态

{

motor_init1（）;

l=1;

f=1;

r=1;

b=1;

back_flag=0;

forward_flag=0;

rate（pwm）;

//delay（200）;

while

（1）

{

if（r==0）

{

r=1;

back_right（）;

}

if（l==0）

{

l=1;

back_left（）;

}

if（f==0）

{

f=1;

forward（）;

}

if（b==0）

{

b=1;

back（）;

}

}

}

voidback（）

{

back_flag=1;

forward_flag=0;

motor_init1（）;

pwm[8]=pwm[8]+300;

pwm[9]=pwm[9]-250;

pwm[2]=pwm[2]+150;

pwm[3]=pwm[3]-150;

pwm[7]=pwm[7]+50;

//pwm[0]=pwm[0]-80;

//pwm[5]=pwm[5]+80;

//pwm[11]=pwm[11]-30;

rate（pwm）;

delay（500）;

pwm[3]=pwm[3]+320;

pwm[8]=pwm[8]-200;

pwm[4]=pwm[4]+600;

pwm[5]=pwm[5]+600;

pwm[6]=pwm[6]+600;

pwm[7]=pwm[7]+600;

rate（pwm）;

delay（300）;

pwm[4]=pwm[4]-600;

pwm[5]=pwm[5]-600;

pwm[6]=pwm[6]-600;

pwm[7]=pwm[7]-600;

rate（pwm）;

delay（300）;

while

（1）

{

if（r==0）

{

r=1;

back_right（）;

}

if（l==0）

{

l=1;

back_left（）;

}

if（f==0）

{

f=1;

forward（）;

}

if（b==0）

b=1;

pwm[3]=pwm[3]-320;

pwm[8]=pwm[8]+200;

pwm[2]=pwm[2]-270;

pwm[9]=pwm[9]+320;

pwm[1]=pwm[1]-600;

pwm[0]=pwm[0]-600;

pwm[10]=pwm[10]-600;

pwm[11]=pwm[11]-600;

rate（pwm）;

delay（300）;

pwm[1]=pwm[1]+600;

pwm[0]=pwm[0]+600;

pwm[10]=pwm[10]+600;

pwm[11]=pwm[11]+600;

rate（pwm）;

delay（500）;

pwm[2]=pwm[2]+270;

pwm[9]=pwm[9]-320;

pwm[3]=pwm[3]+320;

pwm[8]=pwm[8]-200;

pwm[4]=pwm[4]+600;

pwm[5]=pwm[5]+600;

pwm[6]=pwm[6]+600;

pwm[7]=pwm[7]+600;

rate（pwm）;

delay（300）;

pwm[4]=pwm[4]-600;

pwm[5]=pwm[5]-600;

pwm[6]=pwm[6]-600;

pwm[7]=pwm[7]-600;

rate（pwm）;

delay（500）;

if（P1!

=0xff）

forward（）;

}

}

voidback_right（）

{

motor_init1（）;

pwm[8]=pwm[8]+50;

pwm[9]=pwm[9]-50;

//pwm[2]=pwm[2]+150;

//pwm[3]=pwm[3]-150;

pwm[7]=pwm[7]+100;

//pwm[0]=pwm[0]-80;

//pwm[5]=pwm[5]+80;

//pwm[11]=pwm[11]-30;

rate（pwm）;

delay（300）;

pwm[3]=pwm[3]-70;

pwm[8]=pwm[8]-70;

pwm[4]=pwm[4]+600;

pwm[5]=pwm[5]+600;

pwm[6]=pwm[6]+600;

pwm[7]=pwm[7]+600;

rate（pwm）;

delay（300）;

pwm[4]=pwm[4]-600;

pwm[5]=pwm[5]-600;

pwm[6]=pwm[6]-600;

pwm[7]=pwm[7]-600;

rate（pwm）;

delay（300）;

while

（1）

{

if（r==0）

{

if（back_flag==1）

{

r=1;

back_right（）;

}

if（forward_flag==1）

{

r=1;

back_left（）;

}

}

if（l==0）

{

if（back_flag==1）

{

l=1;

back_left（）;

}

if（forward_flag==1）

{

l=1;

back_right（）;

}

}

if（f==0）

{

f=1;

forward（）;

}

if（b==0）

{

b=1;

back（）;

}

pwm[3]=pwm[3]+70;

pwm[8]=pwm[8]+70;

pwm[2]=pwm[2]-70;

pwm[9]=pwm[9]-70;

pwm[1]=pwm[1]-600;

pwm[0]=pwm[0]-600;

pwm[10]=pwm[10]-600;

pwm[11]=pwm[11]-600;

rate（pwm）;

delay（300）;

pwm[1]=pwm[1]+600;

pwm[0]=pwm[0]+600;

pwm[10]=pwm[10]+600;

pwm[11]=pwm[11]+600;

rate（pwm）;

delay（500）;

pwm[2]=pwm[2]+70;

pwm[9]=pwm[9]+70;

pwm[3]=pwm[3]-70;

pwm[8]=pwm[8]-70;

pwm[4]=pwm[4]+600;

pwm[5]=pwm[5]+600;

pwm[6]=pwm[6]+600;