开启辅助访问

amobbs.com 阿莫电子技术论坛

登录 注册 找回密码
搜索
amobbs.com 阿莫电子技术论坛»论坛首页 › 单片机 › CortexM3 › 发一个独立键盘加六个旋转按钮的例子
bottom↓
返回列表 发新帖
回复: 7

发一个独立键盘加六个旋转按钮的例子

[复制链接]
yzstone

出0入0汤圆
发表于 2015-2-1 13:15:20 | 显示全部楼层 |阅读模式
旋转按钮的程序仿照了机器人天空的帖子，普通按键就是很普通的做法延迟去抖，开始写简单的代码，大家多多指教（本程序已经在仪器上用气了）
/*********************************************************************************************************
** Function name:       uart0SendByte
** Descriptions:        从串口0发送数据
** input parameters:    data: 发送的数据
** output parameters:   无
** Returned value:      无
*********************************************************************************************************/
void uart1SendByte (INT8U ucData)
{
    U1THR   = ucData;
    while ( (U1LSR & 0x20) == 0 );
}

/*********************************************************************************************************
** Function name:       uart1GetByte
** Descriptions:        从串口接收1字节数据，使用查询方式接收
** input parameters:    无
** output parameters:   无
** Returned value:      ucRcvData:   接收到的数据
*********************************************************************************************************/
INT8U uart1GetByte (void)
{
    INT8U ucRcvData;   
    while ((U1LSR & 0x01) == 0);                               /* 等待接收标志置位   */
    ucRcvData = U1RBR;                                         /* 读取数据           */
    return (ucRcvData);   
}
/*********************************************************************************************************
* Function Name:        uart1Isr
* Description:          UART1中断服务函数
* Input:                无
* Output:               无
* Return:               无
*********************************************************************************************************/
void uart1Isr (void)
{
//    GulNum = 0;
      
    while ((U1IIR & 0x01) == 0)
        {                                        /*  判断是否有中断挂起          */
        switch (U1IIR & 0x0E)
                {                                          /*  判断中断标志                */
        
            case 0x04:                                                  /*  接收数据中断                */
               {
                           GucRcvNew = 1;                                          /*  置接收新数据标志            */
//                for (GulNum = 0; GulNum < 8; GulNum++)                                         /*  连续接收8个字节             */
//                                        {                 
//                          GucRcvBuf[GulNum] = U1RBR;
                GucRcvBuf = U1RBR;  
//                         }               
                break;
            
            case 0x0C:                                                  /*  字符超时中断                */
                GucRcvNew = 1;
                while ((U1LSR & 0x01) == 0x01)                         /*  判断数据是否接收完毕      */
//                                {                        
//                  GucRcvBuf[GulNum] = U1RBR;
//                  GulNum++;
                                  GucRcvBuf = U1RBR;
//               }
                break;
               
            default:
                break;
        }
    }
        }
}
/*********************************************************************************************************
** Function name:       uart1GetStr
** Descriptions:        串口接收字符串
** input parameters:    pucStr:   指向接收数据数组的指针
**                      ulNum:   接收数据的个数
** output parameters:   无
** Returned value:      无
*********************************************************************************************************/
void uart1GetStr (INT8U *pucStr, INT32U ulNum)
{
    for (; ulNum > 0; ulNum--){
        *pucStr++ =  uart1GetByte ();
    }  
}

