基于SCT89C52的贪吃蛇游戏制作

最新推荐文章于 2024-04-06 09:39:40 发布
最新推荐文章于 2024-04-06 09:39:40 发布
阅读量961 收藏 9
点赞数 1
分类专栏： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoshixiu/article/details/102674394
版权

基于SCT89C52的贪吃蛇游戏制作

本文主要描述各个模块的软件原理部分，开发板电路部分略微提及。
下载链接：https://download.csdn.net/download/xiaoshixiu/11813752

一、 控制器

  1. 红外发射管和红外接收管
    在这里插入图片描述
    红外通信是指以红外线作为载波的通信，我们常可以在遥控器的顶端看到红外二极管，也就是上图。如果晶振频率较高，有时候需要对晶振分频后由红外发射器发出。一般红外频率为38KHZ。
    二进制信号调制方式有多种，包括PCM脉冲编码调制，PWM脉冲宽度调制，PPM脉冲位置调制。
    红外接收器目前基本都已经将接收、放大、限幅、检波、整形等功能集成到一个器件中，如下图。三个脚分别为电源正、电源负、数据输出。
    在这里插入图片描述

  2. 红外接收器的数据输出端接到MCU的数据接收端口，MCU需要解析二进制信号，也就是一段区分遥控器按键的二进制信号。具体数据格式以及各段时长如下:
    在这里插入图片描述
    对于单一的遥控器而言，可以仅仅使用数据码来区分不同的按键，使用数据反码来进行校验，数据反码就是数据码取反。

  3. 为了准确接收红外信号，需要对各个部分时长做范围检查，起始码是一段9ms的高电平加上4.5ms的低电平/而后续的每一个数据包括一个低电平和一个高电平，如下图，数据0的低电平持续0.56ms，高电平大约0.56ms。数据1的低电平持续0.56ms，高电平持续1.69ms。

在这里插入图片描述

  1. 软件部分如下。
void onInt0() interrupt 0
{	
	int threshold=0;
	int i=0;
	int times=0;
	
	delay(500);//5ms
	
	//判断起始码低电平是否持续9ms
	if(p32==1){
		return;
	}
	
	//10ms持续监测起始码低电平
	threshold=1000;
	while(p32==0 && threshold!=0){
		delay(1);
		threshold--;
	};
	if(threshold==0){
		return;
	}
	
	//5.5ms持续监测起始码高电平
	threshold=550;
	while(p32==1 && threshold!=0){
		delay(1);
		threshold--;
	};
	if(threshold==0){
		return;
	}
	
	//receive data code
	//后续32位数据进行32次循环
	for(i=0;i<32;i++)
	{
        //0.6ms监测数据位的低电平
		threshold=60;
		while(p32==0 && threshold>0){
			delay(1);
			threshold--;
		}
		
      //根据高电平时长判断是位0还是位1，并把数据保存到数组infra_data中
		threshold=100;
		times=0;
		while(p32==1 && threshold!=0){
			delay(10);
			threshold--;
			times++;
		}
		if(threshold==0){
			return;
		}
		if(times>=8){
			infra_data[i/8]|=0x01;
		}
		
		if((i+1)%8 != 0)
		{
			infra_data[i/8]<<=1;
		}
	}
	
	if(infra_data[2]!=~infra_data[3])
	{
		return;
	}
		
}

二、 显示器
1 二极管阵列
在这里插入图片描述
贪吃蛇的显示采用8X8二极管阵列来显示。二极管的驱动采用74HC595进行数据位输入，位选信号则是直接使用MCU的P0输出端口。595的电路图和位选电路图如下所示。595是一个串行输入转并行输出的器件，可以将一段串行连续输入的数据转为并行输出。驱动方式主要通过11/12/14口。14口表示串行数据输入，11口表示移位寄存器输入，也就是输入并保存一位数据，需要注意11口和14口同步，当11口持续一定时间(通常几十微妙)高电平，14端口的数据会保存到一位寄存器中。持续8次后8位移位寄存器将保存好8位数据，然后12端口持续一个高电平和一个低电平，会使移位寄存器的数据输出到存储寄存器中，也就是通过并行输出。
在这里插入图片描述
2 软件部分如下

sbit _RCLK=P3^5;
sbit _SRCLK=P3^6;
sbit _SER=P3^4;

void init595(void)
{
	//上升沿有效
	_RCLK=0;
	_SRCLK=0;
}

