【IRD-LPC1768-DEV】IIC key board

day_day

（一）键盘工作机理
关于键盘的资料目前只有在Industrial Reference Design I2C  Rel2.ppt这个文件里面找到，剩下的就是键盘主控芯片pca9555的数据手册： PCA9555.pdf (258.61 KB, 下载次数: 5)

2019-3-10 14:24 上传

点击文件名下载附件
这个键盘的机理不同于一般的扫描矩阵，它以Port0的前六个引脚为输入，Port1前六个引脚为输出。
当Port1全为0，任何一个被按下，Port0对应的那一列就从1变成0。

那么要怎么确定是Port0这一列上面的哪一个被按下了呢？
这里则需要把Port1的六个驱动引脚依次拉高，然后看看哪一次Port0又突然全部变回了全1。

以下为列表，这个列表就需要注意了，这里的Port0放到了行上面，也就是看这个列表跟上面分析的行列是调换的！



（二）PCA9555
PCA9555的寄存器只有8个：


其中初始化只需要配置6、7两个：

1. PCA9555Write(ConfigPort0, 0xFF);        //port0 all set,input
   
2.         PCA9555Write(ConfigPort1, 0x00);        //port1 all clear,output
   
3.         

复制代码

这里可以选择轮询一直扫描键盘，或者使用pca9555的中断。手册上面

Active LOW interrupt output

意义不明，看着像中断的时候产生低电平跳变，由于配置外部中断的时候出了点问题，又用高电平跳变折腾了一番，最后发现果然还是低电平跳变：
即，按下按键之后，它会从高电平拉下到低电平（其实这里有些错误，此处先不解决，后面会提到）

（三）中断
LPC1768的输入中断设计有些特殊，有两种实现方式：单纯的外部中断EINT、GPIO中断

1、
外部中断EINT只能在四个引脚上实现！而且还需要配置复用功能IOCON。

此外还要配置EINT的三个寄存器：

以及配置GPIO的中断寄存器:

最后开启NVIC中断。

1. void PCA9555_Exit(void)
   
2. {
   
3.         Chip_IOCON_PinMux(LPC_IOCON, 2, 12, IOCON_MODE_PULLUP, IOCON_FUNC1);
   
4. 
   
5.         LPC_GPIOINT->IO2.ENR |= (1<<12);
   
6.         LPC_SYSCTL->EXTMODE |= (1<<2);        //边沿触发；1
   
7.         LPC_SYSCTL->EXTPOLAR &= ~(1<<2);        //低电平、上升沿；1
   
8.         
   
9.         NVIC_ClearPendingIRQ(EINT2_IRQn);
   
10.         NVIC_SetPriority(EINT2_IRQn, 0);
    
11.         NVIC_EnableIRQ(EINT2_IRQn);
    
12. }

复制代码

中断服务函数：EINT2_IRQHandler

2、
GPIO中断：
GPIO中断不需要配置EINT相关寄存器，只需要配置GPIO的中断寄存器。但由于GPIO中断不属于复用功能，所以还要配置为输入模式：

1. void PCA9555_GPIOIntInit(void)
   
2. {
   
3.         Chip_IOCON_PinMux(LPC_IOCON, 2, 12, IOCON_MODE_PULLUP, IOCON_FUNC0);
   
4.         Chip_GPIO_SetDir(LPC_GPIO, 2, 12, 0);
   
5.         LPC_GPIOINT->IO2.ENF |= (1<<12);
   
6.         
   
7.         NVIC_ClearPendingIRQ(EINT3_IRQn);
   
8.         NVIC_SetPriority(EINT3_IRQn, 1);
   
9.         NVIC_EnableIRQ(EINT3_IRQn);
   
10. }

复制代码

中断服务函数，所有的gpio中断都共用EINT3_IRQHandler

3、
以上任意一种中断都可以

（四）扫描按键
扫描主体函数 ReadAll_SupportFirstOne() 思路：
1、判断有没有按下：没有按下返回-1
2、是否最低位被按下：是返回END，不是的话，把该位放入record
3、for 6轮，突然变为全是1（2、里面那个位为由0变1），把这个for的值计入counter

注意结束扫描之后一定要把Port1设置为全0
PCA9555Write(OutputPort1, 0x00);
否则的话按下同一列的按键将没有反应。这里是上面那个括号所述错误的体现，他并非按下按键就会产生中断。主控就是主控，跟板子本身是分离的，只有输入引脚全0的情况下，按下同一列才会在输入port0中体现为电平跳变。

1. unsigned char ReadKeyInput(unsigned char addr)
   
2. {
   
3.         unsigned char return_char=0;
   
4.         PCA9555Write(OutputPort1, addr);
   
5.         return_char = PCA9555Read(InputPort0);
   
6.         
   
7. //        PCA9555Write(OutputPort1, 0x00);
   
8.         
   
9.         return_char &= 0x3F;
   
10.         return return_char;
    
11. }
    
12. 
    
13. 
    
14. //只支持扫描到的第一个按键
    
15. //返回值：-1（啥也没按到）；-2（奇怪的现象，明明按下了却检测不到）
    
16. int ReadAll_SupportFirstOne()
    
17. {
    
18.         unsigned int counter=0,temp=0;
    
19.         unsigned char record = ReadKeyInput(0x00);
    
20.         
    
21.         if(record == 0x3F)        //没按下
    
22.                 return -1;
    
23.         else if((record&0x01) == 0x00)        //按下了那个独一无二的键
    
24.                 return KEY_END;
    
25.         
    
26.         for(counter=0;counter<=5;counter++)
    
27.         {
    
28.                 temp = ReadKeyInput(0x01<<counter);
    
29.                 if(temp == 0x3F)
    
30.                 {
    
31.                         PCA9555Write(OutputPort1, 0x00);
    
32.                         
    
33.                         record = record>>1;        //掐掉最后一位，移位去掉
    
34.                         record = ~record;                //默认值为1，所以要取反变成默认值为0
    
35.                         record &= 0x1F;                        //顶端三个无效位也被取反过程中置高了，掐掉高三位，使之为零
    
36.         
    
37.                         return JudgeKey(counter, record);
    
38.                 }
    
39.         }
    
40.         
    
41.         return -2;
    
42. }
    