/*********************************************************************************************************
** Function name:            uart1SendStr
** Descriptions:            向串口发送字符串
** input parameters:    puiStr:   要发送的字符串指针
** output parameters:   无
** Returned value:      无
*********************************************************************************************************/
//void uart1SendStr (INT8U  const *pucStr)
//{
//    while (1){
//        if (*pucStr == '\0') break;                                     /*  遇到结束符，退出            */
//        uart1SendByte (*pucStr++);
//    }
//}
/*********************************************************************************************************
** Function name:            uart1SendStr
** Descriptions:            向串口发送字符串
** input parameters:    pucStr:  要发送的字符串指针
**                      ulNum:   要发送的数据个数
** output parameters:   无
** Returned value:      无
*********************************************************************************************************/
void uart1SendStr (INT8U const *pucStr, INT32U ulNum)
{
    INT32U i;
   
    for (i = 0; i < ulNum; i++)
        {                                        /* 发送指定个字节数据           */
        uart1SendByte (*pucStr++);
    }
}
/*********************************************************************************************************
** Function name:       uart0Init
** Descriptions:        按默认值初始化串口0的引脚和通讯参数。设置为8位数据位，1位停止位，无奇偶校验
** input parameters:    无
** output parameters:   无
** Returned value:      无
*********************************************************************************************************/
void uart1Init (void)
{
    INT16U usFdiv;
    U1LCR  = 0x83;                                                      /* 允许设置波特率               */
    usFdiv = (FPCLK / 16) / UART_BPS;                                   /* 设置波特率                   */
    U1DLM  = usFdiv / 256;
    U1DLL  = usFdiv % 256;
    U1LCR  = 0x03;                                                      /* 锁定波特率                   */
    U1FCR  = 0x07;
        U1IER  = 0x01;                                                      /* 使能接收中断                 */
}
/*********************************************************************************************************
** Function name:       Scan
** Descriptions:        独立键盘扫描
** input parameters:    无
** output parameters:   无
** Returned value:      键码编值
*********************************************************************************************************/
INT8U scan (void)
{
    INT32U temp;
        INT8U  keydata=0;
        temp=(FIO0PIN0&0xef)|((FIO0PIN1&0x8f)<<8)|((FIO0PIN2&0xff)<<16)|((FIO0PIN3&0x7f)<<24);
        if(temp!=0)
          {
                   switch(temp)
                   {
                    case 0x00200000:  keydata = 1;  break;                 /* SW1              */
                        case 0x00100000:  keydata = 2;  break;
                        case 0x00000200:  keydata = 3;  break;
                        case 0x00000800:  keydata = 4;  break;
                        case 0x00040000:  keydata = 5;  break;
                        case 0x00010000:  keydata = 6;  break;
                        case 0x00000400:  keydata = 7;  break;
                        case 0x00000008:  keydata = 8;  break;
                        case 0x00000100:  keydata = 9;  break;
                        case 0x00000080:  keydata = 10; break;
                        case 0x00000040:  keydata = 11; break;
                        case 0x00000020:  keydata = 12; break;
                        case 0x00000004:  keydata = 13; break;
                        case 0x00400000:  keydata = 14; break;
                        case 0x00080000:  keydata = 15; break;
                        case 0x00020000:  keydata = 16; break;
                        case 0x00008000:  keydata = 17; break;
                        case 0x00000001:  keydata = 18; break;
                        case 0x00000002:  keydata = 19; break;
                        case 0x10000000:  keydata = 20; break;
                        case 0x01000000:  keydata = 21; break;
                        case 0x02000000:  keydata = 22; break;
                        case 0x40000000:  keydata = 23; break;
                        case 0x20000000:  keydata = 24; break;
                        case 0x08000000:  keydata = 25; break;
                        case 0x00800000:  keydata = 26; break;
                        case 0x04000000:  keydata = 27; break;
                        default : break;
                        }
                  
     }
          return(keydata) ;
}
INT8U keyin(void)
{   
        INT8U t1,t2;
            t1=scan();
                myDelay(5);          //延时消抖
                t2=scan();
                if(t1=t2)
                   return(t1);
                else
                   return(0);
//                while(t1=t2);
}
/*********************************************************************************************************
** Function name:       knob_can
** Descriptions:        独立键盘扫描
** input parameters:    无
** output parameters:   无
** Returned value:      键码编值
*********************************************************************************************************/
INT8U knob_can (void)
{
//    INT32U knob_temp;
        INT8U  knob_data=0;
           if((knob_data=EncoderProcess(9,10,4))!=0)
                 return(knob_data) ;
           if((knob_data=EncoderProcess(16,17,8))!=0)
                 return(knob_data) ;
           if((knob_data=EncoderProcess(22,23,14))!=0)
                 return(knob_data) ;       
           if((knob_data=EncoderProcess(4,8,2))!=0)
              return(knob_data);
           if((knob_data=EncoderProcess(14,15,6))!=0)
              return(knob_data);
           if((knob_data=EncoderProcess(18,19,10))!=0)
              return(knob_data);
           if((knob_data=EncoderProcess(20,21,12))!=0)
              return(knob_data);
           if((knob_data=EncoderProcess(22,23,14))!=0)
              return(knob_data);
           if((knob_data=EncoderProcess(0,1,0))!=0)
              return(knob_data);
}
//========================================================================================
/*********************************************************************************************************
** Function name:       knob_can
** Descriptions:        独立键盘扫描
** input parameters:    无
** output parameters:   无
** Returned value:      返回键码值
*********************************************************************************************************/
     INT8U EncoderProcess(INT8U a,INT8U b,INT8U c)
      {
                  INT8U keytmp;
                  INT8U WheelNow=0x00;
                  INT16U tmpstate=((b<<8)|a);
                  switch(tmpstate)
                        {
                                 case 0x0100:
                                      WheelOld = wheelold_data[0];
                                          break;
                                case 0x0804:
                                      WheelOld = wheelold_data[1];
                                          break;
                                case 0x0A09:
                                      WheelOld = wheelold_data[2];
                                          break;
                                case 0x0F0E:
                                      WheelOld = wheelold_data[3];
                                          break;
                                case 0x1110:
                                      WheelOld = wheelold_data[4];
                                          break;
                                case 0x1312:
                                      WheelOld = wheelold_data[5];
                                          break;
                                case 0x1514:
                                      WheelOld = wheelold_data[6];
                                          break;
                                case 0x1716:
                                      WheelOld = wheelold_data[7];
                                          break;
                                 default: break;                                 
                                 }        
                         WheelNow=WheelNow<<1;
          if (GetPIN1(a)==1)
                      WheelNow=WheelNow+1;           // 读 PINA
              WheelNow=WheelNow<<1;
          if (GetPIN1(b)==1)                                  // 读 PINB
                     WheelNow=WheelNow+1;            
             WheelNow=WheelNow & 0x03;      // 将 WheelNow 的 2 - 7 位清零,保留 0- 1 两个位的状态.
          if (WheelNow==0x00)
                     return(NULL);                //当  PINA 和 PINB都为低电平时退出,低电平区不做处理
             keytmp=WheelNow;
             keytmp ^=WheelOld;          // 判断新读的数据同旧数据
          if (keytmp==0)
                     return(NULL);              // 新读的数据同旧数据一样时退出.
         
          if (WheelOld==0x01 && WheelNow==0x02)        // 是左旋转否
                      {
                              switch(tmpstate)
                        {
                                case 0x0100:
                                      wheelold_data[0]=WheelNow;
                                          break;
                                case 0x0804:
                                      wheelold_data[1]=WheelNow;
                                          break;
                                case 0x0A09:
                                      wheelold_data[2]=WheelNow;
                                          break;
                                case 0x0F0E:
                                      wheelold_data[3]=WheelNow;
                                          break;
                                case 0x1110:
                                      wheelold_data[4]=WheelNow;
                                          break;
                                case 0x1312:
                                      wheelold_data[5]=WheelNow;
                                          break;
                                case 0x1514:
                                      wheelold_data[6]=WheelNow;
                                          break;
                                case 0x1716:
                                      wheelold_data[7]=WheelNow;
                                          break;
                                 default: break;
                                 
                                 }
//                                  WheelOld=WheelNow;
//                  return(WheelLeft());         //左旋转
                                  return(knob_coding[c]);         //左旋转
              }
          else if (WheelOld==0x02 && WheelNow==0x01)  // 是右旋转否
                     {
                               switch(tmpstate)
                        {
                                case 0x0100:
                                      wheelold_data[0]=WheelNow;
                                          break;
                                case 0x0804:
                                      wheelold_data[1]=WheelNow;
                                          break;
                                case 0x0A09:
                                      wheelold_data[2]=WheelNow;
                                          break;
                                case 0x0F0E:
                                      wheelold_data[3]=WheelNow;
                                          break;
                                case 0x1110:
                                      wheelold_data[4]=WheelNow;
                                          break;
                                case 0x1312:
                                      wheelold_data[5]=WheelNow;
                                          break;
                                case 0x1514:
                                      wheelold_data[6]=WheelNow;
                                          break;
                                case 0x1716:
                                      wheelold_data[7]=WheelNow;
                                          break;
                                 default: break;
                                 
                                 }
//                                  WheelOld=WheelNow;
//                  return(WheelRight()); //右旋转
                                  return(knob_coding[c+1]);         //左旋转
             }
                  switch(tmpstate)
                {
                        case 0x0100:
                              wheelold_data[0]=WheelNow;
                                  break;
                        case 0x0804:
                              wheelold_data[1]=WheelNow;
                                  break;
                        case 0x0A09:
                              wheelold_data[2]=WheelNow;
                                  break;
                        case 0x0F0E:
                              wheelold_data[3]=WheelNow;
                                  break;
                        case 0x1110:
                              wheelold_data[4]=WheelNow;
                                  break;
                        case 0x1312:
                              wheelold_data[5]=WheelNow;
                                  break;
                        case 0x1514:
                              wheelold_data[6]=WheelNow;
                                  break;
                        case 0x1716:
                              wheelold_data[7]=WheelNow;
                                  break;
                         default: break;
                         
                         }
//                  WheelOld=WheelNow; // 保存当前值
          return(NULL); // 当  PINA 和 PINB 都为高电平时表示编码器没有动作,退出
      }