void _595out(unsigned char out)
{
    int i=0;
	for(i=0;i<8;i++)
	{
		_SER=out>>7;//右移7位，高位数据赋值
		out<<=1;//左移一位，下次循环保存的将是第二位数据
		_SRCLK=1;//移位寄存器保存数据
		_nop_;
		_SRCLK=0;
	}
	_RCLK=1;//存储寄存器保存数据
	_nop_;
	_RCLK=0;
}

三、 贪吃蛇逻辑
此部分属于纯软件部分，但也是最复杂的部分。下面直接把所有代码进行解释。

#include"reg52.h"
#include"intrins.h"

#define NUM_1 0x30
#define NUM_2 0x18
#define NUM_3 0x7A
#define NUM_4 0x10
#define NUM_5 0x38
#define NUM_6 0x5A
#define NUM_7 0x42
#define NUM_8 0x4A
#define NUM_9 0x52

typedef unsigned char u8;

sbit p32=P3^2;
u8 infra_data[4]={0};

sbit _RCLK=P3^5;
sbit _SRCLK=P3^6;
sbit _SER=P3^4;

static int panel_index=0;

unsigned char random_seed=0;
unsigned char isGameOver=0;

void endGame(){
	EA=0;
}

void init595(void)
{
	//上升沿有效
	_RCLK=0;
	_SRCLK=0;
}

void initTimer()
{
	//IE
	EA=1;
	ET0=1;
	//TCON
	TR0=1;
	//TMOD
	TMOD|=0x01;
	TH0=0xFC;
	TL0=0x18;
}

void delay(int size) //10us
{
	while(size--);
}

void displayInMills(int ms)
{
	int i=0;
	int j=0;
	for(j=0;j<ms;j++)
	{
		while(i!=100)
		{
			i++;
		}
		i=0;
	}
}


void _595out(unsigned char out)
{
    int i=0;
	for(i=0;i<8;i++)
	{
		_SER=out>>7;
		out<<=1;
		_SRCLK=1;
		_nop_;
		_SRCLK=0;
	}
	_RCLK=1;
	_nop_;
	_RCLK=0;
}


//采用Window思想，不能每次只显示一条蛇，而是需要将所有蛇的像素拼接到二极管阵列panel中，然后采用类似垂直扫描的思想每次显示一行，循环8次，将8x8都显示出来。
void _displaypanel(unsigned char *_coord)
{
	  int i=0;
	  for(i=0;i<8;i++)
	  {
	  	  P0= 0xff - (0x01<<i) ;
	  	  _595out(_coord[i]);	     
		  
		  displayInMills(1);
		  _595out(0); //重要，消除影响
	  }
}


unsigned char snakePanel[8]={0x00,0x00,0x00,0,0,0,0,0}; //表示led阵列，可表示64个点的情况

#define SNAKE_LENGTH 8
unsigned char snakePos[SNAKE_LENGTH]={0x13,0x12,0x11,0,0,0,0,0};//表示坐标轴，每个元素表示坐标位置，高位行，低位列。蛇长最高为8

//unsigned char robotSnakePos[SNAKE_LENGTH]={0,0,0x33,0x32,0x31,0,0,0};
unsigned char robotSnakePos[SNAKE_LENGTH]={0x73,0x72,0x71,0,0,0,0,0};


//d_snake是否包含d_pos，判断是否碰撞
unsigned char isSnakeCrash(unsigned char d_pos,unsigned char *d_snake){

	int i=0;
	for(i=0;i<8;i++){
		if(d_snake[i]!=0 && d_snake[i]==d_pos){
			return 1;
		}
	}

	return 0;
}

unsigned char getSnakeLength(unsigned char *snake){
	int i=0;
	unsigned char length=0;
	for(i=0;i<8;i++){
		if(snake[i]==0){
			break;
		}
		length++;
	}
	return length;
}

