基于51单片机和LCD1602、矩阵按键的小游戏《猜数字》

王柳  论坛元老 | 2025-5-4 17:14:31 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 2041|帖子 2041|积分 6123

系列文章目次

前言

用的是普中A2开发板，用到板上的矩阵按键，还必要外接一个LCD1602液晶显示屏。
【单片机】STC89C52RC
【频率】12T@11.0592MHz
   效果查看/操作演示：B站搜索“甘腾胜”或“gantengsheng”查看。
源代码下载：B站对应视频的简介有工程文件下载链接。
  一、效果展示





二、原理分析

1、数字的输入与清除
输入数字时，通过十进制的移位和加法，将刚输入的数字及时保存到int变量中。
2、随机数的产生
设置的最大范围是：1~9999，我发现当范围较大时，虽然每次获取键码时用了定时器0的低八位做种子，但发现产生的随机数比力会集，会集在其中的一个小范围内。然后我将随机数的产生的算式弄复杂一些，就比力随机了，但还是有一定的伪随机性。道友有更好的办法请跟我说一下，谢谢了！
3、随机数的范围
由于屏幕巨细有限，以是限定随机数的范围是1~9999，最多四位数。设定范围的时间要注意，最大值要比最小值大2以上，如果不公道，则必要重置后重新输入。
4、按键的检测
矩阵按键通过行列扫描检测，使用定时器0，每隔20ms检测一次，防止阻塞步伐运行。
三、各模块代码

1、LCD1602

h文件
  1. #ifndef __LCD1602_H__
  2. #define __LCD1602_H__
  4. void LCD_WriteCommand(unsigned char Command);
  5. void LCD_WriteData(unsigned char Data);
  6. void LCD_SetCursor(unsigned char Line,unsigned char Column);
  7. void LCD_Init();
  8. void LCD_ShowChar(unsigned char Line,unsigned char Column,char Char);
  9. void LCD_ShowString(unsigned char Line,unsigned char Column,char *String);
  10. void LCD_ShowNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length);
  11. void LCD_ShowSignedNum(unsigned char Line,unsigned char Column,int Number,unsigned char Length);
  12. void LCD_ShowHexNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length);
  13. void LCD_ShowBinNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length);
  14. void LCD_Clear(void);
  15. void LCD_IsShowCursor(unsigned char State);
  16. void LCD_Show16Char(unsigned char Line,unsigned char Column,char *String);
  18. #endif