//========================================================================================
/*********************************************************************************************************
** Function name:       Key_LED
** Descriptions:        接收数据，相应的LED灯点亮
** input parameters:    无
** output parameters:   无
** Returned value:      无
*********************************************************************************************************/
void Key_LED (INT8U d)
{        INT8U led_data=0;
    led_data=d;
        FIO1SET3=0x03;
    FIO2SET =0xFFFF;
        if(led_data!=0)
           {
            switch(led_data)
                {
                        case 0x01:
                              FIO2CLR|=0x0004;
                                  break;
                        case 0x02:
                              FIO2CLR|=0x0008;
                                  break;
                        case 0x03:
                              FIO2CLR|=0x0010;
                                  break;
                        case 0x04:
                              FIO2CLR|=0x0020;
                                  break;
                        case 0x05:
                              FIO2CLR|=0x0040;
                                  break;
                        case 0x06:
                              FIO2CLR|=0x0080;
                                  break;
                        case 0x07:
                              FIO2CLR|=0x0100;
                                  break;
                        case 0x08:
                              FIO2CLR|=0x0200;
                                  break;
                        case 0x09:
                              FIO2CLR|=0x0400;
                                  break;
                        case 0x0a:
                              FIO2CLR|=0x0800;
                                  break;
                        case 0x0b:
                              FIO2CLR|=0x1000;
                                  break;
                        case 0x0c:
                              FIO2CLR|=0x2000;
                                  break;
                        case 0x0d:
                              FIO1CLR|=0x01000000;
                                  break;
                        case 0x0e:
                              FIO1CLR|=0x02000000;
                                  break;
                    case 0x10:
                              FIO1CLR|=0x04000000;
                                  break;
                         default:  break;
                         
                         }
           }
   
}
//========================================================================================