//1:add success,0:game over and success,2:cross board 
unsigned char addSnakeLength(unsigned char *snake,unsigned char size)
{

	int i=0;
	unsigned char length=0;
	length=getSnakeLength(snake);
	if(SNAKE_LENGTH<(i+size)){
		return 0;
	}
	//由于硬件限制，增长受到限制
for(i=0;i<size;i++){
		if(length>=3)
		{
			// bit is equal
            //需要判断贪吃蛇与边界垂直时，增加长度会增长到阵列外
			if(snake[length-1+i]>>4==snake[length-2+i]>>4){
				if(snake[length-1+i]%16 ==0 || snake[length-1+i]%16 ==0xf)
				{
					return 2;
				}
				else{
					if(snake[length-1+i]<snake[length-2+i]){
						snake[length+i]=snake[length-1+i]-1;
					}
					else{
					   snake[length+i]=snake[length-1+i]+1;
					}
				} 
			}
			else{
				if(snake[length-1+i]>>4 ==0 || snake[length-1+i]>>4 ==0xf)
				{
					return 2;
				}
				else{
					if(snake[length-1+i]<snake[length-2+i]){
						snake[length+i]=snake[length-1+i]-0x10;
					}
					else{
					    snake[length+i]=snake[length-1+i]+0x10;
					}
					
				} 	
			}
		}
	}

	return 1;
}

void initSnakePanel()
{
    int i=0;
	for(i=0;i<8;i++)
	{
		 snakePanel[i]=0;
	}
}

void appendSnakePosToPanel(unsigned char *snake)
{
	int i=0;
	unsigned char high=0,low=0;

	for(i=0;i<SNAKE_LENGTH;i++)
	{
		low=snake[i] & 0x0F;
		high=snake[i] & 0xF0;
		if(snake[i]!=0)
		{
			snakePanel[low-1]|= 0x01<<((high>>4) - 1);
		}
	}

}

enum action{
  action_null=-1,
  up,
  right,
  down,
  left,
};


char randomAction(){
	 return random_seed%4;
}


void resetUserSnake(unsigned char *snake)
{
	snake[0]=0x13;
	snake[1]=0x12;
    snake[2]=0x11;
	snake[3]=0;
	snake[4]=0;
	snake[5]=0;
	snake[6]=0;
	snake[7]=0;
}
//当贪吃蛇碰撞时进行重置
void resetRobotSnake(unsigned char *snake)
{
	snake[0]=0x73;
	snake[1]=0x72;
    snake[2]=0x71;
	snake[3]=0;
	snake[4]=0;
	snake[5]=0;
	snake[6]=0;
	snake[7]=0;
}

unsigned char isUser=0;

//贪吃蛇左移
//贪吃蛇的移动需要判断是否是用户控制的贪吃蛇还是电脑生成的贪吃蛇，用于判断胜负
void onSnakeUp(unsigned char *snake)
{
	 int i=0;
	 unsigned char *other_snake;
	 if(isUser){
	 	 other_snake=robotSnakePos;
	 }
	 else{
	 	 other_snake=snakePos;
	 }
	 for(i=SNAKE_LENGTH-1;i>=0;i--)
	 {
	 	if(i==0)
		{	
			if(snake[i]>>4 == 0x8 || isSnakeCrash(snake[i]+0x10,other_snake))
			{
				if(isSnakeCrash(snake[i]+0x10,other_snake))
				{
                    //碰撞时直接增加被碰撞的蛇的长度，这里省略了被撞蛇去“吃“的玩法
					if(addSnakeLength(other_snake,getSnakeLength(snake))==0){
			    		isGameOver=1;
						endGame();	
			    		return;
					}
				}
				if(isUser)
				{
					resetUserSnake(snake);
					return;	
				}
				else
				{
					resetRobotSnake(snake);
					return;
				}
			}
			snake[i]+=0x10;
		}
		else
		{
			if(snake[i]!=0)
			  snake[i]=snake[i-1];
		}
	 }
}

