设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › stm32航模无刷电机遥控驱动程序-里面有很多模块lcd键盘2 ...
返回列表 发新帖
查看: 4517|回复: 0
收起左侧

stm32航模无刷电机遥控驱动程序-里面有很多模块lcd键盘24l01主机和丛机程序一体

[复制链接]
ID:130231 发表于 2017-5-10 15:55 | 显示全部楼层 |阅读模式
stm32航模无刷电机遥控驱动程序-里面有很多模块lcd键盘24l01主机和丛机程序一体

单片机源码：
  1. #include "Defineall.h"
  2. #include "stm32f10x.h"
  3. #include "stdio.h"
  4. uchar Key_NumberKeyInputTimes=0;

  6. void Key_Init(void)
  7. {
  8.         GPIO_InitTypeDef        GPIO_InitStructure;
  9.         EXTI_InitTypeDef        EXTI_InitStructure;
  10.         NVIC_InitTypeDef        NVIC_InitStructure;
  11.        
  12.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO,ENABLE);
  13.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;//键盘纵轴，用作中断输入(下拉电阻，上升沿)
  14.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPD;
  15.         GPIO_Init(GPIOB,&GPIO_InitStructure);
  16.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9;//键盘横轴，输出
  17.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
  18.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_2MHz;
  19.         GPIO_Init(GPIOB,&GPIO_InitStructure);
  20.        
  21.         GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9);//拉高X轴

  23.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource12);                //将GPIO连接到外部中断
  24.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource13);
  25.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource14);
  26.         GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource15);
  27.        
  28.         EXTI_InitStructure.EXTI_Line=EXTI_Line12|EXTI_Line13|EXTI_Line14|EXTI_Line15;//Y轴做中断
  29.         EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
  30.         EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Rising;//上升沿
  31.         EXTI_InitStructure.EXTI_LineCmd=ENABLE;
  32.         EXTI_Init(&EXTI_InitStructure);
  33. //        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  34.         NVIC_InitStructure.NVIC_IRQChannel=EXTI15_10_IRQn;
  35.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
  36.         NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
  37.         NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
  38.         NVIC_Init(&NVIC_InitStructure);
  39. }
  40. void EXTI15_10_IRQHandler(void)
  41. {
  42.         char KeyValue=0;
  43.         uint16_t KeyValueStatus=0;
  44.         uchar KeyValueY=0,KeyValueX=0;
  45.         uchar Times=0;
  46.         uint TestKeyValue=GPIO_Pin_6;
  47.         EXTI_ClearITPendingBit(EXTI_Line12|EXTI_Line13|EXTI_Line14|EXTI_Line15);//复位中断挂起标志位，防止因为中断挂起标志位置位，反复进入中断
  48.         EXTI->IMR&=~(EXTI_Line12|EXTI_Line13|EXTI_Line14|EXTI_Line15);//暂时关闭中断，防止抖动触发中断，待处理完成后再次开启中断
  49.         DelayMs(30);//消除抖动
  50.         if((GPIO_ReadInputData(GPIOB)&0XF000)!=0X0000)//检查是否按键仍旧处于按下状态。无按键按下时GPIOB Bit15_12(下拉电阻)的值都为低。
  51.         {
  52.                 //Led亮
  53.                 KeyValueStatus=GPIO_ReadInputData(GPIOB);
  54.                 KeyValueY=(uchar)(KeyValueStatus>>12)&0X0F;
  55.                 for(Times=0;Times<4;Times++)        //检测纵轴
  56.                 {
  57.                         if((KeyValueY&0X01)==0X01)
  58.                         {
  59.                                 KeyValueY=Times*4;
  60.                                 break;
  61.                         }
  62.                         KeyValueY=KeyValueY>>1;
  63.                 }
  64.                 for(Times=0;Times<4;Times++)//检测横轴
  65.                 {
  66.                         GPIO_ResetBits(GPIOB,TestKeyValue);
  67.                         if((GPIO_ReadInputData(GPIOB)&0XF000)==0X0000)
  68.                         {
  69.                                 KeyValueX=Times+1;
  70.                                 break;
  71.                         }
  72.                         TestKeyValue=TestKeyValue<<1;
  73.                 }
  74.                 KeyValue=KeyValueX+KeyValueY;
  75.                 GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9);//拉高X轴
  76.                 do
  77.                 {
  78.                         KeyValueStatus=GPIO_ReadInputData(GPIOB)&0XF000;
  79.                         DelayMs(1);
  80.                 }
  81.                 while(KeyValueStatus==0X0000);//等待按键释放
  82.                 //led灭
  83. //                printf("KeyValueY:%d\n",KeyValueY+KeyValueX);
  84.                         Key_Redefine((char)KeyValue);
  85.         }
  86.         EXTI->IMR|=(EXTI_Line12|EXTI_Line13|EXTI_Line14|EXTI_Line15);//开启中断
  87. }
  88. /***************************
  89. 按键分布
  90. 1        2        3 Enter                                //        1                2                3                4
  91. 4        5        6        Return                        //        5                6                7                8
  92. 7        8        9        Delete                        //        9                10        11        12
  93.                 0                        Home                        //        13        14        15        16
  94. ****************************/
  95. void Key_Redefine(uchar KeyValue)//重定义按键
  96. {
  97.         switch(KeyValue)
  98.         {
  99.                 case        1:        KeyValue=1;break;
  100.                 case        2:        KeyValue=2;break;
  101.                 case        3:        KeyValue=3;break;
  102.                 case        4:        KeyValue=KeyEnter;break;//11
  103.                 case        5:        KeyValue=4;break;
  104.                 case        6:        KeyValue=5;break;
  105.                 case        7:        KeyValue=6;break;
  106.                 case        8:        KeyValue=KeyReturn;break;//12
  107.                 case        9:        KeyValue=7;break;
  108.                 case        10:        KeyValue=8;break;
  109.                 case        11:        KeyValue=9;break;
  110.                 case        12:        KeyValue=KeyDelete;break;//13
  111.                 case        13:        KeyValue=KeyUp;break;//15
  112.                 case        14:        KeyValue=0;break;
  113.                 case        15:        KeyValue=KeyDown;break;//16
  114.                 case        16:        KeyValue=KeyHome;break;//14
  115.                 default:break;
  116.         }
  117.         printf("键值是:%d\n",KeyValue);
  118.         Key_Check(KeyValue);
  119. }
  120. void Key_Check(uchar KeyValue)//检查当前页面,以确定需要传递处理和屏蔽的干扰按键
  121. {
  122.         uchar LcdPageChecked=Lcd_PageStatusCheck();
  123.         switch(LcdPageStatus)
  124.         {
  125.                 case Lcd_LogoPage:       
  126.                 {
  127.                         Key_Proccess(LcdPageChecked,KeyValue);
  128.                         break;               
  129.                 }
  130.                
  131.                 case        Lcd_PasswordInputPage:
  132.                 {
  133.                                 if((KeyValue!=KeyUp)||(KeyValue!=KeyDown))
  134.                                 {
  135.                                         Key_Proccess(LcdPageChecked,KeyValue);
  136.                                 }
  137.                                 break;
  138.                 }
  139.                        
  140.                 case Lcd_MainPage:       
  141.                 {
  142.                                 if((KeyValue!=KeyDelete)||(KeyValue!=KeyEnter))
  143.                                 {
  144.                                         Key_Proccess(LcdPageChecked,KeyValue);
  145.                                 }                                       
  146.                                 break;
  147.                 }
  148.                 case Lcd_PasswordRightPage:
  149.                 {
  150.                                 Key_Proccess(LcdPageChecked,KeyValue);
  151.                                 break;
  152.                 }
  153.                 case Lcd_PasswordFaultPage:
  154.                 {
  155.                         Key_Proccess(LcdPageChecked,KeyValue);
  156.                         break;
  157.                 }
  158.                 default:break;
  159.         }
  160. }
  161. void Key_ClearInputInformation(void)//清除输入信息
  162. {
  163.         uchar Times=0;
  164.         Key_NumberKeyInputTimes=0;
  165.         for(Times=0;Times<MotorPasswordLength;Times++)
  166.         {
  167.                 MotorPassWordInput[Times]=0;
  168.         }
  169. }
  170. void Lcd_RefreshCommandStatus(uchar Selection)
  171. {
  172.                 Lcd_ClearScreen(1,1,16);
  173.                 if(Selection==1)
  174.                 {
  175.                         Lcd_PrintString(1,1,"Rsing");
  176.                 }
  177.                 else if(Selection==0)
  178.                 {
  179.                         Lcd_PrintString(1,1,"Downiing");                       
  180.                 }
  181.                 else
  182.                 {
  183.                         Lcd_PrintString(1,1,"No Operation");                                       
  184.                 }
  185.                 Lcd_PrintAByte(4,6,Motor_PowerLevelSatatus+0x30);
  186.                 Lcd_DisplayPosition(4,8);
  187.                 Lcd_PrintString(4,1,"Th");
  188.                 //Lcd_PrintAByte(4,7,'%');
  189. }
  190. void Key_Proccess(uchar PageStatusChecked,uchar KeyValue)
  191. {
  192.         uchar Times=0;
  193.         switch(PageStatusChecked)
  194.         {
  195.                 case Lcd_LogoPage:
  196.                         if(MotorPasswordRightFlag==1)
  197.                         {
  198.                                 Lcd_PageCreate(Lcd_MainPage);
  199.                         }
  200.                         else
  201.                         {
  202.                                 Lcd_PageCreate(Lcd_PasswordInputPage);
  203.                         }
  204.                 break;
  205.                        
  206.                 case Lcd_MainPage:
  207.                 if(KeyValue>9)
  208.                 {
  209.                         switch(KeyValue)
  210.                         {
  211.                                 case KeyHome:
  212.                                         Motor_PowerLevelSatatus=0;
  213.                                         Motor_PowerLevelSatatus=0;
  214.                                         Motor_PowerLevelPast=0;
  215.                                         Lcd_PageCreate(Lcd_LogoPage);
  216.                                         Motor_SendCammand(Motor_SetPowerLevel,Motor_PowerLevelSatatus);                        //发送
  217.                                         printf("已经向从机发送了将至最低功率命令\n");
  218.                                 break;
  219.                                 case KeyReturn:
  220.                                         Motor_PowerLevelSatatus=0;
  221.                                         Motor_PowerLevelPast=0;
  222.                                         Lcd_PageCreate(Lcd_LogoPage);
  223.                                         Motor_SendCammand(Motor_SetPowerLevel,Motor_PowerLevelSatatus);                        //发送
  224.                                         printf("已经向从机发送了将至最低功率命令\n");
  225.                                 break;
  226.                                
  227.                                 case KeyDelete:__nop();break;
  228.                                 case KeyEnter:__nop();break;
  229.                                
  230.                                 case KeyUp:
  231.                                         if(Motor_PowerLevelSatatus>=9)
  232.                                         {
  233.                                                 Motor_PowerLevelSatatus=9;
  234.                                                 Lcd_RefreshCommandStatus(2);//无操作
  235.                                                 Motor_SendCammand(Motor_SetMotorPowerHigher,Motor_PowerLevelSatatus);                                                //发送
  236.                                                 printf("已经向从机发送了无操作命令\n");
  237.                                         }
  238.                                         else
  239.                                         {
  240.                                                 Lcd_RefreshCommandStatus(1);        //显示加速
  241.                                                 Motor_PowerLevelSatatus++;
  242.                                                 Motor_SendCammand(Motor_SetMotorPowerHigher,Motor_PowerLevelSatatus);                                                //发送
  243.                                                 printf("已经向从机发送了加速命令\n");
  244.                                         }                                                       
  245.                                 break;
  246.                                        
  247.                                 case KeyDown:
  248.                                         if(Motor_PowerLevelSatatus<=0)               
  249.                                         {
  250.                                                 Motor_PowerLevelSatatus=0;
  251.                                                 Lcd_RefreshCommandStatus(2);//无操作
  252.                                                 Motor_SendCammand(Motor_SetMotorPowerLower,Motor_PowerLevelSatatus);                                                //发送
  253.                                                 printf("已经向从机发送了无操作命令\n");
  254.                                         }
  255.                                         else
  256.                                         {
  257.                                                 Lcd_RefreshCommandStatus(0);//显示减速
  258.                                                 Motor_PowerLevelSatatus--;
  259.                                                 Motor_SendCammand(Motor_SetMotorPowerLower,Motor_PowerLevelSatatus);                                                //发送
  260.                                                 printf("已经向从机发送了减速命令\n");
  261.                                         }                                                       
  262.                                 break;
  263.                                 default:break;
  264.                         }
  265.                 }
  266.                 else
  267.                 {
  268.                                 Motor_PowerLevelPast=Motor_PowerLevelSatatus;
  269.                                 Motor_PowerLevelSatatus=KeyValue;
  270.                                 if(Motor_PowerLevelPast<Motor_PowerLevelSatatus)
  271.                                 {
  272.                                                 Lcd_RefreshCommandStatus(1);//显示提速
  273.                                                 printf("已将功率大小信息发送到从机(提速)\n");
  274.                                 }
  275.                                 if(Motor_PowerLevelPast>Motor_PowerLevelSatatus)
  276.                                 {
  277.                                                 Lcd_RefreshCommandStatus(0);//显示减速
  278.                                                 printf("已将功率大小信息发送到从机(减速)\n");
  279.                                 }
  280.                                 if(Motor_PowerLevelPast==Motor_PowerLevelSatatus)
  281.                                 {
  282.                                         Lcd_RefreshCommandStatus(2);//显示无操作
  283.                                                 printf("已将功率大小信息发送到从机(无操作)\n");
  284.                                 }
  285.                                 Motor_SendCammand(Motor_SetPowerLevel,Motor_PowerLevelSatatus);                        //发送
  286.                 }
  287.                 break;
  288.                
  289.                 case Lcd_PasswordInputPage:
  290.                         if(KeyValue>9)
  291.                         {
  292.                                 switch(KeyValue)
  293.                                 {
  294.                                         case KeyDelete:
  295.                                                 Key_ClearInputInformation();//        清除输入信息
  296.                                                 Lcd_PageCreate(Lcd_PasswordInputPage);//返回重新输入                                               
  297.                                         break;
  298.                                        
  299.                                         case        KeyHome:
  300.                                                 Key_ClearInputInformation();//        清除输入信息
  301.                                                 Lcd_PageCreate(Lcd_LogoPage);//返回logo               
  302.                                         break;                                       
  303.                                        
  304.                                         case        KeyReturn:
  305.                                                 Key_ClearInputInformation();//        清除输入信息
  306.                                                 Lcd_PageCreate(Lcd_LogoPage);//返回logo                                       
  307.                                         break;               

  309.                                         case KeyEnter:
  310.                                                 if((Key_NumberKeyInputTimes==MotorPasswordLength)&&(Motor_CheckPassword()==1))//密码正确,验证输入次数的目的是防止密码是8个0
  311.                                                 {
  312.                                                         Key_ClearInputInformation();
  313.                                                         Lcd_PageCreate(Lcd_PasswordRightPage);
  314.                                                         Motor_SendCammand(Motor_InitESC,1);
  315.                                                         DelayMs(5000);//等待电调初始化才能操作
  316.                                                         Lcd_PageCreate(Lcd_MainPage);//进入主菜单
  317.                                                         printf("已经向从机发送了解锁命令\n");
  318.                                                 }               
  319.                                                 else
  320.                                                 {
  321.                                                         Key_ClearInputInformation();
  322.                                                         Lcd_PageCreate(Lcd_PasswordFaultPage);//进入输入密码出错页面
  323.                                                 }
  324.                                         break;
  325.                                         default:break;
  326.                                 }
  327.                         }
  328.                         else//数字输入
  329.                         {
  330.                                 Key_NumberKeyInputTimes=Key_NumberKeyInputTimes+1;
  331.                                 printf("输入数字次数是:%d\n",Key_NumberKeyInputTimes);
  332.                                 if(Key_NumberKeyInputTimes>8)
  333.                                 {
  334.                                                 Key_NumberKeyInputTimes=0;
  335.                                 }
  336.                                 else
  337.                                 {
  338.                                         MotorPassWordInput[Key_NumberKeyInputTimes-1]        =KeyValue;                               
  339.                                         Lcd_DisplayPosition(4,Key_NumberKeyInputTimes);                       
  340.                                         Lcd_WriteAByte(0,MotorPassWordInput[Key_NumberKeyInputTimes-1]+0X30);
  341.                                         Lcd_DisplayPosition(4,Key_NumberKeyInputTimes);                       
  342.                                         Lcd_WriteAByte(0,MotorPassWordInput[Key_NumberKeyInputTimes-1]+0X30);
  343.                                         for(Times=0;Times<8;Times++)
  344.                                         {
  345.                                                 printf("输入的密码是:%d\n",MotorPassWordInput[Times]);
  346.                                         }
  347.                                 }
  348.                         }
  349.                         break;
  350.                        
  351.                         case Lcd_PasswordFaultPage:
  352.                                 Lcd_PageCreate(Lcd_PasswordInputPage);
  353.                         break;
  354.                        
  355.                         case Lcd_PasswordRightPage:
  356.                                 if(Motor_BSCInitCompleteFlag==1)//电调没完成初始化时用户不能自行操作,要等待系统完成初始化后自动返回.
  357.                                 {
  358.                                         switch(KeyValue)
  359.                                         {
  360.                                                 case KeyHome:Lcd_PageCreate(Lcd_LogoPage);break;
  361.                                                 case KeyReturn:Lcd_PageCreate(Lcd_LogoPage);break;
  362.                                                 default:break;
  363.                                         }
  364.                                 }
  365.                                 else       
  366.                                 {
  367.                                         __nop();
  368.                                 }
  369.                         break;
  370.                         default:break;
  371.         }
  372. }

  374. //void Key_Proccess(char KeyValue)
  375. //{
  376. //        uchar Key_NumberInputFlag=1;
  377. //        if(KeyValue>9)
  378. //        {
  379. //                Key_NumberInputFlag=0;//我规定了键0-9是数字键.11-16是功能键
  380. //        }
  381. //        //下面启动页的
  382. //        switch(KeyValue)
  383. //        {
  384. //                case Lcd_LogoPage:
  385. //                {
  386. //                        if(Motor_CheckPassword()==1)//先检查密码是否正确
  387. //                        {
  388. //                                Lcd_PageCreate(Lcd_MainPage);
  389. //                        }
  390. //                        else
  391. //                        {
  392. //                                        Lcd_PageCreate(Lcd_PasswordInputPage);
  393. //                        }
  394. //                        break;
  395. //                }

  397. ////下面是密码输入正确的页面       
  398. //                case Lcd_PasswordRightPage:
  399. //                {
  400. //                        Lcd_PageCreate(Lcd_MainPage);//进入调速页
  401. //                        break;               
  402. //                }
  403. ////密码输入错误页面
  404. //                case Lcd_PasswordFaultPage:
  405. //                {
  406. //                        switch(KeyValue)
  407. //                        {
  408. //                                case KeyReturn:Lcd_PageCreate(Lcd_PasswordInputPage);break;
  409. //                                case        KeyHome:Lcd_PageCreate(Lcd_LogoPage);break;
  410. //                                case KeyEnter:Lcd_PageCreate(Lcd_PasswordInputPage);break;
  411. //                                default:break;
  412. //                        }
  413. //                        break;
  414. //                }
  415. ////密码输入页面
  416. //                case        Lcd_PasswordInputPage:
  417. //                {
  418. //                        if(Key_NumberInputFlag==1)//检查是否是数字输入
  419. //                        {
  420. //                                Key_NumberKeyInputTimes++;//开启数字进入次数计数;
  421. //                                        if(Key_NumberKeyInputTimes<=MotorPasswordLength)
  422. //                                        {
  423. //                                                MotorPassWordInput[Key_NumberKeyInputTimes-1]        =KeyValue;       
  424. //                                                Lcd_PrintAByte(4,Key_NumberKeyInputTimes,MotorPassWordInput[Key_NumberKeyInputTimes-1]+0X30);
  425. //                                        }       
  426. //                                        if(Key_NumberKeyInputTimes>=MotorPasswordLength)
  427. //                                        {
  428. //                                                Key_NumberKeyInputTimes=0;
  429. //                                        }
  430. //                        }
  431. //                        else
  432. //                        {
  433. //                                switch(KeyValue)
  434. //                                {
  435. //                                        case KeyReturn:
  436. //                                        {
  437. //                                                Lcd_PageCreate(Lcd_LogoPage);
  438. //                                                Key_ClearInputInformation();
  439. //                                                break;
  440. //                                        }
  441. //                                        case        KeyHome:
  442. //                                        {
  443. //                                                Lcd_PageCreate(Lcd_LogoPage);
  444. //                                                Key_ClearInputInformation();
  445. //                                                break;                                               
  446. //                                        }
  447. //                                        case KeyEnter:
  448. //                                        {
  449. //                                                if((Key_NumberKeyInputTimes==MotorPasswordLength)&&(Motor_CheckPassword()==1))//密码正确,验证输入次数的目的是防止密码是8个0
  450. //                                                {
  451. //                                                        Key_ClearInputInformation();
  452. //                                                        Lcd_PageCreate(Lcd_MainPage);//进入主菜单
  453. //                                                }
  454. //                                                break;
  455. //                                        }
  456. //                                        case KeyDelete:
  457. //                                        {
  458. //                                                Key_ClearInputInformation();//        清除输入信息
  459. //                                                Lcd_PageCreate(Lcd_PasswordInputPage);//返回重新输入
  460. //                                                break;
  461. //                                        }
  462. //                                        default:break;
  463. //                                }
  464. //                        }
  465. //                        break;
  466. //                }
  467. ////下面是主页的       
  468. //                case Lcd_MainPage:
  469. //                {
  470. //                        if((KeyValue==KeyReturn)||(KeyValue==KeyHome))
  471. //                        {
  472. //                                Lcd_PageCreate(Lcd_LogoPage);
  473. //                                Key_ClearInputInformation();
  474. //                        }
  475. //                        break;
  476. //                }

  478. //                default:break;
  479. //        }
  480. //}


  483. //void Key_Proccess(char KeyValue)
  484. //{
  485. //        uchar Motor_PowerLevelPast=0;
  486. //        switch(LcdPageStatus)
  487. //        {
  488. //                case Lcd_LogoPage:       
  489. //                {
  490. //                                if(Motor_CheckPassword())
  491. //                                {
  492. //                                        Lcd_PageCreate(Lcd_MainPage);                                       
  493. //                                }
  494. //                                else
  495. //                                {
  496. //                                        Lcd_PageCreate(Lcd_PasswordInputPage);                               
  497. //                                }
  498. //                                break;
  499. //                }
  500. //               
  501. //                case        Lcd_PasswordInputPage:                       
  502. //                {
  503. ////                                if((KeyValue>=0)||(KeyValue<=9))//数字输入
  504. //                        switch(KeyValue)
  505. //                        {
  506. //                                case KeyEnter:
  507. //                                {
  508. //                                        if(Key_NumberKeyInputTimes==MotorPasswordLength)
  509. //                                        {
  510. //                                                if(Motor_CheckPassword()==1)//密码正确
  511. //                                                {
  512. //                                                        //提示密码正确,等待机器初始化
  513. //                                                        Key_ClearInputInformation();
  514. //                                                        Lcd_PageCreate(Lcd_PasswordRightPage);
  515. //                                                }
  516. //                                                else
  517. //                                                {
  518. //                                                        //页面提示密码错误,清楚输入并返回输入界面
  519. //                                                        Key_ClearInputInformation();
  520. //                                                        Lcd_PageCreate(Lcd_PasswordFaultPage);
  521. //                                                }
  522. //                                        }                                       
  523. //                                        break;
  524. //                                }
  525. //                               
  526. //                                case KeyDelete:
  527. //                                {
  528. //                                        Key_ClearInputInformation();
  529. //                                        Lcd_PageCreate(Lcd_PasswordInputPage);                                               
  530. //                                        break;
  531. //                                }
  532. //                                case KeyHome:
  533. //                                {
  534. //                                        Key_ClearInputInformation();
  535. //                                        Lcd_PageCreate(Lcd_LogoPage);                                               
  536. //                                        break;
  537. //                                }
  538. //                               
  539. //                                case KeyReturn:
  540. //                                {
  541. //                                        Key_ClearInputInformation();
  542. //                                        Lcd_PageCreate(Lcd_LogoPage);                                               
  543. //                                        break;
  544. //                                }
  545. //                               
  546. //                                default:
  547. //                                {
  548. //                                        Key_NumberKeyInputTimes++;
  549. //                                        if(Key_NumberKeyInputTimes<=MotorPasswordLength)
  550. //                                        {
  551. //                                                MotorPassWordInput[Key_NumberKeyInputTimes-1]        =KeyValue;       
  552. //                                                Lcd_PrintAByte(4,Key_NumberKeyInputTimes,MotorPassWordInput[Key_NumberKeyInputTimes-1]+0X30);
  553. //                                        }               
  554. //                                                break;
  555. //                                }
  556. //                        }
  557. //                }
  558. ////                        if(KeyValue<=9)
  559. ////                                {
  560. ////                                        if(Key_NumberKeyInputTimes<=MotorPasswordLength)
  561. ////                                        {
  562. ////                                                Key_NumberKeyInputTimes++;
  563. ////                                                MotorPassWordInput[Key_NumberKeyInputTimes-1]        =KeyValue;       
  564. ////                                                Lcd_PrintAByte(4,Key_NumberKeyInputTimes,MotorPassWordInput[Key_NumberKeyInputTimes-1]+0X30);
  565. ////                                        }
  566. ////                                }
  567. ////                               
  568. ////                                if(KeyValue==KeyEnter)
  569. ////                                {
  570. ////                                        if(Key_NumberKeyInputTimes==MotorPasswordLength)
  571. ////                                        {
  572. ////                                                if(Motor_CheckPassword()==1)//密码正确
  573. ////                                                {
  574. ////                                                        //提示密码正确,等待机器初始化
  575. ////                                                        Key_ClearInputInformation();
  576. ////                                                        Lcd_PageCreate(Lcd_PasswordRightPage);
  577. ////                                                }
  578. ////                                                else
  579. ////                                                {
  580. ////                                                        //页面提示密码错误,清楚输入并返回输入界面
  581. ////                                                        Key_ClearInputInformation();
  582. ////                                                        Lcd_PageCreate(Lcd_PasswordInputPage);

  584. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

完整代码：
stm32航模无刷电机遥控驱动程序-里面有很多模块lcd键盘24l01主机和丛机程序一体.rar (331.18 KB, 下载次数: 51)
无刷电机, 程序, 键盘, 主机

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表