43. 
    
44. int JudgeKey(unsigned int counter, unsigned int record)
    
45. {
    
46.         switch(counter)
    
47.         {
    
48.                 case 0:
    
49.                         switch(record)
    
50.                         {
    
51.                                 case 0x08:
    
52.                                         return KEY_F4;
    
53.                                         ;
    
54.                                 case 0x10:
    
55.                                         return KEY_MENU;
    
56.                                         ;
    
57.                         }
    
58.                         ;
    
59.                 case 1:
    
60.                         switch(record)
    
61.                         {
    
62.                                 case 0x01:
    
63.                                         return KEY_CIAO;
    
64.                                         ;
    
65.                                 case 0x04:
    
66.                                         return KEY_3;
    
67.                                         ;
    
68.                                 case 0x08:
    
69.                                         return KEY_DOWN;
    
70.                                         ;
    
71.                                 case 0x10:
    
72.                                         return KEY_UP;
    
73.                                         ;
    
74.                         }
    
75.                         ;
    
76.                 case 2:
    
77.                         switch(record)
    
78.                         {
    
79.                                 case 0x01:
    
80.                                         return KEY_0;
    
81.                                         ;
    
82.                                 case 0x02:
    
83.                                         return KEY_7;
    
84.                                         ;
    
85.                                 case 0x04:
    
86.                                         return KEY_2;
    
87.                                         ;
    
88.                                 case 0x08:
    
89.                                         return KEY_MINUS;
    
90.                                         ;
    
91.                                 case 0x10:
    
92.                                         return KEY_PLUS;
    
93.                                         ;
    
94.                         }
    
95.                         ;
    
96.                 case 3:
    
97.                         switch(record)
    
98.                         {
    
99.                                 case 0x01:
    
100.                                         return KEY_STAR;
     
101.                                         ;
     
102.                                 case 0x02:
     
103.                                         return KEY_6;
     
104.                                         ;
     
105.                                 case 0x04:
     
106.                                         return KEY_1;
     
107.                                         ;
     
108.                                 case 0x08:
     
109.                                         return KEY_RIGHT;
     
110.                                         ;
     
111.                                 case 0x10:
     
112.                                         return KEY_F3;
     
113.                                         ;
     
114.                         }
     
115.                         ;
     
116.                 case 4:
     
117.                         switch(record)
     
118.                         {
     
119.                                 case 0x01:
     
120.                                         return KEY_9;
     
121.                                         ;
     
122.                                 case 0x02:
     
123.                                         return KEY_5;
     
124.                                         ;
     
125.                                 case 0x04:
     
126.                                         return KEY_CLEAR;
     
127.                                         ;
     
128.                                 case 0x08:
     
129.                                         return KEY_OK;
     
130.                                         ;
     
131.                                 case 0x10:
     
132.                                         return KEY_F2;
     
133.                                         ;
     
134.                         }
     
135.                         ;
     
136.                 case 5:
     
137.                         switch(record)
     
138.                         {
     
139.                                 case 0x01:
     
140.                                         return KEY_8;
     
141.                                         ;
     
142.                                 case 0x02:
     
143.                                         return KEY_4;
     
144.                                         ;
     
145.                                 case 0x04:
     
146.                                         return KEY_SEND;
     
147.                                         ;
     
148.                                 case 0x08:
     
149.                                         return KEY_LEFT;
     
150.                                         ;
     
151.                                 case 0x10:
     
152.                                         return KEY_F1;
     
153.                                         ;
     
154.                         }
     
155.                         ;
     
156.         }
     
157.         
     
158.         return -2;
     
159. }

复制代码

（四）中断服务函数
采用EINT中断：

1. 
   
2. void EINT2_IRQHandler(void)
   
3. {
   
4.         static bool i=0;
   
5.         i= (!i);
   
6.         if(i)               
   
7.                 IICSendChar(0xC0, 0x06, 0x55);
   
8.         else               
   
9.                 IICSendChar(0xC0, 0x06, 0x54);
   
10.         
    
11.         ScanDisplay();
    
12.         while(ReadKeyInput(0x00) != 0x3F);        //直到松开为止
    
13.         LPC_SYSCTL->EXTINT |= (1<<2);
    
14. }
    

复制代码

采用GPIO中断：

1. void EINT3_IRQHandler(void)
   
2. {
   
3.         //1-led test
   
4.         static bool i=0;
   
5.         i= (!i);
   
6.         if(i)               
   
7.                 IICSendChar(0xC0, 0x06, 0x55);
   
8.         else               
   
9.                 IICSendChar(0xC0, 0x06, 0x51);
   
10.         
    
11.         //2-handle
    
12.         if((LPC_GPIOINT->IO2.STATF & (1<<12)) == (1<<12))
    
13.         {
    
14.                 ScanDisplay();
    
15.                 while(ReadKeyInput(0x00) != 0x3F);        //直到松开为止
    
16.                 LPC_GPIOINT->IO2.CLR |= (1<<12);
    
17.         }
    
18. 
    
19.         //3-clear flag
    
20.         LPC_SYSCTL->EXTINT |= (1<<3);
    
21. }
    

复制代码

阅读全文

leo121_3006061

谢谢分享，很详细，学习了，中断这部分挺犯晕的