自制<<手把手教你学单片机C程序设计>>实验板

只看该作者 · 2010-5-2 21:34

第九章
数**算与显示实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
void delay(uint k);
void main(void)
{
  uchar a,b,c,out;
  a=100;
  b=60;
  c=9;
  out=a+3*(b-c)/2;
  while(1)
{
   P0=SEG7[out/100];
P2=0xfb;
delay(1);
//==================
P0=SEG7[(out%100)/10];
P2=0xfd;
delay(1);
//==================
P0=SEG7[out%10];
P2=0xfe;
delay(1);
}
}
//=================================
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}

只看该作者 · 2010-5-2 21:35

输入数的大小比较及判断实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//======================================================
uchar a=0,b=0,c;
//---------------------------------------------------------------------
uchar key_S1(void);
uchar key_S2(void);
void delay(uint k);
//---------------------------------------------------------------------
void main(void)
{
uchar i;
while(1)
  {
  b=key_S1();
a=key_S2();
if(a>b)c=0x76;
if(a<b)c=0x38;
if(a==b)c=0x09;
   for(i=0;i<50;i++)
   {
   P0=SEG7[a];
P2=0xfd;
      delay(2);
      //==================
      P0=SEG7;
      P2=0xfe;
      delay(2);
      //==================
      P0=c;
      P2=0xf7;
      delay(2);
}
}
}
//------------------------------------
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
uchar key_S1(void)
{
static uchar x;
P3=0xff;
if(P3!=0xff)
  {
delay(10);
  if(P3==0xfb)
{
x=x+1;
}
  }
if(x>9)x=0;
return x;
}
//----------------------------------
uchar key_S2(void)
{
static uchar y;
P3=0xff;
if(P3!=0xff)
  {
delay(10);
  if(P3==0xf7)
{
y=y+1;
}
  }
if(y>9)y=0;
return y;
}

只看该作者 · 2010-5-2 21:37

逻辑判断实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
sbit P3_2=P3^2;
sbit P3_3=P3^3;
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//======================================================
uchar data a=0,b=0,out;
//---------------------------------------------------------------------
uchar key_S1(void);
uchar key_S2(void);
void delay(uint k);
//---------------------------------------------------------------------
void main(void)
{
while(1)
  {
b=key_S1();
  a=key_S2();
  if((a==8)&&(b==5))out=1;
  else out=0;
  //----------------------------
  P0=SEG7[a];
  P2=0xfd;
  delay(2);
  //------------------------------
  P0=SEG7;
  P2=0xfe;
  delay(2);
  //-------------------------------
  if(out==1)P0=0x73;
  else P0=0x00;
  P2=0xf7;
  delay(2);
  }
}
//=======================================================
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
uchar key_S1(void)
{
uchar data x;
P3=0xff;
if(!P3_2)x=5;
else x=0;
return x;
}
//----------------------------------
uchar key_S2(void)
{
uchar data y;
P3=0xff;
if(!P3_3)y=8;
else y=0;
return y;
}

只看该作者 · 2010-5-2 21:43

自增运算a++ 和++b 实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//======================================================
//=======================================================
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
void main(void)
{
uchar a=0,b=0,i,dis_a,dis_b;
while(1)
   {
   dis_a=SEG7[a++];
dis_b=SEG7[++b];
for(i=0;i<250;i++)
{
   P0=dis_a;
P2=0xfe;
delay(2);
P0=dis_b;
P2=0xfd;
delay(2);
}
if((a==9)||(b==9))while(1);
   }
}

只看该作者 · 2010-5-2 21:44

两个变量x、y的位运算实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
//======================================================
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
void main(void)
{
  uchar x=57,y=136;
P1=~x;
delay(3000);
P1=~y;
delay(3000);
P1=x&y;
delay(3000);
P1=x|y;
delay(3000);
P1=x^y;
delay(3000);
P1=x<<1;
delay(3000);
P1=y<<2;
delay(3000);
  while(1);
}

只看该作者 · 2010-5-2 21:46

第十章

复合语句实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//======================================================
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
void main(void)
{
uchar m=0,n=0,i;
  for(i=0;i<250;i++)
{
P0=SEG7[n];
  P2=0xfe;
  delay(4);
  //========
  P0=SEG7[m];
  P2=0xfd;
  delay(4);
}
//==========================
{
uchar m=8,x=6;
  for(i=0;i<250;i++)
{
P0=SEG7[n];
  P2=0xfe;
  delay(4);
  //========
  P0=SEG7[m];
  P2=0xfd;
  delay(4);
  //========
  P0=SEG7[x];
  P2=0xfb;
  delay(4);
}
}
//==========================
for(i=0;i<250;i++)
{
P0=SEG7[n];
  P2=0xfe;
  delay(4);
  //========
  P0=SEG7[m];
  P2=0xfd;
  delay(4);
}
P0=0x00;
while(1);
}