void onSnakeRight(unsigned char *snake)
{
     int i=0;
	 unsigned char *other_snake;
	 if(isUser){
	 	 other_snake=robotSnakePos;
	 }
	 else{
	 	 other_snake=snakePos;
	 }
	 for(i=SNAKE_LENGTH-1;i>=0;i--)
	 {
	 	if(i==0)
		{
			if(snake[i]%16 == 0 || isSnakeCrash(snake[i]-0x01,other_snake))
			{
				if(isSnakeCrash(snake[i]-0x01,other_snake))
				{
					if(addSnakeLength(other_snake,getSnakeLength(snake))==0){
			    		isGameOver=1;
						endGame();	
			    		return;
					}
				}
				if(isUser)
				{
					resetUserSnake(snake);
					return;
				}
				else
				{
					resetRobotSnake(snake);
					return;
				}
			}
			snake[i]-=0x01;
		}
		else
		{
			if(snake[i]!=0)
			  snake[i]=snake[i-1];
		}
	 }
}
void onSnakeDown(unsigned char *snake)
{
	 char i=0;
     char ret=0;
	 unsigned char *other_snake;
	 if(isUser){
	 	 other_snake=robotSnakePos;
	 }
	 else{
	 	 other_snake=snakePos;
	 }
	 for(i=SNAKE_LENGTH-1;i>=0;i--)
	 {
	 	if(i==0)
		{		
			if(snake[i]>>4 == 0 || isSnakeCrash(snake[i]-0x10,other_snake))
			{
				if(isSnakeCrash(snake[i]-0x10,other_snake))
				{
					if(addSnakeLength(other_snake,getSnakeLength(snake))==0){
			    		isGameOver=1;
						endGame();	
			    		return;
					}
				}
				if(isUser)
				{
					resetUserSnake(snake);
					return;	
				}
				else
				{
					resetRobotSnake(snake);
					return;
				}
			}
			snake[i]-=0x10;
		}
		else
		{
			if(snake[i]!=0)
			  snake[i]=snake[i-1];
		}
	 }
}

void onSnakeLeft(unsigned char *snake)
{
	 int i=0;
	 unsigned char *other_snake;
	 if(isUser){
	 	 other_snake=robotSnakePos;
	 }
	 else{
	 	 other_snake=snakePos;
	 }
	 for(i=SNAKE_LENGTH-1;i>=0;i--)
	 {
	 	if(i==0)
		{
			if(snake[i]%16 == 8 || isSnakeCrash(snake[i]+0x01,other_snake))
			{
				if(isSnakeCrash(snake[i]+0x01,other_snake))
				{
					if(addSnakeLength(other_snake,getSnakeLength(snake))==0){
			    		isGameOver=1;
						endGame();	
			    		return;
					}
				}
				if(isUser)
				{
					resetUserSnake(snake);
					return;
				}
				else
				{
					resetRobotSnake(snake);
					return;
				}
			}
			snake[i]+=0x01; 
		}
		else
		{
			if(snake[i]!=0)
			  snake[i]=snake[i-1];
		}
	 }
}

enum action ir_to_action()
{
	  switch(infra_data[2]){
	  	case NUM_2:
			return up;
		case NUM_6:
			return right;
		case NUM_8:
			return down;
		case NUM_4:
			return left;
		default:
			return action_null;
	  }
	  return action_null;
}

void onTimer()
{
	initSnakePanel();
	
	isUser=1;
	switch(ir_to_action())
	{
		case up:
			//onUp();
			onSnakeUp(snakePos);
			break;
		case right:
			//onRight();
			onSnakeRight(snakePos);
			break;
		case down:
			//onDown();
			onSnakeDown(snakePos);
			break;
		case left:
			//onLeft();
			onSnakeLeft(snakePos);
			break;
		default:
			//
			break;
	}
	
	isUser=0;	
	switch(randomAction())
	{
		case up:
			//onUp();
			onSnakeUp(robotSnakePos);
			break;
		case right:
			//onRight();
			onSnakeRight(robotSnakePos);
			break;
		case down:
			//onDown();
			onSnakeDown(robotSnakePos);
			break;
		case left:
			//onLeft();
			onSnakeLeft(robotSnakePos);
			break;
		default:
			//
			break;
	}
	
	appendSnakePosToPanel(robotSnakePos);
	appendSnakePosToPanel(snakePos);
}

//由于生成的电脑需要产生随机动作，但是C51本身并没有产生随机值得方法，手动生成一个随机值至少需要一个随机种子，这里的随机种子直接使用定时器的值。可能并不是完全随机的。
void random_seed_change()
{
	if(random_seed!=0xff){
		random_seed++;
	 }else{
	  	random_seed=0;
	 }
}

//0.5s timer
void onInterrupt() interrupt 1
{
      static int i=0;
	  TH0=0xFC;
	  TL0=0x18;
	  i++;
	  if(i==500)
	  {
	      onTimer();
	      i=0;
	  }
	  
	  random_seed_change();
}

//int 0
/*now  test infra*/

void initInt0()
{
	EA=1;
	EX0=1;

	IT0=1;
	p32=1;

	infra_data[2]=NUM_4;
}

