初学51单片机之点阵LED、数组、变量

于 2024-05-06 22:45:52 发布
阅读量1.2k 收藏 25
点赞数 19
文章标签： 51单片机 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/firewood2024/article/details/138470310
版权
数组的基本定义

1：具有相同的数据类型。

2：具有相同的名字。

3：在存储器中是被连续存放的

数组的初始化

数据类型 数组名[数组长度] = [初值列表]

举例：unsigned char LedChar[8] ={0xF7,0xF6,0xB6,0xB6,0xB6,0xB6,0x80,0xFF,}

1:初值列表里的数据之间要用逗号隔开，最后一个逗号可以取消

2：初值列表里的初值数量必须等于或者小于数组长度，当小于数组长度时，数组的后面没有赋值的元素由系统自动赋值为0.

3：若给数组的所有元素都赋初值，可以省略数组的长度

上例可写成unsigned char LedChar[] ={0xF7,0xF6,0xB6,0xB6,0xB6,0xB6,0x80,0xFF};

4：系统为数组分配连续的存储单元的时候，数组元素的相对次序由下标来决定，就是LedChar[0]

LedChar[1]......LedChar[7],按照顺序依次排下来的，注意第1位下标是从0开始的最后一位的下标是数组长度减1，如上述最后一位数0xFF的定位是 LedChar[7]

对于数组LedChar[],如果没加code关键字，这个数组里的数据是既可读也可写的，即

它可以是a = LedChar[0]这是把数组的第一个元素赋值给a这个变量，也可以写成 LedChar[0] = a;

把a这个变量的值送给数组中的第一个元素，即数组现在的值是

LedChar[] = {a,0xF6,0xB6,0xB6,0xB6,0xB6,0x80,0xFF,};

即可读可写，如果加上code关键字

unsigned char code LedChar[] ={0xF7,0xF6,0xB6,0xB6,0xB6,0xB6,0x80,0xFF} ;这个数组就只能读取不能写入了。

二维数组的声明方式是：

数组类型 数组名[数组长度1][数组长度2] ；

与一维数组类似，数据类型是全体元素的数据类型，数组名是标识符，数组长度1和数组长度2分别代表数组具有的行数和列数，数组元素的下表一律从0开始。例如

unsigned char LedChar[2][4] 声明一个2行4列的无符号字符型的二维数组。

则unsigned char LedChar[2][4] = { {0xF7,0xF6,0xB6,0xB6 },

                                                       {0xB6,0xB6,0x80,0xFF}

                                                      };

二维数组的元素总个数是两个长度的乘积，二维数组在内存中存储的时候，采用行优先的方式来存储，即在内存中先存放第0行的元素，再存放第一行的元素......，同一行中再按照顺序存放。