复制代码
c文件
  1. #include <REGX52.H>
  3. /*引脚配置*/
  4. sbit LCD_RS=P2^6;
  5. sbit LCD_RW=P2^5;
  6. sbit LCD_EN=P2^7;
  7. #define LCD_DataPort P0
  9. /*函数定义*/
  10. /**
  11.   * 函    数：LCD1602私有延时函数，延时约50us
  12.   * 参    数：无
  13.   * 返 回 值：无
  14.   */
  15. void LCD_Delay50us(void)        //12T@11.0592MHz
  16. {
  17.         unsigned char i;
  18.         i=20;
  19.         while(--i);
  20. }
  22. /**
  23.   * 函    数：LCD1602私有延时函数，延时约2ms
  24.   * 参    数：无
  25.   * 返 回 值：无
  26.   */
  27. void LCD_Delay2ms(void)        //12T@11.0592MHz
  28. {
  29.         unsigned char i,j;
  30.         i=4;
  31.         j=146;
  32.         do
  33.         {
  34.                 while(--j);
  35.         }while(--i);
  36. }
  38. /**
  39.   * 函    数：LCD1602写指令
  40.   * 参    数：Command 要写入的指令
  41.   * 返 回 值：无
  42.   */
  43. void LCD_WriteCommand(unsigned char Command)
  44. {
  45.         LCD_RS=0;
  46.         LCD_RW=0;
  47.         LCD_DataPort=Command;
  48.         LCD_EN=1;
  49.         LCD_Delay50us();
  50.         LCD_EN=0;
  51.         LCD_Delay50us();
  52. }
  54. /**
  55.   * 函    数：LCD1602写数据
  56.   * 参    数：Data 要写入的数据
  57.   * 返 回 值：无
  58.   */
  59. void LCD_WriteData(unsigned char Data)
  60. {
  61.         LCD_RS=1;
  62.         LCD_RW=0;
  63.         LCD_DataPort=Data;
  64.         LCD_EN=1;
  65.         LCD_Delay50us();
  66.         LCD_EN=0;
  67.         LCD_Delay50us();
  68. }
  70. /**
  71.   * 函    数：LCD1602设置光标位置
  72.   * 参    数：Line 行位置，范围：1~2
  73.   * 参    数：Column 列位置，范围：1~16
  74.   * 返 回 值：无
  75.   */
  76. void LCD_SetCursor(unsigned char Line,unsigned char Column)
  77. {
  78.         if(Line==1)
  79.         {
  80.                 LCD_WriteCommand(0x80|(Column-1));
  81.         }
  82.         else if(Line==2)
  83.         {
  84.                 LCD_WriteCommand(0x80|(Column-1+0x40));
  85.         }
  86. }
  88. /**
  89.   * 函    数：LCD1602初始化函数
  90.   * 参    数：无
  91.   * 返 回 值：无
  92.   */
  93. void LCD_Init()
  94. {
  95.         LCD_WriteCommand(0x38);        //八位数据接口，两行显示，5*7点阵
  96.         LCD_WriteCommand(0x0C);        //显示开，光标关，闪烁关
  97.         LCD_WriteCommand(0x06);        //数据读写操作后，光标自动加一，画面不动
  98.         LCD_WriteCommand(0x01);        //光标复位，清屏
  99.         LCD_Delay2ms();        //清屏指令执行需要较长时间，需要较长的延时
  100. }
  102. /**
  103.   * 函    数：在LCD1602指定位置上显示一个字符
  104.   * 参    数：Line 行位置，范围：1~2
  105.   * 参    数：Column 列位置，范围：1~16
  106.   * 参    数：Char 要显示的字符
  107.   * 返 回 值：无
  108.   */
  109. void LCD_ShowChar(unsigned char Line,unsigned char Column,char Char)
  110. {
  111.         LCD_SetCursor(Line,Column);
  112.         LCD_WriteData(Char);
  113. }
  115. /**
  116.   * 函    数：在LCD1602指定位置开始显示所给字符串
  117.   * 参    数：Line 起始行位置，范围：1~2
  118.   * 参    数：Column 起始列位置，范围：1~16
  119.   * 参    数：String 要显示的字符串
  120.   * 返 回 值：无
  121.   */
  122. void LCD_ShowString(unsigned char Line,unsigned char Column,char *String)
  123. {
  124.         unsigned char i;
  125.         LCD_SetCursor(Line,Column);
  126.         for(i=0;String[i]!='\0';i++)
  127.         {
  128.                 LCD_WriteData(String[i]);
  129.         }
  130. }
  132. /**
  133.   * 函    数：返回值=X的Y次方
  134.   */
  135. int LCD_Pow(int X,int Y)
  136. {
  137.         unsigned char i;
  138.         int Result=1;
  139.         for(i=0;i<Y;i++)
  140.         {
  141.                 Result*=X;
  142.         }
  143.         return Result;
  144. }
  146. /**
  147.   * 函    数：在LCD1602指定位置开始显示所给数字
  148.   * 参    数：Line 起始行位置，范围：1~2
  149.   * 参    数：Column 起始列位置，范围：1~16
  150.   * 参    数：Number 要显示的数字，范围：0~65535
  151.   * 参    数：Length 要显示数字的长度，范围：1~5
  152.   * 返 回 值：无
  153.   */
  154. void LCD_ShowNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length)
  155. {
  156.         unsigned char i;
  157.         LCD_SetCursor(Line,Column);
  158.         for(i=Length;i>0;i--)
  159.         {
  160.                 LCD_WriteData(Number/LCD_Pow(10,i-1)%10+'0');
  161.         }
  162. }
  164. /**
  165.   * 函    数：在LCD1602指定位置开始以有符号十进制显示所给数字
  166.   * 参    数：Line 起始行位置，范围：1~2
  167.   * 参    数：Column 起始列位置，范围：1~16
  168.   * 参    数：Number 要显示的数字，范围：-32768~32767
  169.   * 参    数：Length 要显示数字的长度，范围：1~5
  170.   * 返 回 值：无
  171.   */
  172. void LCD_ShowSignedNum(unsigned char Line,unsigned char Column,int Number,unsigned char Length)
  173. {
  174.         unsigned char i;
  175.         unsigned int Number1;
  176.         LCD_SetCursor(Line,Column);
  177.         if(Number>=0)
  178.         {
  179.                 LCD_WriteData('+');
  180.                 Number1=Number;
  181.         }
  182.         else
  183.         {
  184.                 LCD_WriteData('-');
  185.                 Number1=-Number;
  186.         }
  187.         for(i=Length;i>0;i--)
  188.         {
  189.                 LCD_WriteData(Number1/LCD_Pow(10,i-1)%10+'0');
  190.         }
  191. }
  193. /**
  194.   * 函    数：在LCD1602指定位置开始以十六进制显示所给数字
  195.   * 参    数：Line 起始行位置，范围：1~2
  196.   * 参    数：Column 起始列位置，范围：1~16
  197.   * 参    数：Number 要显示的数字，范围：0~0xFFFF
  198.   * 参    数：Length 要显示数字的长度，范围：1~4
  199.   * 返 回 值：无
  200.   */
  201. void LCD_ShowHexNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length)
  202. {
  203.         unsigned char i,SingleNumber;
  204.         LCD_SetCursor(Line,Column);
  205.         for(i=Length;i>0;i--)
  206.         {
  207.                 SingleNumber=Number/LCD_Pow(16,i-1)%16;
  208.                 if(SingleNumber<10)
  209.                 {
  210.                         LCD_WriteData(SingleNumber+'0');
  211.                 }
  212.                 else
  213.                 {
  214.                         LCD_WriteData(SingleNumber-10+'A');
  215.                 }
  216.         }
  217. }
  219. /**
  220.   * 函    数：在LCD1602指定位置开始以二进制显示所给数字
  221.   * 参    数：Line 起始行位置，范围：1~2
  222.   * 参    数：Column 起始列位置，范围：1~16
  223.   * 参    数：Number 要显示的数字，范围：0~1111 1111 1111 1111
  224.   * 参    数：Length 要显示数字的长度，范围：1~16
  225.   * 返 回 值：无
  226.   */
  227. void LCD_ShowBinNum(unsigned char Line,unsigned char Column,unsigned int Number,unsigned char Length)
  228. {
  229.         unsigned char i;
  230.         LCD_SetCursor(Line,Column);
  231.         for(i=Length;i>0;i--)
  232.         {
  233.                 LCD_WriteData(Number/LCD_Pow(2,i-1)%2+'0');
  234.         }
  235. }
  237. /**
  238.   * 函    数：LCD1602的光标复位，清屏
  239.   * 参    数：无
  240.   * 返 回 值：无
  241.   */
  242. void LCD_Clear(void)
  243. {
  244.         LCD_WriteCommand(0x01);
  245.         LCD_Delay2ms();
  246. }
  248. /**
  249.   * 函    数：LCD1602设置光标是否显示
  250.   * 参    数：State 光标状态，1：显示，0：不显示
  251.   * 返 回 值：无
  252.   */
  253. void LCD_IsShowCursor(unsigned char State)
  254. {
  255.         if(State){LCD_WriteCommand(0x0E);}
  256.         else{LCD_WriteCommand(0x0C);}
  257. }