//IR
void onInt0() interrupt 0
{	
	int threshold=0;
	int i=0;
	int times=0;
	
	delay(500);
	
	
	if(p32==1){
		return;
	}
	
	
	threshold=1000;
	while(p32==0 && threshold!=0){
		delay(1);
		threshold--;
	};
	if(threshold==0){
		return;
	}
	
	
	threshold=550;
	while(p32==1 && threshold!=0){
		delay(1);
		threshold--;
	};
	if(threshold==0){
		return;
	}
	
	//receive data code
	
	for(i=0;i<32;i++)
	{
		threshold=60;
		while(p32==0 && threshold>0){
			delay(1);
			threshold--;
		}
		//if(threshold==0){
		//	return;
		//}
		threshold=100;
		times=0;
		while(p32==1 && threshold!=0){
			delay(10);
			threshold--;
			times++;
		}
		if(threshold==0){
			return;
		}
		if(times>=8){
			infra_data[i/8]|=0x01;
		}
		
		if((i+1)%8 != 0)
		{
			infra_data[i/8]<<=1;
		}
	}
	
	if(infra_data[2]!=~infra_data[3])
	{
		return;
	}
		
}

int main(void)
{
	  
	  init595();
	  initTimer();
	  initInt0();

	  while(1)
	  {
	  	_displaypanel(snakePanel);
		random_seed_change();
	  }

	  return;
}

最后是显示效果图
在这里插入图片描述