/*********************************************************************************************************
** Function name:       main
** Descriptions:        发送和接收数据
** input parameters:    无
** output parameters:   无
** Returned value:      无
*********************************************************************************************************/
int main (void)
{       
//    rcvdata=0;
   
    targetInit();                                                       /* 初始化目标板，切勿删除       */
    pinInit();                                                                                                                   /* 引脚初始化                   */
        FIO0DIR0=0x00;
        FIO0DIR1=0x00;
        FIO0DIR2=0x00;
        FIO0DIR3=0x00;
    FIO1DIR0=0x00;
        FIO1DIR1=0x00;
        FIO1DIR2=0x00;
        FIO1DIR3=0x07;
        FIO1SET3=0x07;

        FIO2DIR =0xFFFF;
        FIO2SET =0xFFFF;
        GucRcvNew = 0;                           
        PCONP = PCONP | (1<<4);                                             /* 开启串口1功能模块            */
                                                                            
        uart1Init();
        zyIsrSet(NVIC_UART1,(unsigned long)uart1Isr,PRIO_ONE);        
    while (1)
        {
           data =keyin();          
           if(data!=0&&(data!=dlay_data))
              {
                  uart1SendByte(data);                  
                  }
           dlay_data=data;

           if (GucRcvNew == 1)
           {                                           /* 判断是否有新数据             */
              GucRcvNew = 0;                          /* 清除标志                     */
                 if(GucRcvBuf!=0)
              Key_LED(GucRcvBuf);
          uart1SendByte (GucRcvBuf);
       }
                  
           data1=knob_can();
           if(data1!=0)
              {
                  uart1SendByte(data1);
                  myDelay(1);
                  }
         
        }       
}

阿莫论坛20周年了！感谢大家的支持与爱护！！

为众人抱薪者，不可使其冻毙于风雪。阿莫呼吁大家支持谭秦东医生！订单留言里面请备注：阿莫电子论坛，支持谭医生！
回复

   举报本楼层   

mcu5i51

出0入0汤圆
发表于 2015-2-1 13:29:41 | 显示全部楼层
什么东东,读键吗?
回复

   举报本楼层   

3DA502