复制代码
2、矩阵按键

h文件
  1. #ifndef __MATRIXKEYSCAN_H__
  2. #define __MATRIXKEYSCAN_H__
  4. unsigned char MatrixKey(void);
  5. void MatrixKey_Tick(void);
  7. #endif
复制代码
c文件
  1. #include <REGX52.H>
  3. #define Matrix_Port P1        //矩阵按键接口
  5. unsigned char KeyNumber;
  7. /**
  8.   * 函    数：获取矩阵按键键码
  9.   * 参    数：无
  10.   * 返 回 值：按下按键的键码，范围：0~48，0表示无按键按下
  11.   * 说    明：在下一次检测按键之前，第二次获取键码一定会返回0
  12.   */
  13. unsigned char MatrixKey(void)
  14. {
  15.         unsigned char KeyTemp=0;
  16.         KeyTemp=KeyNumber;
  17.         KeyNumber=0;
  18.         return KeyTemp;
  19. }
  21. /**
  22.   * 函    数：检测当前按下的按键，无消抖及松手检测
  23.   * 参    数：无
  24.   * 返 回 值：按下按键的键值，范围：0~16，无按键按下时返回值为0
  25.   */
  26. unsigned char Key_GetState()
  27. {
  28.         unsigned char KeyValue=0;
  29.         unsigned char i=0;
  30.        
  31.         Matrix_Port=0x0F;        //给所有行赋值0，列全为1
  32.         i=2;while(i--);        //适当延时，延时5us
  33.         if(Matrix_Port!=0x0F)
  34.         {
  35.                 Matrix_Port=0x0F;        //测试列
  36.                 i=2;while(i--);
  37.                 switch(Matrix_Port)        //所有行拉低，检测哪一列按下
  38.                 {
  39.                         case 0x07:KeyValue=1;break;
  40.                         case 0x0B:KeyValue=2;break;
  41.                         case 0x0D:KeyValue=3;break;
  42.                         case 0x0E:KeyValue=4;break;
  43.                         default:break;
  44.                 }
  45.                 Matrix_Port=0xF0;        //测试行
  46.                 i=2;while(i--);
  47.                 switch(Matrix_Port)        //所有列拉低，检测哪一行按下
  48.                 {
  49.                         case 0x70:KeyValue=KeyValue;break;
  50.                         case 0xB0:KeyValue=KeyValue+4;break;
  51.                         case 0xD0:KeyValue=KeyValue+8;break;
  52.                         case 0xE0:KeyValue=KeyValue+12;break;
  53.                         default:break;
  54.                 }
  55.         }
  56.         else
  57.         {
  58.                 KeyValue=0;
  59.         }
  61.         return KeyValue;
  62. }
  64. /**
  65.   * 函    数：矩阵按键驱动函数，在中断中调用
  66.   * 参    数：无
  67.   * 返 回 值：无
  68.   */
  69. void MatrixKey_Tick(void)
  70. {
  71.         static unsigned char NowState,LastState;
  72.         static unsigned int KeyCount;
  74.         LastState=NowState;        //更新上一次的键值
  75.         NowState=Key_GetState();        //获取当前的键值
  77.         //如果上个时间点按键未按下，这个时间点按键按下，则是按下瞬间
  78.         if(LastState==0)
  79.         {
  80.                 switch(NowState)
  81.                 {
  82.                         case 1:KeyNumber=1;break;
  83.                         case 2:KeyNumber=2;break;
  84.                         case 3:KeyNumber=3;break;
  85.                         case 4:KeyNumber=4;break;
  86.                         case 5:KeyNumber=5;break;
  87.                         case 6:KeyNumber=6;break;
  88.                         case 7:KeyNumber=7;break;
  89.                         case 8:KeyNumber=8;break;
  90.                         case 9:KeyNumber=9;break;
  91.                         case 10:KeyNumber=10;break;
  92.                         case 11:KeyNumber=11;break;
  93.                         case 12:KeyNumber=12;break;
  94.                         case 13:KeyNumber=13;break;
  95.                         case 14:KeyNumber=14;break;
  96.                         case 15:KeyNumber=15;break;
  97.                         case 16:KeyNumber=16;break;
  98.                         default:break;
  99.                 }
  100.         }
  101.        
  102.         //如果上个时间点按键按下，这个时间点按键还是按下，则是长按
  103.         if(LastState && NowState)
  104.         {
  105.                 KeyCount++;
  107.                 if(KeyCount%50==0)        //定时器中断函数中每隔20ms检测一次按键
  108.                 {        //长按后每隔1s返回一次长按的键码
  109.                         if     (LastState== 1 && NowState== 1){KeyNumber=17;}
  110.                         else if(LastState== 2 && NowState== 2){KeyNumber=18;}
  111.                         else if(LastState== 3 && NowState== 3){KeyNumber=19;}
  112.                         else if(LastState== 4 && NowState== 4){KeyNumber=20;}
  113.                         else if(LastState== 5 && NowState== 5){KeyNumber=21;}
  114.                         else if(LastState== 6 && NowState== 6){KeyNumber=22;}
  115.                         else if(LastState== 7 && NowState== 7){KeyNumber=23;}
  116.                         else if(LastState== 8 && NowState== 8){KeyNumber=24;}
  117.                         else if(LastState== 9 && NowState== 9){KeyNumber=25;}
  118.                         else if(LastState==10 && NowState==10){KeyNumber=26;}
  119.                         else if(LastState==11 && NowState==11){KeyNumber=27;}
  120.                         else if(LastState==12 && NowState==12){KeyNumber=28;}
  121.                         else if(LastState==13 && NowState==13){KeyNumber=29;}
  122.                         else if(LastState==14 && NowState==14){KeyNumber=30;}
  123.                         else if(LastState==15 && NowState==15){KeyNumber=31;}
  124.                         else if(LastState==16 && NowState==16){KeyNumber=32;}
  125.                 }
  126.         }
  127.         else
  128.         {
  129.                 KeyCount=0;
  130.         }
  132.         //如果上个时间点按键按下，这个时间点按键未按下，则是松手瞬间
  133.         if(NowState==0)
  134.         {
  135.                 switch(LastState)
  136.                 {
  137.                         case 1:KeyNumber=33;break;
  138.                         case 2:KeyNumber=34;break;
  139.                         case 3:KeyNumber=35;break;
  140.                         case 4:KeyNumber=36;break;
  141.                         case 5:KeyNumber=37;break;
  142.                         case 6:KeyNumber=38;break;
  143.                         case 7:KeyNumber=39;break;
  144.                         case 8:KeyNumber=40;break;
  145.                         case 9:KeyNumber=41;break;
  146.                         case 10:KeyNumber=42;break;
  147.                         case 11:KeyNumber=43;break;
  148.                         case 12:KeyNumber=44;break;
  149.                         case 13:KeyNumber=45;break;
  150.                         case 14:KeyNumber=46;break;
  151.                         case 15:KeyNumber=47;break;
  152.                         case 16:KeyNumber=48;break;
  153.                         default:break;
  154.                 }
  155.         }
  157. }