上天肖
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
贪吃蛇---STC89C52（已修复BUG版）
云上的土豆
04-10 1561
SNACK STC89C52  （已修复BUG版）思路： 通过结构体设置x，y坐标，对点阵进行定点处理。只需对每个点进行扫描，利用人眼的延时性即可显示snack; 还有比较关键的就是模仿，只控制第一个点，随后几个分别模仿前一个点的运动轨迹即可实现连贯跟随。：）自定义游戏规则： 不能穿墙（考虑到界面比较小，颜色比较单一，穿墙后容易分辨不了蛇的头和尾）。    撞到自己后重新开局，头只能向三个方向
STC89C52开发板原理图.pdf
04-06
STC89C52开发板原理图.pdf 未经允许，禁止转载
基于C语言编程的STC80C52单片机的手机贪吃蛇游戏系统的设计
07-18
设立开始键和上下左右操控键，液晶显示上可以随机出现食物，贪吃蛇在吃到食物后蛇身能增长，在撞到墙壁或者和自身相撞时游戏结束，并且贪吃蛇在吃到食物和游戏结束时要辅以不同的音效。用C语言编程
[记录] 基于STC89C52RC的贪吃蛇三色游戏机设计（内含点阵驱动、数码管驱动详解）
TZR986981442的博客
03-22 2780
目录设计目标需求分析硬件设计模块设计点阵模块线路图软件设计总结新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 设计目标 以红绿双色共阳极点阵M1588BRG和红色共阳极数码管MT03641BR作为图像输出设备，其中两块点
你知道什么是STC89C52RC吗？
最新发布
w5jaLw的博客
04-06 2948
STC89C52RC是一种基于8051架构的单片机芯片，由中国的STC公司生产。它包含52KB的闪存程序存储器，1KB的RAM数据存储器，以及一系列的外设接口，例如串口、定时器、计数器等等，可广泛应用于工业自动化、仪器仪表、智能家居、电子产品等领域。STC89C52RC具有低功耗、高性能和高可靠性等优点，成本相对较低，因此在中国的嵌入式系统开发领域得到了广泛应用。你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！” />你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！
基于STC89C52的贪吃蛇游戏
03-20
基于STC89C52，lcd12864显示，按钮控制方向和菜单，贪吃蛇游戏，新增功能血量，不单单吃食物会变长，在游戏过程中，随机刷新障碍物，撞到扣血，同时也会刷新血块，可以补血。随着长度增加贪吃蛇运动也会加快。
基于STC89C52的贪吃蛇（用74hc595和P1口。P1口可用74hc138代替）
qq_45774073的博客
10-12 1103
说法一：其实单色点阵LED本无所谓共阳还是共阴，如此命名多半是因为行业习惯造成的。市面上对8*8点阵LED所谓的共阳还是共阴的说法一般是根据点阵第一个引脚的极性所定义的，第一个引脚为阳极则为共阳，反之则为共阴。 说法二：卖家所说的共阴或者共阳确切的说应该是行共阴或者行共阳 从这两张图片上我们看到第一脚是在第一行的，所以这两种说法其实是一样的 下面说说点阵的一些基本知识 管脚的定义： 有的点阵后面标有第一脚，但是有的没有标，现在大家默认跟IC的管脚顺序一样，读法是第1脚一般在侧面有字的那一面，字是正向时左
基于SCT89C51智能小车实训报告
05-14
基于 STC89C52 单片机智能小车系统设计由 STC89C52 单片机、电机驱动、晶振电路、按键电路、数码管显示电路、红外感应电路几部分组成。 4.1 框图设计 基于 STC89C52 单片机智能小车系统框图如图 1-1 所示。 4.2 ...
SCT89C52电子钟
06-28
SCT89C52电子钟设计
SCT89C52RC中文数据手册
09-18
SCT89C52RC中文数据手册，适合单片机初学者
基于stc89c52单片机设计电压表程序
08-12
对该电压 表的设计使用了模块化的设计特点，主要用到了 C51 系列型号为 STC89C52RC 单 片机的矩阵键盘模块、AD/DA 转换模块、LCD 显示模块。该电压表相比于一般的 电压表，特点是体现了人机界面交互，即使用密码解锁...
C52单片机做的贪吃蛇
06-20
C52单片机做的贪吃蛇 以验证可用
基于51单片机的贪吃蛇程序.
01-13
基于proteus的仿真，12864显示，实现贪吃蛇的基本功能，可以作为单片机的课设的
基于STC89C52 16*16点阵贪吃蛇
05-08
本设计采用8051单片机为主控，实现采用4个按键控制16*16点阵显示的贪吃蛇游戏。并做到以下要求： 1.点阵显示清晰无坏点； 2.按键控制方向，反应迅速无延迟； 3.随着所吃食物增加，移动速度逐渐增加； 4.当贪吃蛇碰壁时游戏结束，并且显示分数； 5.当游戏结束后能够恢复初始化，继续进行。
51单片机贪吃蛇代码
12-13
这是51单片机里面运行的贪吃蛇代码，不同板子可以通过改变端口来使用，需要通过按键来改变方向
单片机AT89C52贪吃蛇资料.rar
06-03
随着社会的发展，人们生活的步调日益加快，越来越多的人加入了全球化的世界。 人们不再拘泥于--,J,块天地，加班，出差成了现代人不可避免的公务。而此时一款可以 随时随地娱乐的游戏成了必需品。贪吃蛇这一游戏简单易行，操作方便，娱乐性较强， 吸引了不少人。这一款游戏紧紧地抓住了人们的心理，虽然简单，却其乐无穷，在人们 不断追求更多的欲望下，该游戏给人们带来了追逐的快感，以及成功后的满足感，对于 一直处于高压下的现代人是很好的放松工具 ———————————————— 版权声明：本文为CSDN博主「lqs82791847」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/lqs82791847/article/details/6061345
基于stc89C52的贪吃蛇小程序
qq_41976171的博客
06-18 4559
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210...
用STC89C52RC单片机和0.96寸OLED屏幕实现贪吃蛇游戏。
qq12651775的博客
12-08 2124
用STC89C52RC单片机和0.96寸OLED屏幕实现贪吃蛇游戏。
单片机实现一个贪吃蛇小游戏
m0_52003856的博客
09-26 2063
#include <reg52.h> #define uchar unsigned char #define SNAKE 22 //最大长度 #define TIME 40 //显示延时时间 #define SPEED 88 //速度控制 #define keyenable 1 sbit led = P0^0; sbit up=P3^2; sbit down=P3^4; sbit right=P3^3; sbi.
sct89c52基本原理
05-12
SCT89C52是一种基于8051架构的单片机，其基本原理与其他8051芯片相似。 SCT89C52具有8位CPU，具有128个字节的RAM和8KB的Flash存储器。它还具有2个16位计数器/定时器，2个串行口，4个8位输入/输出端口和一个可编程的矩阵键盘控制器。 SCT89C52的工作原理是通过执行指令来完成各种任务。它的指令集包括基本的算术和逻辑运算指令、数据传输指令和程序控制指令。程序可以通过内部Flash存储器或外部EEPROM存储器来存储。 SCT89C52还具有中断功能，可以通过外部中断、定时器中断等方式触发中断。中断可以在程序执行过程中及时响应外部事件，以提高系统的实时性和可靠性。 总之，SCT89C52是一种功能强大的单片机，具有广泛的应用范围，包括工业自动化、家电控制、智能仪器等领域。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值