物理存储结构；LedChar[0][0]   LedChar[0][1]   LedChar[0][2]   LedChar[0][3   LedChar[1][0]   LedChar[1][1]   LedChar[1][2]   LedChar[1][3]

变量的作用域

所谓的作用域就是指变量起作用的范围，也是变量的有效范围，变量按照作用域可以分为局部变量和全局变量

1：局部变量是在一个函数内声明的变量。它只在本函数内有效，在本函数外不起作用。

2； 全局变量是在函数外声明的变量，一个源程序文件可以包含一个或者多个函数，全局变量的作用范围是从它开始声明的位置一直到程序结束。

     1：全局变量可以被作用域内所有的函数直接引用

     2：全局变量的应用会降低函数的通用性，函数在执行的时候过多依赖全局变量不利于函数的重复利用

     3：过多的使用全局变量会降低程序的清晰度，使程序的可读性下降，在各个函数执行的时候都有可能改变全局变量的值，往往难以清楚的判断出每个时刻各个全局变量的值

    4：定义全局变量会永久占用单片机的内存单元，而局部变量只有进入定义局部变量的函数时才会占用内存空间，函数退出后会自动释放所占用的内存。

      变量的储存类别分别为自动，静态，寄存器和外部4种

函数中的局部变量如果不加static这个关键字来修饰都属于自动变量，也叫动态储存变量。动态变量的关键字是auto，但是这个关键字是可以省略的，所有平时都不写。

 与动态变量对应的就是静态变量。首先，全局变量均是静态变量。此外还有一种特殊的局部变量也是静态变量。即在定义局部变量时在前边加上static这个关键字，加上这个关键字的变量就称之为静态局部变量。

      它的特点，在整个生存中只赋一次初值，在第一次执行函数时，它的值就是给定的初值，而之后在该函数所有的执行次数中，它的值都是上一次函数执行结束后的值，即它可以保持前次的执行结果。 通俗的将就是类似语句static unsigned char i = 0;不管多少次进入函数该句只执行一次，下次进入函数，该句就不在执行了，即不会再把0赋值给i。

点阵的认识

该图是本案使用的8x8点阵LED。

一个数码管是8个LED组成，同理，1个8x8的点阵就是由64个LED小灯组成的。

图示1

图示2

图示3

图示4

图示是本案的原理图

          首先点亮点阵LED左上角的LED。如图从原理图上来看 若想实现该现象，我们需要图示1的 DB0输出低电平 LEDC0也为低电平，从原理图上看点阵LED的限流电阻是图4所示的330R电阻，通过双向缓冲器74HC25和单片机相连。这里不直接接到单片机是因为51单片机的IO口承受电流不能超过50ma，单个IO口的电流不要超过6ma。 

通过电路图计算一下IO的电流，供电电压是5V，途径过三极管Q10的CE端和点阵LED本身的压降，Q10工作在饱和状态几乎没有压降，点阵LED的压降在1.8-2.2V作用，假设限流电压R18两端的压降是3V则电流是9ma，8个IO口则是72ma。超出了单片机IO能承受的范围。因此接入一个双向缓冲器74HC25让电流流入缓冲器而不是单片机，看图示4，DIR1脚是高电平，OE19脚是低电平，通过数据手册

可以看出B端的输出电压由A端控制，A端连着单片机P0口，P0口的输出电压则和74Hc25的B端的电压一致。因此 使P0^0 = 0；可使LED阴极接低电平。

若使图1 LEDC0输出低电平其他位为高电平，则需要图2 U4第15脚Y0输出低电平，Y1-Y7输出高电平。这边原理图有点小瑕疵，看图原理图上ADDR0-ADDR3和p1.0-p1.3端口它们没有标识是连在一起的。

，事实上ADDR0和端口P1.0  ，ADDR1和P1.1，ADDR2和p1.2，ADDR3和P1.3是相连的。可以看出ENLED是p1.4端口。

由74Hc18的数据手册可知

U4     A=A0=ADDR0=p1.0      B=A1=ADDR1=p1.1  C=A2=ADDR2=p1.2 G1 =E3接5V电压高电平

 G2A=E1=ADDR3=p1.3  G2B=E2=ENLED=p1.4  G2A、G2B接低电平使能。

如果要想使U4工作并且使Y0输出低电平其他输出高电平则需要，

ADDR0 = 0；ADDR1 = 0； ADDR2 = 0；ADDR3 = 0；ENLED = 0；

则程序为

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1; 
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED = P0^0;

void main()
{
   ENLED = 0;
	 ADDR3 = 0;
	 ADDR2 = 0;
	 ADDR1 = 0;
	 ADDR0 = 0;
	LED = 0;
	while(1);

}

现象为成功点亮左上角的电压。

如果要点亮第一排的电压的话则只需要把P0端口的电压都置为低电平即可。

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1; 
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED = P0^0;

void main()
{
   ENLED = 0;
	 ADDR3 = 0;
	 ADDR2 = 0;
	 ADDR1 = 0;
	 ADDR0 = 0;
	P0 = 0x00;
	while(1);

}

。

假使点亮左起第一行1.3.5.7LED如何操作

因为低电平有效若实现目标则必须使点阵相应LED的位置的电压为 01010101，从原理图上来看8个LED从左到右是DB0-DB7分是按照循序依次排列的，但是二进制左边是高位，上述01010101高位0是P0.0口因此这个二进制要反一下是10101010=0xAA才符合我们的电路。看程序

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1; 
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED = P0^0;

void main()
{
   ENLED = 0;
	 ADDR3 = 0;
	 ADDR2 = 0;
	 ADDR1 = 0;
	 ADDR0 = 0;
	P0 = 0xAA;
	while(1);

}

如果我们要在点阵LED上画一些复杂的图片则需要字模软件的帮忙。

针对本案原理图图字模软件的设置是

从上述的例子可以看出要把字节倒序打上勾，然后是横向取模。因为只有横向的8个位置可以被一个值（P0的值）表示。纵向的涉及38译码器无法设置一个值就能控制纵向的通断。

实现1个山字的显示

通过取模软件取一个不标准的山字0xF7,0xF6,0xB6,0xB6,0xB6,0xB6,0x80,0xFF,

本案是横向取模可以看到要想第1行显示正确，加上是低电平有效因此它的值是11101111取反11110111=0xF7,为数组的第一个元素，可见确实是符合本电路的取值。

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

unsigned char code image[] = {
	0xF7,0xF6,0xB6,0xB6,0xB6,0xB6,0x80,0xFF,
	};	
void main()
{
	EA = 1;
	ENLED = 0;
	ADDR3 = 0;
	TMOD = 0x01;
	TH0 = 0xFC;
	TL0 = 0x67;
	ET0 = 1;
	TR0 = 1;
	while(1);
}

void InterruptTimer0() interrupt 1
{
	static unsigned char i = 0;
	TH0 = 0xFC;
	TL0 = 0x67;

	P0 = 0xFF;
	switch(i)
	{
		case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=image[0];break;
		case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=image[1];break;
		case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=image[2];break;
		case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=image[3];break;
		case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=image[4];break;
		case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=image[5];break;
		case 6: ADDR2=1; ADDR1=1; ADDR0=0; i++; P0=image[6];break;
		case 7: ADDR2=1; ADDR1=1; ADDR0=1; i=0; P0=image[7];break;
		default: break;

	}

}

显示一个山字

实现山字上下翻转

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1; 
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED = P0^0;

unsigned char code image[] = {0xF7,0xF6,0xB6,0xB6,0xB6,0xB6,0x80,0xFF,
};

void main()
{
  EA = 1;  //中断使能（启动中断）
  ENLED = 0;  //38译码器U4使能
  ADDR3 = 0; //38译码器U4使能
  TMOD = 0x01; //定时器工作在模式1
  TH0 = 0xFC;  //定时器0赋值 定时1ms
  TL0 = 0x67;	
	ET0 = 1;    //定时器0中断使能（启动T0中断）
	TR0 = 1;   // 定时器0使能（启动T0）
	while(1);
	
}

void TtrTimer0 () interrupt 1
{
   static unsigned char i = 0;
	 TH0 = 0xFC;  //定时器0重新赋值
	 TL0 = 0x67;
	
	 P0 = 0xFF;  //消除鬼影
	 switch(i)
	 {
		 case 7: ADDR2 = 0; ADDR1 = 0; ADDR0 = 0; i = 0; P0 = image[7]; break;   //上下扫描
		 case 6: ADDR2 = 0; ADDR1 = 0; ADDR0 = 1; i++; P0 = image[6]; break;
		 case 5: ADDR2 = 0; ADDR1 = 1; ADDR0 = 0; i++; P0 = image[5]; break;
		 case 4: ADDR2 = 0; ADDR1 = 1; ADDR0 = 1; i++; P0 = image[4]; break;
		 case 3: ADDR2 = 1; ADDR1 = 0; ADDR0 = 0; i++; P0 = image[3]; break;
		 case 2: ADDR2 = 1; ADDR1 = 0; ADDR0 = 1; i++; P0 = image[2]; break;
		 case 1: ADDR2 = 1; ADDR1 = 1; ADDR0 = 0; i++; P0 = image[1]; break;
		 case 0: ADDR2 = 1; ADDR1 = 1; ADDR0 = 1; i++; P0 = image[0]; break;
		 default: break;
     		 
	 
	 
	 
	 }
 

}

通过改变switch语句的扫描方式 数码管从左起第一行开始扫描变成开始从左起最后一行开始扫描

实现山字左右翻转

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1; 
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED = P0^0;

unsigned char code image[] = {0xEF,0x6F,0x6D,0x6D,0x6D,0x6D,0x01,0xFF,
};

void main()
{
  EA = 1;  //中断使能（启动中断）
  ENLED = 0;  //38译码器U4使能
  ADDR3 = 0; //38译码器U4使能
  TMOD = 0x01; //定时器工作在模式1
  TH0 = 0xFC;  //定时器0赋值 定时1ms
  TL0 = 0x67;	
	ET0 = 1;    //定时器0中断使能（启动T0中断）
	TR0 = 1;   // 定时器0使能（启动T0）
	while(1);
	
}

void TtrTimer0 () interrupt 1
{
   static unsigned char i = 0;
	 TH0 = 0xFC;  //定时器0重新赋值
	 TL0 = 0x67;
	
	 P0 = 0xFF;  //消除鬼影
	 switch(i)
	 {
		 case 7: ADDR2 = 0; ADDR1 = 0; ADDR0 = 0; i = 0; P0 = image[7]; break;   //上下扫描
		 case 6: ADDR2 = 0; ADDR1 = 0; ADDR0 = 1; i++; P0 = image[6]; break;
		 case 5: ADDR2 = 0; ADDR1 = 1; ADDR0 = 0; i++; P0 = image[5]; break;
		 case 4: ADDR2 = 0; ADDR1 = 1; ADDR0 = 1; i++; P0 = image[4]; break;
		 case 3: ADDR2 = 1; ADDR1 = 0; ADDR0 = 0; i++; P0 = image[3]; break;
		 case 2: ADDR2 = 1; ADDR1 = 0; ADDR0 = 1; i++; P0 = image[2]; break;
		 case 1: ADDR2 = 1; ADDR1 = 1; ADDR0 = 0; i++; P0 = image[1]; break;
		 case 0: ADDR2 = 1; ADDR1 = 1; ADDR0 = 1; i++; P0 = image[0]; break;
		 default: break;
     		 
	 
	 
	 
	 }
 

}

0xEF,0x6F,0x6D,0x6D,0x6D,0x6D,0x01,0xFF,

取消选择‘字节倒序’功能，然后重新取值。放入数组

如何实现点阵图片动起来。

1：向上移动的我爱你

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,

0xFF,0x99,0x00,0x00,0x00,0x81,0xC3,0xE7,0xFF,0x99,0x99,0x99,0x99,0x99,0x81,0xC3,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,

往上移动的我爱你_哔哩哔哩_bilibili

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

unsigned char code image[] = {
	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,
  0xFF,0x99,0x00,0x00,0x00,0x81,0xC3,0xE7,
	0xFF,0x99,0x99,0x99,0x99,0x99,0x81,0xC3,
  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	};	
void main()
{
	EA = 1;
	ENLED = 0;
	ADDR3 = 0;
	TMOD = 0x01;
	TH0 = 0xFC;
	TL0 = 0x67;
	ET0 = 1;
	TR0 = 1;
	while(1);
}

void InterruptTimer0() interrupt 1
{
	static unsigned char i = 0;
	static unsigned char index = 0;
	static unsigned char tmr = 0;
	TH0 = 0xFC;
	TL0 = 0x67;

	P0 = 0xFF;
	switch(i)
	{
		case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=image[index + 0];break;
		case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=image[index + 1];break;
		case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=image[index + 2];break;
		case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=image[index + 3];break;
		case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=image[index + 4];break;
		case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=image[index + 5];break;
		case 6: ADDR2=1; ADDR1=1; ADDR0=0; i++; P0=image[index + 6];break;
		case 7: ADDR2=1; ADDR1=1; ADDR0=1; i=0; P0=image[index + 7];break;
		default: break;
	}

	tmr++;
	if(tmr >= 250)
	{
		tmr = 0;
		index++;
		if(index >= 32)
		{
			index = 0;
		}
	}


}

2：向下移动的我爱你

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,

0xFF,0xE7,0xC3,0x81,0x00,0x00,0x00,0x99,0xFF,0xC3,0x81,0x99,0x99,0x99,0x99,0x99,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,

往下移动的我爱你_哔哩哔哩_bilibili

方式是按照前文山字上下翻转的方式，但是取模的图片需要重新画。，上图上下翻转一下的话是

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1; 
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED = P0^0;

unsigned char code image[] = 
	{ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
		0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,
    0xFF,0xE7,0xC3,0x81,0x00,0x00,0x00,0x99,
		0xFF,0xC3,0x81,0x99,0x99,0x99,0x99,0x99,
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,

};

void main()
{
  EA = 1;  //中断使能（启动中断）
  ENLED = 0;  //38译码器U4使能
  ADDR3 = 0; //38译码器U4使能
  TMOD = 0x01; //定时器工作在模式1
  TH0 = 0xFC;  //定时器0赋值 定时1ms
  TL0 = 0x67;	
	ET0 = 1;    //定时器0中断使能（启动T0中断）
	TR0 = 1;   // 定时器0使能（启动T0）
	while(1);
	
}

void TtrTimer0 () interrupt 1
{
   static unsigned char i = 0;
	 static unsigned char index = 0;
	 static unsigned char tmr = 0;
	 TH0 = 0xFC;  //定时器0重新赋值
	 TL0 = 0x67;
	
	 P0 = 0xFF;  //消除鬼影
	 switch(i)
	 {
		 case 7: ADDR2 = 0; ADDR1 = 0; ADDR0 = 0; i = 0; P0 = image[index+7]; break;   //上下扫描
		 case 6: ADDR2 = 0; ADDR1 = 0; ADDR0 = 1; i++; P0 = image[index+6]; break;
		 case 5: ADDR2 = 0; ADDR1 = 1; ADDR0 = 0; i++; P0 = image[index+5]; break;
		 case 4: ADDR2 = 0; ADDR1 = 1; ADDR0 = 1; i++; P0 = image[index+4]; break;
		 case 3: ADDR2 = 1; ADDR1 = 0; ADDR0 = 0; i++; P0 = image[index+3]; break;
		 case 2: ADDR2 = 1; ADDR1 = 0; ADDR0 = 1; i++; P0 = image[index+2]; break;
		 case 1: ADDR2 = 1; ADDR1 = 1; ADDR0 = 0; i++; P0 = image[index+1]; break;
		 case 0: ADDR2 = 1; ADDR1 = 1; ADDR0 = 1; i++; P0 = image[index+0]; break;
		 default: break;
     }
   tmr++;
		 if(tmr >= 250)
		 {
		   tmr = 0;
			 index++;
			 if(index >= 32)
			 {
			   index = 0;
			 }
		 
		 }

}

3向下移动的我爱你第二种方式

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x99,0x99,0x99,0x99,0x99,0x81,0xC3,0xFF,

0x99,0x00,0x00,0x00,0x81,0xC3,0xE7,0xFF,0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,

0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,

往下移动的我爱你2_哔哩哔哩_bilibili

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1; 
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED = P0^0;

unsigned char code image[] = 
	{ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
		0x99,0x99,0x99,0x99,0x99,0x81,0xC3,0xFF,
    0x99,0x00,0x00,0x00,0x81,0xC3,0xE7,0xFF,
		0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3,
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,

};

void main()
{
  EA = 1;  //中断使能（启动中断）
  ENLED = 0;  //38译码器U4使能
  ADDR3 = 0; //38译码器U4使能
  TMOD = 0x01; //定时器工作在模式1
  TH0 = 0xFC;  //定时器0赋值 定时1ms
  TL0 = 0x67;	
	ET0 = 1;    //定时器0中断使能（启动T0中断）
	TR0 = 1;   // 定时器0使能（启动T0）
	while(1);
	
}

void TtrTimer0 () interrupt 1
{
   static unsigned char i = 0;
	 static unsigned char index = 39;
	 static unsigned char tmr = 0;
	 TH0 = 0xFC;  //定时器0重新赋值
	 TL0 = 0x67;
	
	 P0 = 0xFF;  //消除鬼影
	 switch(i)
	 {
		 case 7: ADDR2 = 0; ADDR1 = 0; ADDR0 = 0; i = 0; P0 = image[index-7]; break;   //上下扫描
		 case 6: ADDR2 = 0; ADDR1 = 0; ADDR0 = 1; i++; P0 = image[index-6]; break;
		 case 5: ADDR2 = 0; ADDR1 = 1; ADDR0 = 0; i++; P0 = image[index-5]; break;
		 case 4: ADDR2 = 0; ADDR1 = 1; ADDR0 = 1; i++; P0 = image[index-4]; break;
		 case 3: ADDR2 = 1; ADDR1 = 0; ADDR0 = 0; i++; P0 = image[index-3]; break;
		 case 2: ADDR2 = 1; ADDR1 = 0; ADDR0 = 1; i++; P0 = image[index-2]; break;
		 case 1: ADDR2 = 1; ADDR1 = 1; ADDR0 = 0; i++; P0 = image[index-1]; break;
		 case 0: ADDR2 = 1; ADDR1 = 1; ADDR0 = 1; i++; P0 = image[index-0]; break;
		 default: break;
     }
   tmr++;
		 if(tmr >= 250)
		 {
		   tmr = 0;
			 index--;
			 if(index <= 8)
			 {
			   index = 39;
			 }
		 
		 }

}

从逻辑上更好理解就是往下移动。

4：左移的我爱你

左移的我爱你实现起来会比较麻烦，硬件电路设计的结果更方便上下移动。左移的我爱你在实方面更直观的表现出类似动画片一样一帧一帧的移动。而且使用了二维数组

往左移动的我爱你_哔哩哔哩_bilibili

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

	unsigned char code image[30][8] = {
    {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},  //动画帧1
	{0xFF,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0x7F},  //动画帧2
	{0xFF,0x3F,0x7F,0x7F,0x7F,0x7F,0x7F,0x3F},  //动画帧3
	{0xFF,0x1F,0x3F,0x3F,0x3F,0x3F,0x3F,0x1F},  //动画帧4
	{0xFF,0x0F,0x9F,0x9F,0x9F,0x9F,0x9F,0x0F},  //动画帧5
    {0xFF,0x87,0xCF,0xCF,0xCF,0xCF,0xCF,0x87},  //动画帧6
    {0xFF,0xC3,0xE7,0xE7,0xE7,0xE7,0xE7,0xC3},  //动画帧7
    {0xFF,0xE1,0x73,0x73,0x73,0xF3,0xF3,0xE1},  //动画帧8
    {0xFF,0x70,0x39,0x39,0x39,0x79,0xF9,0xF0},  //动画帧9
    {0xFF,0x38,0x1C,0x1C,0x1C,0x3C,0x7C,0xF8},  //动画帧10
    {0xFF,0x9C,0x0E,0x0E,0x0E,0x1E,0x3E,0x7C},  //动画帧11
    {0xFF,0xCE,0x07,0x07,0x07,0x0F,0x1F,0x3E},  //动画帧12
    {0xFF,0x67,0x03,0x03,0x03,0x07,0x0F,0x9F},  //动画帧13
    {0xFF,0x33,0x01,0x01,0x01,0x03,0x87,0xCF},  //动画帧14
    {0xFF,0x99,0x00,0x00,0x00,0x81,0xC3,0xE7},  //动画帧15
    {0xFF,0xCC,0x80,0x80,0x80,0xC0,0xE1,0xF3},  //动画帧16
    {0xFF,0xE6,0xC0,0xC0,0xC0,0xE0,0xF0,0xF9},  //动画帧17
    {0xFF,0x73,0x60,0x60,0x60,0x70,0x78,0xFC},  //动画帧18
    {0xFF,0x39,0x30,0x30,0x30,0x38,0x3C,0x7E},  //动画帧19
    {0xFF,0x9C,0x98,0x98,0x98,0x9C,0x1E,0x3F},  //动画帧20
    {0xFF,0xCE,0xCC,0xCC,0xCC,0xCE,0x0F,0x1F},  //动画帧21
    {0xFF,0x67,0x66,0x66,0x66,0x67,0x07,0x0F},  //动画帧22
    {0xFF,0x33,0x33,0x33,0x33,0x33,0x03,0x87},  //动画帧23
    {0xFF,0x99,0x99,0x99,0x99,0x99,0x81,0xC3},  //动画帧24
    {0xFF,0xCC,0xCC,0xCC,0xCC,0xCC,0xC0,0xE1},  //动画帧25
    {0xFF,0xE6,0xE6,0xE6,0xE6,0xE6,0xE0,0xF0},  //动画帧26
    {0xFF,0xF3,0xF3,0xF3,0xF3,0xF3,0xF0,0xF8},  //动画帧27
    {0xFF,0xF9,0xF9,0xF9,0xF9,0xF9,0xF8,0xFC},  //动画帧28
    {0xFF,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFE},  //动画帧29
    {0xFF,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFF}   //动画帧30
};

void main()
{
	EA = 1;
	ENLED = 0;
	ADDR3 = 0;
	TMOD = 0x01;
	TH0 = 0xFC;
	TL0 = 0x67;
	ET0 = 1;
	TR0 = 1;
	while(1);
}

void InterruptTimer0() interrupt 1
{
	static unsigned char i = 0;
	static unsigned char tmr = 0;
	static unsigned char index = 0;

	TH0 = 0xFC;
	TL0 = 0x67;

	P0 = 0xFF;
	switch(i)
	{
		case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=image[index][0]; break;
		case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=image[index][1]; break;
		case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=image[index][2]; break;
		case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=image[index][3]; break;
		case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=image[index][4]; break;
		case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=image[index][5]; break;
		case 6: ADDR2=1; ADDR1=1; ADDR0=0; i++; P0=image[index][6]; break;
		case 7: ADDR2=1; ADDR1=1; ADDR0=1; i=0; P0=image[index][7]; break;
		default: break;
	}

	tmr++;
	if(tmr >= 250)
	{	
		tmr = 0;
		index++;
		if(index >= 30)
		{
			index = 0;
		}
	}

}

5：横向的我爱你

翻转硬件右移的我爱你_哔哩哔哩_bilibili

#include<reg52.h>

sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;

unsigned char code image[] = {
	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0x7D,0x01,0x01,0x7D,0xFF,0xFF,0xE3,0xC1,
  0x81,0x03,0x03,0x81,0xC1,0xE3,0xFF,0xFF,
	0x81,0x01,0x3F,0x3F,0x3F,0x01,0x81,0xFF,
  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	};	
void main()
{
	EA = 1;
	ENLED = 0;
	ADDR3 = 0;
	TMOD = 0x01;
	TH0 = 0xFC;
	TL0 = 0x67;
	ET0 = 1;
	TR0 = 1;
	while(1);
}

void InterruptTimer0() interrupt 1
{
	static unsigned char i = 0;
	static unsigned char index = 0;
	static unsigned char tmr = 0;
	TH0 = 0xFC;
	TL0 = 0x67;

	P0 = 0xFF;
	switch(i)
	{
		case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=image[index + 0];break;
		case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=image[index + 1];break;
		case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=image[index + 2];break;
		case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=image[index + 3];break;
		case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=image[index + 4];break;
		case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=image[index + 5];break;
		case 6: ADDR2=1; ADDR1=1; ADDR0=0; i++; P0=image[index + 6];break;
		case 7: ADDR2=1; ADDR1=1; ADDR0=1; i=0; P0=image[index + 7];break;
		default: break;
	}

	tmr++;
	if(tmr >= 250)
	{
		tmr = 0;
		index++;
		if(index >= 32)
		{
			index = 0;
		}
	}


}

相比用二维数组的方式更倾向在硬件电路上改动，让点阵转个90度放置实现左右移动。

firewood2024
关注
  • 19
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ASC点阵库数组
01-11
包括8*8 8*14 8*16，(6x12,12x24 16x32 20x40 24x48 28x56) 括号中的点阵库只包括可显示字符，在使用时注意查找 -0x20,可用在液晶显示
51单片机接收数组
Tylerco的专栏
08-05 6733
   最近在做一个项目，其中有一模块是需要通过串口使单片机与电脑进行通信，在单片机中我是用C语言进行编程，在应用程序中是用.net编程。其中有一个要求是电脑一次发送十个数据，单片机里定义一个数组，接收这10个数据。可是在进行检验的过程中却发现接收的数据会移位，比如我从电脑中发送的数据是a,b,c,d,e,f,i,j,k,l.那么理论上我在单片机中定义的数组array[10]应该也是array[10]={a,b,c,d,e,f,i,j,k,l.可实际上却不是这样子的，正真接收的数据是array[10]={l,
51单片机（一）：char数组
weixin_66540418的博客
08-20 1866
上述示例中的数组是顺序存储的，即'65'、'66'、'67'和'68'依次存储在myArray[0]、myArray[1]、myArray[2]和myArray[3]中。例如，如果定义了一个char数组`char myArray[4] = { 'A', 'B', 'C', 'D' };`，则在内存中存储为'65'（对应字符'A'的ASCII码）、'66'（'B'的ASCII码）、'67'（'C'的ASCII码）和'68'（'D'的ASCII码）四个字节。char数组可以用来存储一串字符或者一串字节数据。
点阵数组生成(8X8)(16X16).xlsx
07-08
对于8*8以及16*16的点阵数组计算，本表格在输入后可自动生成，省去使用软件计算点阵数组的麻烦，按照提示绘制所需要的点阵即可。
51单片机接收数组知识
08-18
最近在做一个项目，其中有一模块是需要通过串口使单片机与电脑进行通信，在单片机中我是用C语言进行编程，在应用程序中是用.net编程。其中有一个要求是电脑一次发送十个数据，单片机里定义一个数组，接收这10个数据。
LED点阵显示数字_LED点阵_51单片机LED点阵显示数字_
10-04
LED点阵显示数字是51单片机编程中常见的应用场景，尤其在电子设备的界面设计中，用于构建动态显示效果。51单片机作为一款经典的微控制器，因其硬件资源丰富、开发工具成熟且价格适中，常被用作初学者入门学习的平台...
基于51单片机的点阵式led显示控制.doc
07-06
点阵式LED显示控制是电子工程领域中常见的一种技术，特别是在嵌入式系统设计中，如基于51单片机的项目。51单片机是微控制器的一种，由Intel公司的8051系列发展而来，广泛应用于各种控制系统中，因其性价比高、易于...
51单片机实例148-点阵模拟电梯上行下行
07-08
总之，"51单片机实例148-点阵模拟电梯上行下行"是一个实用的教学项目，能够帮助初学者提升对单片机控制和嵌入式系统设计的理解。通过实际操作，学习者可以深入领会到如何将理论知识应用到实际问题中，这对于未来的...
单片机C语言程序设计：8X8LED 点阵显示数字
08-28
在本文中，我们将深入探讨如何使用C语言进行单片机编程，特别是在8X8LED点阵屏上显示数字和图形。这个程序实例展示了如何通过按键控制来改变显示内容，并利用外部中断和定时中断来实现循环显示。 首先，单片机C语言...
基于51单片机Max7219驱动8×8点阵PROTEUS实例(C语言版)
12-04
51单片机的架构简单，内含CPU、RAM、ROM、定时器/计数器、并行I/O口等核心组件，适合初学者入门学习。 【Max7219】是一种集成的串行输入/并行输出LED显示驱动芯片，常用于驱动点阵显示屏。它能够直接与微处理器或微...
汉字点阵数组生成工具（C语言）
12-19
本工具适用于单板单片机(STM32、C51等)开发中经常用到的点阵数组的自动生成。 发现网上的很多制作汉字点阵的工具经常会被某些杀毒软件报木马病毒，挺吓人的，于是使用自己熟悉的windows编程工具，利用字摸提取原理做了一个点阵数组生成的小工具，可以将windows系统的各种字体转化为常用的24*24或33*32点阵数组。现把这个小工具上传上来，供大家下载使用，自我感觉比原来的好用。由于本人水平有限，错误在所难免，如果各位发现错误或需要改进的地方，欢迎跟帖，以便不断改进完善。
单片机的C语言中数组的用法(转) （附原创源码）
05-26
用动态数组实现任意数排序 博文链接：https://felicity570.iteye.com/blog/511008
单片机发送16进制数组
10-23
单片机发送16进制数组，用的STC单片机。很实用！是我给一个产品订做的。4个按钮，发送4组不同代码！
51单片机c语言数组怎么用,51单片机之C语言-4.2数组
weixin_39752215的博客
05-20 4247
原标题：51单片机之C语言-4.2数组现在我们知道了，不同的数据实际上是占用的单元格不同，8个单元格就是char，16个坑就是int，32坑就是long. 在实际应用中，可能有很多char，比如char1,char2,char3...,也很多int1,int2,int3...,也有很多long1,long2,long3等等。这么多的变量，我们能不能归个类。比如把单元格长度相同的放在一起，比如cha...
51单片机点亮LED1-3（采用数组方式点亮~）
最新发布
2302_81895027的博客
03-07 603
使用模块化，前两篇已经有了一些了解，不懂的可以去看我前两篇的文章，如果还是看不懂，可以去搜索一下模块化编程是个什么，反正了解大概就可以了，那么话不多说我们直接上代码！我们把我们所需要的App,Bsp.Common添加进去,就可以开始进行编译了,编译正确就可以连接STC在实验板上实现我们要的功能了(采用数组的方式点亮LED)看起来好像是挺麻烦的但我们用多了就会发现c语言灵活方便，执行效率高，反正好处很多就不一一说明了，总之c语言是基础，我们要把它列为。为了区分于其他数字的区别，开头都是以0x开始。
【51单片机-调试技巧】 数组越界
幻蜗的笔记
03-02 1011
单片机调试经常遇到各种奇怪的问题，今天又碰到一个，特此记录 问题描述：一个变量，只有赋值，没有运算，中断只有一个比较，数值出现异常 调试半天无果，搜索了一下有网友说可能是内存越界，但怎么知道是哪个数组呢？ 祭出神器，工程目录下找到.m51结尾的文件，这个里面是存储映射。 记事本打开，搜索异常变量，在上方果然有一个数组 这个数组也确实有个指针在中断里没有约束，自己认为不会越界，但还是越界了， 更改方法就简单了，给指针加约束或是直接扩大数组。 因为空间足够(懒)的原因，空间直接给他翻倍，改完.
51单片机c语言数组算法,51单片机C语言几个数组定义的区别(精).doc
weixin_39886172的博客
05-20 546
51单片机C 语言几个数组定义的区别这样三个句子const uchar a[12]={...........};char idata time[4]={...........};uchar code table[20]={...........};const idata code 这三个是什么作用？句子是什么意思？const 表示本数组不可修改 数组为常量数组code 表示本数组生成后是在ROM ...
c51语言如何编译数组,单片机C语言教程：C51数组的使用
weixin_42489252的博客
05-19 762
/*============================================================使用 1602 液晶显示的实验例子==============================================================SMC1602A(16*2)模拟口线接线方式 连接线图:-------------------------------...
51单片机LED点阵显示教程：从8*8到128*32
这个基于51单片机的LED点阵学习攻略是一份全面的教程，覆盖了从硬件选择、软件开发到实际操作的全过程，适合对单片机编程和LED显示感兴趣的初学者和进阶者学习。通过这份教程，学习者可以掌握LED点阵显示的基础知识...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值