出0入0汤圆
发表于 2015-2-1 14:22:18 | 显示全部楼层
  1. /*********************************************************************************************************
  2. ** Function name:       uart0SendByte
  3. ** Descriptions:        从串口0发送数据
  4. ** input parameters:    data: 发送的数据
  5. ** output parameters:   无
  6. ** Returned value:      无
  7. *********************************************************************************************************/
  8. void uart1SendByte (INT8U ucData)
  9. {
  10.     U1THR   = ucData;
  11.     while ( (U1LSR & 0x20) == 0 );
  12. }

  14. /*********************************************************************************************************
  15. ** Function name:       uart1GetByte
  16. ** Descriptions:        从串口接收1字节数据，使用查询方式接收
  17. ** input parameters:    无
  18. ** output parameters:   无
  19. ** Returned value:      ucRcvData:   接收到的数据
  20. *********************************************************************************************************/
  21. INT8U uart1GetByte (void)
  22. {
  23.     INT8U ucRcvData;   
  24.     while ((U1LSR & 0x01) == 0);                               /* 等待接收标志置位   */
  25.     ucRcvData = U1RBR;                                         /* 读取数据           */
  26.     return (ucRcvData);   
  27. }
  28. /*********************************************************************************************************
  29. * Function Name:        uart1Isr
  30. * Description:          UART1中断服务函数
  31. * Input:                无
  32. * Output:               无
  33. * Return:               无
  34. *********************************************************************************************************/
  35. void uart1Isr (void)
  36. {
  37. //    GulNum = 0;
  38.       
  39.     while ((U1IIR & 0x01) == 0)
  40.         {                                        /*  判断是否有中断挂起          */
  41.         switch (U1IIR & 0x0E)
  42.                 {                                          /*  判断中断标志                */
  43.         
  44.             case 0x04:                                                  /*  接收数据中断                */
  45.                {
  46.                            GucRcvNew = 1;                                          /*  置接收新数据标志            */
  47. //                for (GulNum = 0; GulNum < 8; GulNum++)                                         /*  连续接收8个字节             */
  48. //                                        {                 
  49. //                          GucRcvBuf[GulNum] = U1RBR;
  50.                 GucRcvBuf = U1RBR;  
  51. //                         }               
  52.                 break;
  53.             
  54.             case 0x0C:                                                  /*  字符超时中断                */
  55.                 GucRcvNew = 1;
  56.                 while ((U1LSR & 0x01) == 0x01)                         /*  判断数据是否接收完毕      */
  57. //                                {                        
  58. //                  GucRcvBuf[GulNum] = U1RBR;
  59. //                  GulNum++;
  60.                                   GucRcvBuf = U1RBR;
  61. //               }
  62.                 break;
  63.                
  64.             default:
  65.                 break;
  66.         }
  67.     }
  68.         }
  69. }
  70. /*********************************************************************************************************
  71. ** Function name:       uart1GetStr
  72. ** Descriptions:        串口接收字符串
  73. ** input parameters:    pucStr:   指向接收数据数组的指针
  74. **                      ulNum:   接收数据的个数
  75. ** output parameters:   无
  76. ** Returned value:      无
  77. *********************************************************************************************************/
  78. void uart1GetStr (INT8U *pucStr, INT32U ulNum)
  79. {
  80.     for (; ulNum > 0; ulNum--){
  81.         *pucStr++ =  uart1GetByte ();
  82.     }  
  83. }

  85. /*********************************************************************************************************
  86. ** Function name:            uart1SendStr
  87. ** Descriptions:            向串口发送字符串
  88. ** input parameters:    puiStr:   要发送的字符串指针
  89. ** output parameters:   无
  90. ** Returned value:      无
  91. *********************************************************************************************************/
  92. //void uart1SendStr (INT8U  const *pucStr)
  93. //{
  94. //    while (1){
  95. //        if (*pucStr == '\0') break;                                     /*  遇到结束符，退出            */
  96. //        uart1SendByte (*pucStr++);
  97. //    }
  98. //}
  99. /*********************************************************************************************************
  100. ** Function name:            uart1SendStr
  101. ** Descriptions:            向串口发送字符串
  102. ** input parameters:    pucStr:  要发送的字符串指针
  103. **                      ulNum:   要发送的数据个数
  104. ** output parameters:   无
  105. ** Returned value:      无
  106. *********************************************************************************************************/
  107. void uart1SendStr (INT8U const *pucStr, INT32U ulNum)
  108. {
  109.     INT32U i;
  110.    
  111.     for (i = 0; i < ulNum; i++)
  112.         {                                        /* 发送指定个字节数据           */
  113.         uart1SendByte (*pucStr++);
  114.     }
  115. }
  116. /*********************************************************************************************************
  117. ** Function name:       uart0Init
  118. ** Descriptions:        按默认值初始化串口0的引脚和通讯参数。设置为8位数据位，1位停止位，无奇偶校验
  119. ** input parameters:    无
  120. ** output parameters:   无
  121. ** Returned value:      无
  122. *********************************************************************************************************/
  123. void uart1Init (void)
  124. {
  125.     INT16U usFdiv;
  126.     U1LCR  = 0x83;                                                      /* 允许设置波特率               */
  127.     usFdiv = (FPCLK / 16) / UART_BPS;                                   /* 设置波特率                   */
  128.     U1DLM  = usFdiv / 256;
  129.     U1DLL  = usFdiv % 256;
  130.     U1LCR  = 0x03;                                                      /* 锁定波特率                   */
  131.     U1FCR  = 0x07;
  132.         U1IER  = 0x01;                                                      /* 使能接收中断                 */
  133. }
  134. /*********************************************************************************************************
  135. ** Function name:       Scan
  136. ** Descriptions:        独立键盘扫描
  137. ** input parameters:    无
  138. ** output parameters:   无
  139. ** Returned value:      键码编值
  140. *********************************************************************************************************/
  141. INT8U scan (void)
  142. {
  143.     INT32U temp;
  144.         INT8U  keydata=0;
  145.         temp=(FIO0PIN0&0xef)|((FIO0PIN1&0x8f)<<8)|((FIO0PIN2&0xff)<<16)|((FIO0PIN3&0x7f)<<24);
  146.         if(temp!=0)
  147.           {
  148.                    switch(temp)
  149.                    {
  150.                     case 0x00200000:  keydata = 1;  break;                 /* SW1              */
  151.                         case 0x00100000:  keydata = 2;  break;
  152.                         case 0x00000200:  keydata = 3;  break;
  153.                         case 0x00000800:  keydata = 4;  break;
  154.                         case 0x00040000:  keydata = 5;  break;
  155.                         case 0x00010000:  keydata = 6;  break;
  156.                         case 0x00000400:  keydata = 7;  break;
  157.                         case 0x00000008:  keydata = 8;  break;
  158.                         case 0x00000100:  keydata = 9;  break;
  159.                         case 0x00000080:  keydata = 10; break;
  160.                         case 0x00000040:  keydata = 11; break;
  161.                         case 0x00000020:  keydata = 12; break;
  162.                         case 0x00000004:  keydata = 13; break;
  163.                         case 0x00400000:  keydata = 14; break;
  164.                         case 0x00080000:  keydata = 15; break;
  165.                         case 0x00020000:  keydata = 16; break;
  166.                         case 0x00008000:  keydata = 17; break;
  167.                         case 0x00000001:  keydata = 18; break;
  168.                         case 0x00000002:  keydata = 19; break;
  169.                         case 0x10000000:  keydata = 20; break;
  170.                         case 0x01000000:  keydata = 21; break;
  171.                         case 0x02000000:  keydata = 22; break;
  172.                         case 0x40000000:  keydata = 23; break;
  173.                         case 0x20000000:  keydata = 24; break;
  174.                         case 0x08000000:  keydata = 25; break;
  175.                         case 0x00800000:  keydata = 26; break;
  176.                         case 0x04000000:  keydata = 27; break;
  177.                         default : break;
  178.                         }
  179.                   
  180.      }
  181.           return(keydata) ;
  182. }
  183. INT8U keyin(void)
  184. {   
  185.         INT8U t1,t2;
  186.             t1=scan();
  187.                 myDelay(5);          //延时消抖
  188.                 t2=scan();
  189.                 if(t1=t2)
  190.                    return(t1);
  191.                 else
  192.                    return(0);
  193. //                while(t1=t2);
  194. }
  195. /*********************************************************************************************************
  196. ** Function name:       knob_can
  197. ** Descriptions:        独立键盘扫描
  198. ** input parameters:    无
  199. ** output parameters:   无
  200. ** Returned value:      键码编值
  201. *********************************************************************************************************/
  202. INT8U knob_can (void)
  203. {
  204. //    INT32U knob_temp;
  205.         INT8U  knob_data=0;
  206.            if((knob_data=EncoderProcess(9,10,4))!=0)
  207.                  return(knob_data) ;
  208.            if((knob_data=EncoderProcess(16,17,8))!=0)
  209.                  return(knob_data) ;
  210.            if((knob_data=EncoderProcess(22,23,14))!=0)
  211.                  return(knob_data) ;        
  212.            if((knob_data=EncoderProcess(4,8,2))!=0)
  213.               return(knob_data);
  214.            if((knob_data=EncoderProcess(14,15,6))!=0)
  215.               return(knob_data);
  216.            if((knob_data=EncoderProcess(18,19,10))!=0)
  217.               return(knob_data);
  218.            if((knob_data=EncoderProcess(20,21,12))!=0)
  219.               return(knob_data);
  220.            if((knob_data=EncoderProcess(22,23,14))!=0)
  221.               return(knob_data);
  222.            if((knob_data=EncoderProcess(0,1,0))!=0)
  223.               return(knob_data);
  224. }
  225. //========================================================================================
  226. /*********************************************************************************************************
  227. ** Function name:       knob_can
  228. ** Descriptions:        独立键盘扫描
  229. ** input parameters:    无
  230. ** output parameters:   无
  231. ** Returned value:      返回键码值
  232. *********************************************************************************************************/
  233.      INT8U EncoderProcess(INT8U a,INT8U b,INT8U c)
  234.       {
  235.                   INT8U keytmp;
  236.                   INT8U WheelNow=0x00;
  237.                   INT16U tmpstate=((b<<8)|a);
  238.                   switch(tmpstate)
  239.                         {
  240.                                  case 0x0100:
  241.                                       WheelOld = wheelold_data[0];
  242.                                           break;
  243.                                 case 0x0804:
  244.                                       WheelOld = wheelold_data[1];
  245.                                           break;
  246.                                 case 0x0A09:
  247.                                       WheelOld = wheelold_data[2];
  248.                                           break;
  249.                                 case 0x0F0E:
  250.                                       WheelOld = wheelold_data[3];
  251.                                           break;
  252.                                 case 0x1110:
  253.                                       WheelOld = wheelold_data[4];
  254.                                           break;
  255.                                 case 0x1312:
  256.                                       WheelOld = wheelold_data[5];
  257.                                           break;
  258.                                 case 0x1514:
  259.                                       WheelOld = wheelold_data[6];
  260.                                           break;
  261.                                 case 0x1716:
  262.                                       WheelOld = wheelold_data[7];
  263.                                           break;
  264.                                  default: break;                                 
  265.                                  }        
  266.                          WheelNow=WheelNow<<1;
  267.           if (GetPIN1(a)==1)
  268.                       WheelNow=WheelNow+1;           // 读 PINA
  269.               WheelNow=WheelNow<<1;
  270.           if (GetPIN1(b)==1)                                  // 读 PINB
  271.                      WheelNow=WheelNow+1;            
  272.              WheelNow=WheelNow & 0x03;      // 将 WheelNow 的 2 - 7 位清零,保留 0- 1 两个位的状态.
  273.           if (WheelNow==0x00)
  274.                      return(NULL);                //当  PINA 和 PINB都为低电平时退出,低电平区不做处理
  275.              keytmp=WheelNow;
  276.              keytmp ^=WheelOld;          // 判断新读的数据同旧数据
  277.           if (keytmp==0)
  278.                      return(NULL);              // 新读的数据同旧数据一样时退出.
  279.          
  280.           if (WheelOld==0x01 && WheelNow==0x02)        // 是左旋转否
  281.                       {
  282.                               switch(tmpstate)
  283.                         {
  284.                                 case 0x0100:
  285.                                       wheelold_data[0]=WheelNow;
  286.                                           break;
  287.                                 case 0x0804:
  288.                                       wheelold_data[1]=WheelNow;
  289.                                           break;
  290.                                 case 0x0A09:
  291.                                       wheelold_data[2]=WheelNow;
  292.                                           break;
  293.                                 case 0x0F0E:
  294.                                       wheelold_data[3]=WheelNow;
  295.                                           break;
  296.                                 case 0x1110:
  297.                                       wheelold_data[4]=WheelNow;
  298.                                           break;
  299.                                 case 0x1312:
  300.                                       wheelold_data[5]=WheelNow;
  301.                                           break;
  302.                                 case 0x1514:
  303.                                       wheelold_data[6]=WheelNow;
  304.                                           break;
  305.                                 case 0x1716:
  306.                                       wheelold_data[7]=WheelNow;
  307.                                           break;
  308.                                  default: break;
  309.                                  
  310.                                  }
  311. //                                  WheelOld=WheelNow;
  312. //                  return(WheelLeft());         //左旋转
  313.                                   return(knob_coding[c]);         //左旋转
  314.               }
  315.           else if (WheelOld==0x02 && WheelNow==0x01)  // 是右旋转否
  316.                      {
  317.                                switch(tmpstate)
  318.                         {
  319.                                 case 0x0100:
  320.                                       wheelold_data[0]=WheelNow;
  321.                                           break;
  322.                                 case 0x0804:
  323.                                       wheelold_data[1]=WheelNow;
  324.                                           break;
  325.                                 case 0x0A09:
  326.                                       wheelold_data[2]=WheelNow;
  327.                                           break;
  328.                                 case 0x0F0E:
  329.                                       wheelold_data[3]=WheelNow;
  330.                                           break;
  331.                                 case 0x1110:
  332.                                       wheelold_data[4]=WheelNow;
  333.                                           break;
  334.                                 case 0x1312:
  335.                                       wheelold_data[5]=WheelNow;
  336.                                           break;
  337.                                 case 0x1514:
  338.                                       wheelold_data[6]=WheelNow;
  339.                                           break;
  340.                                 case 0x1716:
  341.                                       wheelold_data[7]=WheelNow;
  342.                                           break;
  343.                                  default: break;
  344.                                  
  345.                                  }
  346. //                                  WheelOld=WheelNow;
  347. //                  return(WheelRight()); //右旋转
  348.                                   return(knob_coding[c+1]);         //左旋转
  349.              }
  350.                   switch(tmpstate)
  351.                 {
  352.                         case 0x0100:
  353.                               wheelold_data[0]=WheelNow;
  354.                                   break;
  355.                         case 0x0804:
  356.                               wheelold_data[1]=WheelNow;
  357.                                   break;
  358.                         case 0x0A09:
  359.                               wheelold_data[2]=WheelNow;
  360.                                   break;
  361.                         case 0x0F0E:
  362.                               wheelold_data[3]=WheelNow;
  363.                                   break;
  364.                         case 0x1110:
  365.                               wheelold_data[4]=WheelNow;
  366.                                   break;
  367.                         case 0x1312:
  368.                               wheelold_data[5]=WheelNow;
  369.                                   break;
  370.                         case 0x1514:
  371.                               wheelold_data[6]=WheelNow;
  372.                                   break;
  373.                         case 0x1716:
  374.                               wheelold_data[7]=WheelNow;
  375.                                   break;
  376.                          default: break;
  377.                         
  378.                          }
  379. //                  WheelOld=WheelNow; // 保存当前值
  380.           return(NULL); // 当  PINA 和 PINB 都为高电平时表示编码器没有动作,退出
  381.       }

  383. //========================================================================================
  384. /*********************************************************************************************************
  385. ** Function name:       Key_LED
  386. ** Descriptions:        接收数据，相应的LED灯点亮
  387. ** input parameters:    无
  388. ** output parameters:   无
  389. ** Returned value:      无
  390. *********************************************************************************************************/
  391. void Key_LED (INT8U d)
  392. {        INT8U led_data=0;
  393.     led_data=d;
  394.         FIO1SET3=0x03;
  395.     FIO2SET =0xFFFF;
  396.         if(led_data!=0)
  397.            {
  398.             switch(led_data)
  399.                 {
  400.                         case 0x01:
  401.                               FIO2CLR|=0x0004;
  402.                                   break;
  403.                         case 0x02:
  404.                               FIO2CLR|=0x0008;
  405.                                   break;
  406.                         case 0x03:
  407.                               FIO2CLR|=0x0010;
  408.                                   break;
  409.                         case 0x04:
  410.                               FIO2CLR|=0x0020;
  411.                                   break;
  412.                         case 0x05:
  413.                               FIO2CLR|=0x0040;
  414.                                   break;
  415.                         case 0x06:
  416.                               FIO2CLR|=0x0080;
  417.                                   break;
  418.                         case 0x07:
  419.                               FIO2CLR|=0x0100;
  420.                                   break;
  421.                         case 0x08:
  422.                               FIO2CLR|=0x0200;
  423.                                   break;
  424.                         case 0x09:
  425.                               FIO2CLR|=0x0400;
  426.                                   break;
  427.                         case 0x0a:
  428.                               FIO2CLR|=0x0800;
  429.                                   break;
  430.                         case 0x0b:
  431.                               FIO2CLR|=0x1000;
  432.                                   break;
  433.                         case 0x0c:
  434.                               FIO2CLR|=0x2000;
  435.                                   break;
  436.                         case 0x0d:
  437.                               FIO1CLR|=0x01000000;
  438.                                   break;
  439.                         case 0x0e:
  440.                               FIO1CLR|=0x02000000;
  441.                                   break;
  442.                     case 0x10:
  443.                               FIO1CLR|=0x04000000;
  444.                                   break;
  445.                          default:  break;
  446.                         
  447.                          }
  448.            }
  449.    
  450. }
  451. //========================================================================================

  453. /*********************************************************************************************************
  454. ** Function name:       main
  455. ** Descriptions:        发送和接收数据
  456. ** input parameters:    无
  457. ** output parameters:   无
  458. ** Returned value:      无
  459. *********************************************************************************************************/
  460. int main (void)
  461. {        
  462. //    rcvdata=0;
  463.    
  464.     targetInit();                                                       /* 初始化目标板，切勿删除       */
  465.     pinInit();                                                                                                                   /* 引脚初始化                   */
  466.         FIO0DIR0=0x00;
  467.         FIO0DIR1=0x00;
  468.         FIO0DIR2=0x00;
  469.         FIO0DIR3=0x00;
  470.     FIO1DIR0=0x00;
  471.         FIO1DIR1=0x00;
  472.         FIO1DIR2=0x00;
  473.         FIO1DIR3=0x07;
  474.         FIO1SET3=0x07;

  476.         FIO2DIR =0xFFFF;
  477.         FIO2SET =0xFFFF;
  478.         GucRcvNew = 0;                           
  479.         PCONP = PCONP | (1<<4);                                             /* 开启串口1功能模块            */
  480.                                                                            
  481.         uart1Init();
  482.         zyIsrSet(NVIC_UART1,(unsigned long)uart1Isr,PRIO_ONE);         
  483.     while (1)
  484.         {
  485.            data =keyin();         
  486.            if(data!=0&&(data!=dlay_data))
  487.               {
  488.                   uart1SendByte(data);                  
  489.                   }
  490.            dlay_data=data;

  492.            if (GucRcvNew == 1)
  493.            {                                           /* 判断是否有新数据             */
  494.               GucRcvNew = 0;                          /* 清除标志                     */
  495.                  if(GucRcvBuf!=0)
  496.               Key_LED(GucRcvBuf);
  497.           uart1SendByte (GucRcvBuf);
  498.        }
  499.                   
  500.            data1=knob_can();
  501.            if(data1!=0)
  502.               {
  503.                   uart1SendByte(data1);
  504.                   myDelay(1);
  505.                   }
  506.          
  507.         }        
  508. }