只看该作者 · 2010-5-2 21:47

条件语句实验一

#include <reg51.h>
#define uchar unsigned char
#define uint unsigned int
sbit KEY_S1=P3^2;
//======================
void delay(uint k)
{
uint i,j;
for(i=0;i<k;i++)
  {
for(j=0;j<121;j++)
{;}
  }
}
//=====================
void main(void)
{
delay(50);
while(1)
  {
  if(!KEY_S1){P1=0x00;}
else {P1=0xff;}
delay(5);
}
}

只看该作者 · 2010-5-2 21:48

条件语句实验二

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
sbit KEY_S1=P3^2;
sbit KEY_S2=P3^3;
sbit KEY_S3=P3^4;
sbit KEY_S4=P3^5;
//==========================
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//=================================
void main(void)
{
  delay(50);
  while(1)
  {
  if(!KEY_S1){P1=0xfc;}
   else if(!KEY_S2){P1=0xf3;}
else if(!KEY_S3){P1=0xcf;}
else if(!KEY_S4){P1=0x3f;}
   else {P1=0xff;}
delay(5);
}
}

只看该作者 · 2010-5-2 21:50

第11章

switch/case 开关语句实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar ACT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
//----------------------------------------------------------------------
uchar status_flag;
uint year;
uchar month;
uchar day;
uchar temp_year_l,temp_month;
uchar temp_year_h;
//----------------------------------------------------------------------
void key_S1(void);
void key_S2(void);
void key_S4(void);
void delay(uint k);
uchar conv(uint year,uchar month);
//=====================================================
void main(void)
{
uchar i;
uint temp1,temp2;
while(1)
{
  key_S4();
  switch(status_flag)
  {
case 0:key_S1();temp1=temp_year_l;
   key_S2();temp2=temp_year_h;break;
case 1:key_S1();month=temp_month;break;
default:break;
  }
year=temp1=(temp2*100);
//-----------------------------------------------
day=conv(year,month);
//----------------------------------------------
  for(i=0;i<40;i++)
   {
   switch(status_flag)
   {
   case 0:P0=SEG7[year%10];P2=ACT[4];delay(1);
            P0=SEG7[(year%100)/10];P2=ACT[5];delay(1);
      P0=SEG7[(year/100)%10];P2=ACT[6];delay(1);
      P0=SEG7[year/1000];P2=ACT[7];delay(1);break;
   case 1:P0=SEG7[month%10];P2=ACT[2];delay(2);
      P0=SEG7[month/10];P2=ACT[3];delay(2);break;
   case 2:if(day){P0=SEG7[day%10];P2=ACT[0];delay(2);
                  P0=SEG7[day/10];P2=ACT[1];delay(2);}
      else{P0=0x00;P2=0xff;delay(2);
         P0=0x00;P2=0xff;delay(2);}break;
   default:break;
   }
   }
}
}
//===========================================
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
{
for (j=0;j<121;j++)
   {;}
}
}
//----------------------------------------------
void key_S1(void)
{
P3=0xff;
if(P3==0xfb)
{
switch(status_flag)
{
   case 0:temp_year_l++;
      if(temp_year_l>99)temp_year_l=0;break;
  case 1:temp_month++;
      if(temp_month>12)temp_month=1;break;
  default:break;
}
}
}
//------------------------------------------------
void key_S2(void)
{
P3=0xff;
if(P3==0xf7)
{
switch(status_flag)
{
   case 0:temp_year_h++;
      if(temp_year_h>99)temp_year_h=0;break;
  default:break;
}
}
}
//------------------------------------------------
void key_S4(void)
{
P3=0xff;
if(P3==0xdf)status_flag++;
if(status_flag>2)status_flag=0;
}
//-----------------------------------------------
uchar conv(uint year,uchar month)
{
uchar len;
switch(month)
{
  case 1:len=31;break;
  case 3:len=31;break;
  case 5:len=31;break;
  case 7:len=31;break;
  case 8:len=31;break;
  case 10:len=31;break;
  case 12:len=31;break;
  case 4:len=31;break;
  case 6:len=31;break;
  case 9:len=31;break;
  case 11:len=31;break;
  case 2:if(year%4==0&&year%100!=0||year%400==0)len=29;
else len=28;break;
  default:return 0;break;
}
return len;
}

只看该作者 · 2010-5-2 21:52