复制代码
3、定时器0

h文件
  1. #ifndef __TIMER0_H__
  2. #define __TIMER0_H__
  4. void Timer0_Init(void);
  6. #endif
复制代码
c文件
  1. #include <REGX52.H>
  3. /**
  4.   * 函    数：定时器0初始化
  5.   * 参    数：无
  6.   * 返 回 值：无
  7.   */
  8. void Timer0_Init(void)
  9. {       
  10. //        AUXR&=0x7F;        //定时器时钟12T模式（STC89C52RC是12T单片机，无需设置）
  11.         TMOD&=0xF0;        //设置定时器模式（高四位不变，低四位清零）
  12.         TMOD|=0x01;        //设置定时器模式（通过低四位设为16位不自动重装）
  13.         TL0=0x00;        //设置定时初值，定时10ms，12T@11.0592MHz
  14.         TH0=0xDC;        //设置定时初值，定时10ms，12T@11.0592MHz
  15.         TF0=0;        //清除TF0标志
  16.         TR0=1;        //定时器0开始计时
  17.         ET0=1;        //打开定时器0中断允许
  18.         EA=1;        //打开总中断
  19.         PT0=0;        //当PT0=0时，定时器0为低优先级，当PT0=1时，定时器0为高优先级
  20. }
  22. /*定时器中断函数模板
  23. void Timer0_Routine() interrupt 1        //定时器0中断函数
  24. {
  25.         static unsigned int T0Count;        //定义静态变量
  26.         TL0=0x00;        //设置定时初值，定时10ms，12T@11.0592MHz
  27.         TH0=0xDC;        //设置定时初值，定时10ms，12T@11.0592MHz
  28.         T0Count++;
  29.         if(T0Count>=1000)
  30.         {
  31.                 T0Count=0;
  32.                
  33.         }
  34. }
  35. */