复制代码
回复

   举报本楼层   

jlhgold

出0入0汤圆
发表于 2015-2-1 18:34:28 | 显示全部楼层
啥东东 看上去就一堆代码
回复

   举报本楼层   

lxk19781221

出0入0汤圆
发表于 2015-2-2 08:33:57 | 显示全部楼层
一个独立键盘加六个旋转按钮
回复

   举报本楼层   

videofun

出0入0汤圆
发表于 2015-5-10 18:15:14 | 显示全部楼层
很牛的资料啊，谢谢分享给大家，点赞一个
回复

   举报本楼层   

big_cat

出0入0汤圆
发表于 2015-6-26 13:12:59 | 显示全部楼层
最好有原理图，有详细讲解。否则，没人有时间看代码
回复

   举报本楼层   

iop

出0入0汤圆
发表于 2015-7-8 09:39:33 | 显示全部楼层
楼主你的代码是不是有问题啊？？？NT8U keyin(void)
{   
        INT8U t1,t2;
            t1=scan();
                myDelay(5);          //延时消抖
                t2=scan();
                if(t1=t2)
                   return(t1);
                else
                   return(0);
//                while(t1=t2);
}这块明显有问题啊！
回复

   举报本楼层   

返回列表 发新帖
回帖提示： 反政府言论将被立即封锁ID 。在按“提交”前，请自问一下：我这样表达会给举报吗，会给自己惹麻烦吗？ 另外：尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片，浪费大家下载带宽和论坛服务器空间，请压缩后（图片小于1兆）才上传。压缩方法可以在微信里面发给自己（不要勾选“原图），然后下载，就能得到压缩后的图片】。另外，手机版只能上传图片，要上传附件需要切换到电脑版（不需要使用电脑，手机上切换到电脑版就行，页面底部）。
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有：东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案：44190002001997 ) )

GMT+8, 2024-4-19 07:47

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

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