这个实验的源程序编译可以通过，但是下载到板子以后总是不能正确操作，而且程序本身算法有点让我看不懂。。。。

只看该作者 · 2010-5-2 21:53

while语句实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//=======================================================================
void delay(uint k)
{
uint i,j;
for(i=0;i<k;i++)
  {
for(j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
void main(void)
{
uint s,n;
s=0;
n=1;
while(n<=100)
  {
s=s+n;
n=n+1;
  }
  //-------------------------------
while(1)
  {
P0=SEG7[s%10];P2=0xfe;delay(1);
P0=SEG7[(s%100)/10];P2=0xfd;delay(1);
P0=SEG7[(s/100)%10];P2=0xfb;delay(1);
P0=SEG7[s/1000];P2=0xf7;delay(1);
  }
}

只看该作者 · 2010-5-2 21:54

for语句实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//=======================================================================
void delay(uint k)
{
uint i,j;
for(i=0;i<k;i++)
  {
for(j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
void main(void)
{
uint s,sum;
for(s=50;s<=100;s=s+2)
{sum=sum+s;}
//-------------------------------
while(1)
{
P0=SEG7[sum%10];P2=0xfe;delay(1);
P0=SEG7[(sum%100)/10];P2=0xfd;delay(1);
P0=SEG7[(sum/100)%10];P2=0xfb;delay(1);
P0=SEG7[sum/1000];P2=0xf7;delay(1);
}
}

只看该作者 · 2010-5-2 21:55

break语句实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//=======================================================================
void delay(uint k)
{
uint i,j;
for(i=0;i<k;i++)
  {
for(j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
void main(void)
{
uchar cnt=0;
P0=SEG7[0];P2=0xfe;
delay(4);
while(1)
{
for(cnt=0;cnt<10;cnt++)
   {
   if(cnt>5)break;
P0=SEG7[cnt];P2=0xfe;
delay(1000);
   }
}
}

只看该作者 · 2010-5-2 21:56

continue语句实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//=======================================================================
void delay(uint k)
{
uint i,j;
for(i=0;i<k;i++)
  {
for(j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
void main(void)
{
uchar cnt=0;
P0=SEG7[0];P2=0xfe;
delay(1000);
while(1)
{
for(cnt=0;cnt<10;cnt++)
   {
   if(cnt<5)continue;
P0=SEG7[cnt];P2=0xfe;
delay(1000);
   }
}
}

只看该作者 · 2010-5-2 21:57

第12章

参数传递的函数调用实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
sbit P3_2=P3^2;
uchar number1,number2;
//========================
void swap(uchar x,uchar y);
//========================
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//========================
void main(void)
{
uchar a=3,b=8;
while(1)
{
   if(!P3_2)
   {
      swap(a,b);
P0=SEG7[number1];
P2=0xfd;
delay(1);
//--------------
P0=SEG7[number2];
P2=0xfe;
delay(1);
   }
else
{
   number1=a,number2=b;
P0=SEG7[number1];
P2=0xfd;
delay(1);
//------------------
P0=SEG7[number2];
P2=0xfe;
delay(1);
}
}
}
//==============================
void swap(uchar x,uchar y)
{
number1=y;
number2=x;
}

只看该作者 · 2010-5-2 21:58

三个数大小自动排列实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
//*********************************************************************
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//========================
void main(void)
{
uchar a=3,b=1,c=9;
uchar temp;
//**********************************************
if((c>b)&&(c>a))
  {
  temp=c;
  c=a;
  a=temp;
  }
else if((b>a)&&(b>c))
   {
temp=b;
b=a;
a=temp;
}
//*********************************************
if(c>b)
  {
  temp=c;
   c=b;
  b=temp;
  }
//**********************************************
while(1)
  {
  P0=SEG7[a];
  P2=0xfb;
  delay(1);
  //************************
  P0=SEG7;
  P2=0xfd;
  delay(1);
  //************************
  P0=SEG7[c];
  P2=0xfe;
  delay(1);
  //************************
  }
}

只看该作者 · 2010-5-2 22:00

华氏-摄氏温度转换的仪器实验

#include <REG51.H>
#include <MATH.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7};
//**********************************************************************
sbit P3_2=P3^2;
sbit P3_3=P3^3;
sbit P3_5=P3^5;
int c,f;
int temp;
uchar status;
//************************************************************************
void key_s1(void);
void key_s2(void);
void key_s4(void);
int conv(int fin);
void delay_1ms(void);
//**********************************************************************
void main(void)
{
int temp_f,temp_c;
while(1)
{
  key_s1();
  key_s2();
  key_s4();
  if(status==0)
{
   if(f<0)
   {
      temp_f=abs(f);
   //----------------------------------
      P0=SEG7[temp_f%10];P2=ACT[0];
      delay_1ms();
   //----------------------------------
      P0=SEG7[(temp_f%100)/10];P2=ACT[1];
      delay_1ms();
   //----------------------------------
      P0=SEG7[(temp_f/100)%10];P2=ACT[2];
      delay_1ms();
   //----------------------------------
      P0=0x40;P2=ACT[3];
      delay_1ms();
   }
   else
   {
      P0=SEG7[f%10];P2=ACT[0];
      delay_1ms();
   //----------------------------------
      P0=SEG7[(f%100)/10];P2=ACT[1];
      delay_1ms();
   //----------------------------------
      P0=SEG7[(f/100)%10];P2=ACT[2];
      delay_1ms();
   }
}
  else
{
   c=conv(f);
   if(c<0)
   {
      temp_c=abs(c);
      P0=SEG7[temp_c%10];P2=ACT[0];
      delay_1ms();
  //----------------------------------
      P0=SEG7[(temp_c%100)/10];P2=ACT[1];
      delay_1ms();
  //----------------------------------
      P0=SEG7[(temp_c/100)%10];P2=ACT[2];
      delay_1ms();
  //----------------------------------
      P0=0x40;P2=ACT[3];
      delay_1ms();
   }
   else
   {
      P0=SEG7[c%10];P2=ACT[0];
      delay_1ms();
  //-----------------------------------
      P0=SEG7[(c%100)/10];P2=ACT[1];
      delay_1ms();
  //-----------------------------------
      P0=SEG7[(c/100)%10];P2=ACT[2];
      delay_1ms();
   }
}
  }
}
//***************************************
void key_s1(void)
{
if(!P3_2)
  {
  if(temp>50)temp=0;
if(temp==0)f++;
if(f>999)f=999;
temp++;
  }
}
//************************************
void key_s2(void)
{
if(!P3_3)
  {
  if(temp>50)temp=0;
if(temp==0)f--;
if(f<-500)f=-500;
temp++;
  }
}
//************************************
void key_s4(void)
{
if(!P3_5)status=1;
else status=0;
}
//************************************
int conv(int fin)
{
int ddata;
ddata=fin-32;
ddata=(ddata*5)/9;
return ddata;
}
//***********************************
void delay_1ms(void)
{
uint k;
for(k=0;k<121;k++);
}

只看该作者 · 2010-5-2 22:02

第13章

数组显示实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7};
uchar data shuzu[4];
//-------------------------------------------------------------------
uchar status;
uchar temp,f;
//-------------------------------------------------------------------
void delay_1ms(void)
{
uint k;
for(k=0;k<121;k++);
}
//--------------------------------------------------------------------
void dis_all(void)
{
P0=SEG7[shuzu[0]];P2=ACT[0];
delay_1ms();
P0=SEG7[shuzu[1]];P2=ACT[1];
delay_1ms();
P0=SEG7[shuzu[2]];P2=ACT[2];
delay_1ms();
P0=SEG7[shuzu[3]];P2=ACT[3];
delay_1ms();
}
//---------------------------------------------------------------------
void dis_shuzu0(void)
{
P0=SEG7[f];P2=ACT[0];
delay_1ms();
}
//--------------------------------------------------------------------
void dis_shuzu1(void)
{
P0=SEG7[f];P2=ACT[1];
delay_1ms();
}
//--------------------------------------------------------------------
void dis_shuzu2(void)
{
P0=SEG7[f];P2=ACT[2];
delay_1ms();
}
//--------------------------------------------------------------------
void dis_shuzu3(void)
{
P0=SEG7[f];P2=ACT[3];
delay_1ms();
}
//--------------------------------------------------------------------
void key_s1(void)
{
P3=0xff;
if(P3==0xfb)
  {
if(temp>50)temp=0;
  if(temp==0)f++;
  if(f>9)f=0;
  temp++;
  delay_1ms();
  }
}
//---------------------------------------------------------------------
void key_s2(void)
{
P3=0xff;
if(P3==0xf7)
  {
switch(status)
{
   case 1:shuzu[0]=f;break;
case 2:shuzu[1]=f;break;
case 3:shuzu[2]=f;break;
case 4:shuzu[3]=f;break;
default:break;
}
  }
}
//---------------------------------------------------------------------
void key_s4(void)
{
P3=0xff;
if(P3==0xdf)
  {
if(temp>50)temp=0;
  if(temp==0)status++;
  if(status>4)status=0;
  temp++;
  delay_1ms();
  }
}
//======================================================
void main()
{
while(1)
  {
key_s1();
  key_s2();
  key_s4();
  switch(status)
{
case 0:dis_all();break;
case 1:dis_shuzu0();break;
case 2:dis_shuzu1();break;
case 3:dis_shuzu2();break;
case 4:dis_shuzu3();break;
default:break;
}
  }
}

只看该作者 · 2010-5-2 22:04

输入10个整数（0~999之间），输出其中的最大数实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar code ACT[5]={0xfe,0xfd,0xfb,0xf7,0xef};
uint data shuzu[10];
//-------------------------------------------------------------------
uchar status;
uchar temp;
int max,f;
//-------------------------------------------------------------------
void delay_1ms(void)
{
uint k;
for(k=0;k<121;k++);
}
//------------------------------------------------------------------
void dis_max(void)
{
P0=SEG7[max%10];P2=ACT[0];
delay_1ms();
P0=SEG7[(max/10)%10];P2=ACT[1];
delay_1ms();
P0=SEG7[max/100];P2=ACT[2];
delay_1ms();
}
//------------------------------------------------------------------
void dis_input(void)
{
P0=SEG7[f%10];P2=ACT[0];
delay_1ms();
P0=SEG7[(f/10)%10];P2=ACT[1];
delay_1ms();
P0=SEG7[f/100];P2=ACT[2];
delay_1ms();
P0=SEG7[status];P2=ACT[4];
delay_1ms();
}
//-------------------------------------------------------------------
void key_s1(void)
{
P3=0xff;
if(P3==0xfb)
{
  if(temp>30)temp=0;
  if(temp==0)f++;
  if(f>999)f=999;
  temp++;
  delay_1ms();
  }
}
//----------------------------------------
void key_s2(void)
{
P3=0xff;
if(P3==0xf7)
{
  if(temp>30)temp=0;
  if(temp==0)f--;
  if(f<0)f=0;
  temp++;
  delay_1ms();
  }
}
//-----------------------------------------
void key_s3(void)
{
  P3=0xff;
  if(P3==0xef)
  {
switch(status)
{
case 0:shuzu[0]=f;break;
case 1:shuzu[1]=f;break;
case 2:shuzu[2]=f;break;
case 3:shuzu[3]=f;break;
case 4:shuzu[4]=f;break;
case 5:shuzu[5]=f;break;
case 6:shuzu[6]=f;break;
case 7:shuzu[7]=f;break;
case 8:shuzu[8]=f;break;
case 9:shuzu[9]=f;break;
default:break;
}
  }
}
//--------------------------------------------
void key_s4(void)
{
P3=0xff;
if(P3==0xdf)
{
  if(temp>100)temp=0;
  if(temp==0)status++;
  if(status>10)status=0;
  temp++;
  delay_1ms();
  }
}
//--------------------------------------
void conv(void)
{
uchar i;
max=shuzu[0];
for(i=1;i<10;i++)
{
if(shuzu>max)max=shuzu;
  }
}
//----------------------------------
void main(void)
{
while(1)
{
key_s1();
key_s2();
key_s3();
key_s4();
conv();
if(status==10)dis_max();
else dis_input();
  }
}

只看该作者 · 2010-5-2 22:05

选择法数组排序显示实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
sbit KEY_S1=P3^2;
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar code ACT[5]={0xfe,0xfd,0xfb,0xf7,0xef};
uint data a[10]={23,58,123,54,63,589,888,19,333,220};
//-------------------------------------------------------------------
void delay(uint k)
{
uint i,j;
for (i=0;i<k;i++)
  {
for (j=0;j<121;j++)
   {;}
  }
}
//-----------------------------------
void sort(uint array[],uint n)
{
uint i,j,k,t;
for(i=0;i<n-1;i++)
{
  k=i;
  for(j=i+1;j<n;j++)
   {
   if(array[j]<array[k])k=j;
   }
  t=array[k];
  array[k]=array;
  array=t;
}
}
//-----------------------------------
void dis(uint array[],uint n)
{
uint m,t;
for(m=0;m<n;m++)
{
  for(t=0;t<300;t++)
   {
P0=SEG7[array[m]%10];
P2=ACT[0];
delay(2);
//-------------------------
P0=SEG7[(array[m]/10)%10];
P2=ACT[1];
delay(2);
//-------------------------
P0=SEG7[array[m]/100];
P2=ACT[2];
delay(2);
//-------------------------
P0=SEG7[m];
P2=ACT[4];
delay(2);
//-------------------------
}
}
}
//============================================
void main(void)
{
  while(1)
  {
dis(a,10);
while(KEY_S1);
sort(a,10);
dis(a,10);
while(1);
  }
}