复制代码
四、主函数

main.c
  1. /*by甘腾胜@20250423
  2. 【效果查看/操作演示】B站搜索“甘腾胜”或“gantengsheng”查看
  3. 【单片机】STC89C52RC
  4. 【频率】12T@11.0592MHz
  5. 【外设】LCD1602、矩阵按键
  6. 【简单的原理分析】https://blog.csdn.net/gantengsheng/article/details/143581157
  7. 【注意】点阵屏旁边的跳线帽接三根排针中的右边两根
  8. 【操作】
  10.         S1                S2                S3                S4
  11.         S5                S6                S7                S8
  12.         S9                S10                S11                S12
  13.         S13                S14                S15                S16
  15. S1~S9：数字1~9
  16. S10：数字0
  17. S11：清空/返回
  18. S12：确认键
  20. （1）输入错误可按S11（松手瞬间）清空后重新输入
  21. （2）按S12（松手瞬间）表示确认完成输入
  22. （3）猜对数字后按S11（松手瞬间）返回设置范围的界面
  23. */
  25. #include <REGX52.H>        //51单片机头文件
  26. #include "LCD1602.h"        //LCD1602液晶显示屏
  27. #include "MatrixKeyScan.h"        //矩阵按键
  28. #include "Timer0.h"        //定时器0
  29. #include <STDLIB.H>        //随机函数
  31. unsigned char KeyNum;        //存储获得的键码
  32. unsigned char Mode;        //模式，0：显示游戏英文名，1：设置数字范围界面，2：猜数字过程，3：猜对后的屏幕显示
  33. unsigned char OnceFlag=1;        //某些前提下只执行一次的标志（各模式中用来判断是否要初始化），1：执行，0：不执行
  34. unsigned char InputLength;        //输入位数，范围：1~4
  35. unsigned char LastInputLength;        //上一次的输入位数，范围：1~4，用来判断是否有按下数字键0~9
  36. bit ConfirmFlag;        //确认按键按下的标志，1：确认按键按下，0：确认按键未按下
  37. unsigned char NowNumber;        //刚刚输入的数字按键对应的数字，范围：0~9
  38. bit SetMinFlag;        //正在设置数字范围最小值的标志，1：正在设置，0：没有在设置
  39. bit SetMaxFlag;        //正在设置数字范围最大值的标志，1：正在设置，0：没有在设置
  40. unsigned int MinNumber;        //所设置的数字范围的最小值，范围：1~9997
  41. unsigned int MaxNumber;        //所设置的数字范围的最大值，范围：3~9999
  42. unsigned char MinLength;        //最小值的位数，范围：1~4
  43. unsigned char MaxLength;        //最大值的位数，范围：1~4
  44. bit CheckFlag;        //设置完范围后检查范围是否合理的标志，1：检查，0：不检查
  45. bit ReenterFlag;        //重新输入的标志，1：重新输入，0：不重新输入
  46. unsigned int PlayerNumber;        //玩家输入的数字，范围：2~9998
  47. unsigned char PlayerLength;        //玩家输入数字的位数，范围：1~4
  48. unsigned int RandomNumber;        //产生的随机数，范围：MinNumber<RandomNumber<MaxNumber
  49. unsigned char RandomLength;        //随机数的位数，范围：1~4
  50. unsigned int GuessTimes;        //玩家猜测的次数
  51. unsigned char GuessLength;        //玩家猜测的次数的位数，范围：1~4
  53. /**
  54.   * 函    数：延时函数，延时约xms毫秒
  55.   * 参    数：xms 延时的时间，范围：0~65535
  56.   * 返 回 值：无
  57.   */
  58. void Delay(unsigned int xms)        //12T@11.0592MHz
  59. {
  60.         unsigned char i,j;
  61.         while(xms--)
  62.         {
  63.                 i=2;
  64.                 j=199;
  65.                 do
  66.                 {
  67.                         while(--j);
  68.                 }while(--i);
  69.         }
  70. }
  72. /**
  73.   * 函    数：主函数（有且仅有一个）
  74.   * 参    数：无
  75.   * 返 回 值：无
  76.   * 说    明：主函数是程序执行的起点，负责执行整个程序的主要逻辑‌
  77.   */
  78. void main()
  79. {
  80.         Timer0_Init();  //定时器0初始化
  81.         LCD_Init();        //LCD1602初始化
  83.         while(1)
  84.         {
  85.                 KeyNum=MatrixKey();        //获取键码
  86.                
  87.                 if(KeyNum)        //如果有按键按下
  88.                 {
  89.                         if(Mode==0)        //如果是显示游戏名称的界面
  90.                         {
  91.                                 if(KeyNum>=33 && KeyNum<=48)        //如果按下任意按键（松手瞬间）
  92.                                 {
  93.                                         Mode=1;
  94.                                         OnceFlag=1;
  95.                                 }
  96.                         }
  97.                         else if(Mode==1)        //如果是设置数字范围的界面
  98.                         {
  99.                                 if(KeyNum>=33 && KeyNum<=42)        //如果按下“0~9”（松手瞬间），即按下S1~S10，S10为0
  100.                                 {
  101.                                         if(InputLength<4)        //限制输入的最大位数为4
  102.                                         {
  103.                                                 if(InputLength!=0 || KeyNum!=42)        //第一个数字不能为0
  104.                                                 {
  105.                                                         NowNumber=(KeyNum-32)%10;
  106.                                                         InputLength++;
  107.                                                 }
  108.                                         }
  109.                                 }
  110.                                 if(KeyNum==27)        //如果按下S11（长按超1s）
  111.                                 {
  112.                                         OnceFlag=1;        //重置
  113.                                 }
  114.                                 if(KeyNum==43)        //如果按下S11（松手瞬间），则清空，重新输入
  115.                                 {
  116.                                         ReenterFlag=1;
  117.                                 }
  118.                                 if(KeyNum==44)        //如果按下S12（松手瞬间），表示确认
  119.                                 {
  120.                                         if(InputLength){ConfirmFlag=1;}        //按了数字键，才能确认
  121.                                 }
  122.                         }
  123.                         else if(Mode==2)        //如果是正在猜数字
  124.                         {
  125.                                 if(KeyNum>=33 && KeyNum<=42)        //如果按下“0~9”（松手瞬间），即按下S1~S10，S10为0
  126.                                 {
  127.                                         if(InputLength<4)        //限制输入的最大位数为4
  128.                                         {
  129.                                                 if(InputLength!=0 || KeyNum!=42)        //第一个数字不能为0
  130.                                                 {
  131.                                                         NowNumber=(KeyNum-32)%10;
  132.                                                         InputLength++;
  133.                                                 }
  134.                                         }
  135.                                 }
  136.                                 if(KeyNum==27)        //如果按下S11（长按超1s）
  137.                                 {
  138.                                         Mode=1;        //返回设置范围的界面
  139.                                         OnceFlag=1;
  140.                                 }
  141.                                 if(KeyNum==43)        //如果按下S11（松手瞬间），则清空，重新输入
  142.                                 {
  143.                                         ReenterFlag=1;
  144.                                 }
  145.                                 if(KeyNum==44)        //如果按下S12（松手瞬间），表示确认
  146.                                 {
  147.                                         if(InputLength){ConfirmFlag=1;}        //按了数字键，才能确认
  148.                                 }
  149.                         }
  150.                         else if(Mode==3)        //如果是猜对之后的屏幕显示
  151.                         {
  152.                                 if(KeyNum==43)        //如果按下S11（松手瞬间）
  153.                                 {
  154.                                         Mode=1;        //返回设置范围的界面
  155.                                         OnceFlag=1;
  156.                                 }
  157.                         }
  159.                 }
  161.                 if(Mode==0)        //显示游戏名称
  162.                 {
  163.                         if(OnceFlag)
  164.                         {
  165.                                 OnceFlag=0;        //标志置0
  166.                                
  167.                                 /*初始化*/
  168.                                 LCD_Clear();        //LCD1602清屏
  169.                                 LCD_ShowString(1,3,"Guess Number");        //显示游戏英文名
  170.                         }
  172.                 }
  174.                 else if(Mode==1)        //设置要猜的数字的范围
  175.                 {
  176.                         if(OnceFlag)
  177.                         {
  178.                                 OnceFlag=0;
  180.                                 //初始化
  181.                                 LastInputLength=0;        //上一次输入的位数清零
  182.                                 InputLength=0;        //输入的位数清零
  183.                                 ConfirmFlag=0;        //确认标志清零
  184.                                 CheckFlag=0;        //检查的标志置0
  185.                                 ReenterFlag=0;        //重新输入的标志置0
  186.                                 SetMinFlag=1;        //正在设置最小值的标志置1
  187.                                 SetMaxFlag=0;        //正在设置最大值的标志置0
  188.                                 MinNumber=0;        //最小值清零
  189.                                 MaxNumber=0;        //最大值清零
  190.                                 MinLength=0;        //最小值的位数清零
  191.                                 MaxLength=0;        //最大值的位数清零
  192.                                 GuessTimes=0;        //猜数字的次数清零
  193.                                 LCD_Clear();        //清屏
  194.                                 LCD_ShowString(1,1,"Set Range");
  195.                                 LCD_ShowString(2,1,"Min:");
  196.                                 LCD_ShowString(2,9,"Max:");        //显示英文提示
  197.                                 LCD_SetCursor(2,5);        //设置光标在第2行第5列
  198.                                 LCD_IsShowCursor(1);        //显示光标
  199.                         }
  200.                         if(LastInputLength!=InputLength)        //如果按了S1~S10（0~9），S10为0
  201.                         {
  202.                                 LastInputLength=InputLength;        //更新上一次的输入长度
  203.                                 if(SetMaxFlag)        //如果正在设置最大值
  204.                                 {
  205.                                         LCD_ShowNum(2,12+InputLength,NowNumber,1);        //将所按的数字显示在屏幕上
  206.                                         MaxNumber*=10;MaxNumber+=NowNumber;        //将刚刚所按的数字键对应的数字保存到变量MaxNumber中
  207.                                         MaxLength++;        //最大数字的位数增加一
  208.                                 }
  209.                                 if(SetMinFlag)        //如果正在设置最小值
  210.                                 {
  211.                                         LCD_ShowNum(2,4+InputLength,NowNumber,1);        //将所按的数字显示在屏幕上
  212.                                         MinNumber*=10;MinNumber+=NowNumber;
  213.                                         MinLength++;
  214.                                 }
  215.                         }
  216.                         if(ConfirmFlag || InputLength==4)        //如果按了确认键，或者输入长度达到4
  217.                         {
  218.                                 if(SetMaxFlag)        //如果是正在设置最大值
  219.                                 {
  220.                                         SetMaxFlag=0;        //正在设置最大值的标志置0
  221.                                         ConfirmFlag=0;        //确认的标志置0
  222.                                         LastInputLength=0;
  223.                                         InputLength=0;
  225.                                         CheckFlag=1;        //检查范围是否合理的标志置1
  226.                                 }
  227.                                 if(SetMinFlag)        //如果是正在设置最小值
  228.                                 {
  229.                                         SetMinFlag=0;        //正在设置最小值的标志置0
  230.                                         ConfirmFlag=0;
  231.                                         LastInputLength=0;
  232.                                         InputLength=0;
  234.                                         LCD_SetCursor(2,13);        //光标设置在第2行第13列
  235.                                         SetMaxFlag=1;        //正在设置最大值的标志置1
  236.                                 }
  237.                         }
  238.                         if(CheckFlag)        //如果检查范围是否合理的标志为真
  239.                         {
  240.                                 CheckFlag=0;        //标志置0
  241.                                 if(MinNumber+1<MaxNumber)        //如果最小值要比最大值小，且最小值和最大值要至少相差2
  242.                                 {        //说明设置得合理
  243.                                         Mode=2;        //切换到玩家输入数字猜测的界面
  244.                                         OnceFlag=1;
  245.                                 }
  246.                                 else        //如果不合理
  247.                                 {
  248.                                         OnceFlag=1;        //重置，即初始化
  249.                                         LCD_ShowString(1,14,"ERR");        //第一行后三个位置显示错误的英文的前三个字母
  250.                                         Delay(1000);        //延时1s
  251.                                 }
  252.                         }
  253.                         if(ReenterFlag)        //如果重新输入的标志为真
  254.                         {
  255.                                 ReenterFlag=0;        //标志置0
  256.                                 if(SetMinFlag)        //如果是正在设置最小值
  257.                                 {
  258.                                         LastInputLength=0;
  259.                                         InputLength=0;
  260.                                         MinNumber=0;
  261.                                         MinLength=0;
  262.                                         LCD_ShowString(2,5,"    ");        //清空显示
  263.                                         LCD_SetCursor(2,5);        //光标设置在第2行第5列
  264.                                 }
  265.                                 if(SetMaxFlag)        //如果是正在设置最大值
  266.                                 {
  267.                                         LastInputLength=0;
  268.                                         InputLength=0;
  269.                                         MaxNumber=0;
  270.                                         MaxLength=0;
  271.                                         LCD_ShowString(2,13,"    ");        //清空显示
  272.                                         LCD_SetCursor(2,13);        //光标设置在第2行第13列
  273.                                 }
  274.                         }
  275.                 }
  277.                 else if(Mode==2)        //猜数字过程
  278.                 {
  279.                         if(OnceFlag)
  280.                         {
  281.                                 OnceFlag=0;
  283.                                 //初始化
  284.                                 LastInputLength=0;
  285.                                 InputLength=0;
  286.                                 ConfirmFlag=0;
  287.                                 srand(TL0);        //每次进入此if，以定时器低八位做随机数的种子
  288.                                 //RandomNumber=(rand()%(MaxNumber-MinNumber-1)+MinNumber+1);        //这样也可以，但是发现产生的随机数很集中
  289.                                 //按下面这样，利用定时器0的高低八位来使计算复杂一些，产生的随机数更加随机
  290.                                 RandomNumber=((rand()+TH0*TL0+TL0/TH0)*(TH0-TL0)%(MaxNumber-MinNumber-1)+MinNumber+1);//产生一个所设置范围内的随机数（不包含最小值和最大值）
  291.                                 LCD_Clear();
  292.                                 LCD_ShowString(1,1,"Range:");
  293.                                 LCD_ShowNum(1,8,MinNumber,MinLength);
  294.                                 LCD_ShowChar(1,8+MinLength,'~');        //显示一个右箭头→
  295.                                 LCD_ShowNum(1,9+MinLength,MaxNumber,MaxLength);
  296.                                 LCD_SetCursor(2,1);        //设置光标在第2行第1列
  297.                         }
  298.                         if(LastInputLength!=InputLength)
  299.                         {
  300.                                 LastInputLength=InputLength;
  301.                                 LCD_ShowNum(2,InputLength,NowNumber,1);
  302.                                 PlayerNumber*=10;PlayerNumber+=NowNumber;
  303.                                 PlayerLength++;
  304.                         }
  305.                         if(ConfirmFlag || InputLength==4)
  306.                         {
  307.                                 ConfirmFlag=0;
  308.                                 LastInputLength=0;
  309.                                 InputLength=0;
  310.                                 GuessTimes++;        //每比较一次，猜的次数增加一
  312.                                 if(PlayerNumber==RandomNumber)        //如果输入的数字跟随机数字相等
  313.                                 {        //说明猜对了
  314.                                         Mode=3;        //切换到下一模式
  315.                                         OnceFlag=1;
  316.                                 }
  317.                                 else if(PlayerNumber<RandomNumber && PlayerNumber>MinNumber)        //如果输入数字小于随机数，且大于范围最小值
  318.                                 {
  319.                                         MinNumber=PlayerNumber;
  320.                                         MinLength=PlayerLength;
  321.                                 }
  322.                                 else if(PlayerNumber>RandomNumber && PlayerNumber<MaxNumber)        //如果输入数字大于随机数，且小于范围最大值
  323.                                 {
  324.                                         MaxNumber=PlayerNumber;
  325.                                         MaxLength=PlayerLength;
  326.                                 }
  327.                                 else        //如果不是以上情况，说明输入的数字不在范围内
  328.                                 {
  329.                                         GuessTimes--;        //输入错误不算次数
  330.                                         LCD_ShowString(2,14,"ERR");        //第2行最后三个位置显示错误的英文的前三个字母
  331.                                         Delay(1000);        //延时1s
  332.                                         LCD_ShowString(2,14,"   ");        //清空三个英文字母的显示
  333.                                 }
  334.                                 PlayerNumber=0;        //玩家输入的数字清0
  335.                                 PlayerLength=0;        //玩家输入数字的位数清零
  337.                                 LCD_ShowString(1,8,"         ");        //第1行右半屏清空显示
  338.                                 LCD_ShowNum(1,8,MinNumber,MinLength);
  339.                                 LCD_ShowChar(1,8+MinLength,'~');
  340.                                 LCD_ShowNum(1,9+MinLength,MaxNumber,MaxLength);        //根据玩家输入的数字显示缩小后的范围
  341.                                 LCD_SetCursor(2,1);
  342.                                
  343.                                 LastInputLength=0;
  344.                                 InputLength=0;
  345.                                 LCD_ShowString(2,1,"    ");        //清空玩家输入的数字
  346.                                 LCD_SetCursor(2,1);        //设置光标在第2行第1列
  347.                         }
  348.                         if(ReenterFlag)
  349.                         {
  350.                                 ReenterFlag=0;
  351.                                 LastInputLength=0;
  352.                                 InputLength=0;
  353.                                 PlayerNumber=0;        //玩家输入的数字清0
  354.                                 PlayerLength=0;        //玩家输入数字的位数清零
  355.                                 LCD_ShowString(2,1,"    ");
  356.                                 LCD_SetCursor(2,1);
  357.                         }
  359.                 }
  360.                 else if(Mode==3)        //猜中之后的屏幕显示
  361.                 {
  362.                         if(OnceFlag)
  363.                         {
  364.                                 OnceFlag=0;
  366.                                 LCD_Clear();
  368.                                 LCD_ShowString(1,1,"Yes!");
  369.                                 LCD_ShowString(1,6,"Number:");
  370.                                 if(RandomNumber/1000){RandomLength=4;}
  371.                                 else if(RandomNumber/100){RandomLength=3;}
  372.                                 else if(RandomNumber/10){RandomLength=2;}
  373.                                 else{RandomLength=1;}
  374.                                 LCD_ShowNum(1,13,RandomNumber,RandomLength);
  376.                                 LCD_ShowString(2,1,"Times:");
  377.                                 if(GuessTimes/1000){GuessLength=4;}
  378.                                 else if(GuessTimes/100){GuessLength=3;}
  379.                                 else if(GuessTimes/10){GuessLength=2;}
  380.                                 else{GuessLength=1;}
  381.                                 LCD_ShowNum(2,7,GuessTimes,GuessLength);
  383.                                 LCD_IsShowCursor(0);
  384.                         }
  385.                 }
  388.         }
  389. }
  391. /**
  392.   * 函    数：定时器0中断函数
  393.   * 参    数：无
  394.   * 返 回 值：无
  395.   */
  396. void Timer0_Routine() interrupt 1
  397. {
  398.         static unsigned char T0Count1;        //定时器0计数变量
  399.         TL0=0x00;        //设置定时初值，定时10ms，12T@11.0592MHz
  400.         TH0=0xDC;        //设置定时初值，定时10ms，12T@11.0592MHz
  401.         T0Count1++;
  402.         if(T0Count1>=2)        //每隔20ms检测一次按键
  403.         {
  404.                 T0Count1=0;
  405.                 MatrixKey_Tick();
  406.         }
  407. }
复制代码
总结

根据设置的范围产生真随机数这一块，感觉还必要改进一下。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

王柳

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

渠道 国产数据库 集成商 AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表