【手机DIY】辛昕4.开始写程序

辛昕

【手机DIY】辛昕4.开始写程序 [复制链接]

在我今晚开始写程序之前。
昨天晚上，我简单想了想整个程序的框架

如上一个帖子所说，由于我最近的工作，我在无意中，事实上已经 拥有了 多级菜单（的实现方案），拥有了队列，至于用于GPRS模块的串口收发，不管是我此前的 超时机制，还是熟悉了队列后我想到的一个实际上可能更好的 方案——实际上这就是大家经常说的 环形缓冲。

所以我很快的就简单设计了整体的程序框架和实现过程。

当然，当时我只用了半个小时，所以写的很粗糙，基本上没什么意义。
而后我开始从如何实现，集成 和 测试各个部分的时候，我突然想到了。

我最好还是首先实现 LCD12864，矩阵按键 的底层驱动，因为有了这个，我可以省去许多测试中层，上层的功能时需要的 桩。
而如果我没有实际实现这些 输入 / 输出 的基本部件，我要用软件桩模拟来测试的时候，所费的劲恐怕也不少。

考虑到这个东西本身就是一个不很复杂，规模不大的项目，所以，我决定，首先 实现（移植）这些底层驱动再说。

第一步我实现 12864，我此前已经做好了一个，并且发布在论坛里。
经过这次换用在 stm32f030上，这个过程非常简单，我真的就只是修改了 几个io绑定函数，这也算是对这个驱动的一个考验，对这个结果我比较满意。

因为我把源代码一个一个添加上去，然后编译，每一步，我都没有遇到编译错误，一步都不用修改。
而且，这个时候，我发现，实际上，即使我把所有源码编译成一个库，只把IO绑定函数 留给调用者 就可以了。

好，就这么干，这样可以省了许多事！

先上个图哈～～

辛昕

库已经编好了。
对于库，目前来说，我还有一个很大很大的问题没有彻底解决，那就是不知道如何应付一次编译，多次（不同编译器使用）。

所以，我只能提供一个我自己使用的iar的编译出来的库。

我的IAR 是 EWARM 7.1
按道理，除了 老版本 无法兼容 新版本，按道理IAR之间是可以互相兼容的。

在这里，我这样做的目的，意义还不算特别明确，我只是不想看到太多代码。
所以想了想，我就把我编译库的 project发上来吧。

没有太多的特殊设置，只是option里 c/c++ 那一项的output选择 library 而不是 executeable 就可以了。

LCD12864-lib.rar (171.14 KB, 下载次数: 6)

2014-7-5 01:08 上传

点击文件名下载附件

youyou_hu111

想请教下楼主，大成库的IO管脚怎么设置？比如不同的芯片，他们调用管脚的方式不同。使用宏定义么？

辛昕

youyou_hu111 发表于 2014-7-5 08:14
想请教下楼主，大成库的IO管脚怎么设置？比如不同的芯片，他们调用管脚的方式不同。使用宏定义么？

我不用宏

因为我觉得这种方式很蹩脚，虽然我在有的地方，而且不少的地方看到类似的做法。
而且这会造成库写的很辛苦。

我的方法是通过 函数指针 实现。

具体思路是，把 封装底层操作，比如IO口高低操作 的 函数，在库里的时候，实际上并未实现，只通过函数指针来实现调用。
然后，在写应用程序时，再根据具体IO，单片机的情况，把这些IO操作写在函数里，然后把这个函数 初始化入 库里。

这样的话，你改变了引脚，改变了不同的芯片，写法完全不一样，都无所谓，你只需要改写应用层的这个 IO操作函数就可以了。
对于库的接口 是完全不影响的。

辛昕

昨晚到今天，发现硬件一个地方做得不好。
我发现12864那个地方经常接触不良。
一开始，我想到莫非是因为我用的是普通的排针排母，不是镀金的，所以插拔多了，就接触不好？
话虽如此，可我一时半会要买东西却是实在不方便。

另一方面，以前我也这么用，也没见我出啥问题。
后来想了想，12864这个地方，因为我用的是 串行方式，实际上我只用了其中8个引脚，所以焊接时，我去头去尾，会不会是因为这样造成接触不良？
又或者，我需要找点铜柱子撑起来会好一些？

不管如何，看起来我今天回宿舍后必须重新焊接一番来试试了～～

真扫兴～～

辛昕

youyou_hu111 发表于 2014-7-5 08:14
想请教下楼主，大成库的IO管脚怎么设置？比如不同的芯片，他们调用管脚的方式不同。使用宏定义么？

具体的例子，我以前写过的一个关于 程序库 的帖子 在这里，你可以参考一下。


https://bbs.eeworld.com.cn/thread-375424-1-1.html

辛昕

晚上回来，把板子重新焊了焊，又正常了。
看来下次要好好考虑这些问题才行。

下面先贴上 显示整屏ascii 函数

1. void WriteAsciiFullScreen(Op12864 *op,const U8 *string)
   
2. {
   
3.      U8 temp[5];
   
4.      U8 len,Length;
   
5.      U8 TotalLength;
   
6.      U8 line;
   
7.      
   
8.      if(string == NULL)
   
9.          return;
   
10.      
    
11.      TotalLength = strlen((char *)string);
    
12.      
    
13.      line = 0;
    
14.      len = 0;
    
15.      Length = 0;
    
16.      
    
17.      do
    
18.      {   
    
19.          if(checkAsciiCode(string[Length],temp) != -1)
    
20.             WriteAscii(op,line,len,temp);
    
21.          
    
22.          len++;
    
23.          Length++;
    
24. 
    
25.          if(len >= 25)
    
26.          {
    
27.             line++;
    
28.             len = 0;
    
29.          }
    
30.          
    
31.          if(string[Length] == '\n')
    
32.          {
    
33.             line++;
    
34.             len = 0;
    
35.             Length++;
    
36.          }         
    
37.          
    
38.          if(Length >= TotalLength)
    
39.             break;
    
40.          
    
41.      }while(line < 8);
    
42. }

复制代码

辛昕

同时，每次编译时，整个stm32f0的 外设库，还要重新编译，实在太慢了，老办法，再一次编译成库。

这里同样贴上 iar for ARM 的7.1版本
我发现它有个好处。
ARM的stm32，有许多麻烦的头文件和系统文件，每次刚开始弄的时候，确实让人不胜其烦。
而编译这个库的时候我发现它们也要一并加进去否则是无法编译的。

这恰好有一个好处，这样一编译，以后就永久不用烦这些东西了。

stm32f030-lib.rar (3.67 MB, 下载次数: 0)

2014-7-5 21:56 上传

点击文件名下载附件

youyou_hu111

这两天比较忙，都没看论坛，楼主都回了这么多，真的非常感谢！版主如此尽心解答，精神值得学习！让我来好好研读以下楼主的文章。

辛昕

这个矩阵键盘有点小纠结。
此前的问题主要在于 脑袋有点糊涂了，居然有一些条件写反了。
另外就是读键，没有完善考虑，测试的时候也不仔细想想 消抖 这些事情，白白浪费了一些时间。

另外就是对于 矩阵键盘 这种 IO口线不定的情况，我经常希望可以通过一定手段，让它的驱动部分可以独立出去，同时可以不受注册时实际数量的限制。

如果可以用malloc的情况下，我想怎么玩就可以怎么玩，包括最简单的 链表。

而实际上，对于不方便到处用malloc这个限制的情况下，最近我无意学会了一种稍加变形的方法来实现 不malloc的链表，它在很大程度上简化了我工作的一个任务，但这个地方，我发现考虑上一些矩阵键盘的其他东西，我发现这个方法在这里，几乎没有太大优势。

所以，我还是决定放弃了，犯不着用上那么复杂的手段。

另外就是，刚和kdy聊了几句，他跟我说到的东西，项目管理的内容，其实我不是不懂，只是我还是很容易陷在实现的细节，因为我对代码有洁癖，而且对实现的完美程度也有很疯魔的固执......

这经常导致我做事情实际上很慢，赶不上进度～～

今晚就不说了，很晚了，最近要好好休息，晚安～～～

不管怎么说，这个本来就不难的东西，很快我就能搞定，而且，其实最后我将让你看到，即使不用什么链表，只是在初始化时稍微有点点麻烦，我一样可以把这个部分像12864那样做成完全独立的库～～

辛昕

矩阵键盘

矩阵键盘 确实 是很简单的东西，我的纠结......其实与它的关系已经不太大，虽然我偶尔老是因为忘了调用这个，调用那个，或者直接把 逻辑条件写反诸如此类......

不过最后，我发现，什么链表，什么malloc在这里都不重要。
反正按键，不管是查询键值 还是 映射键值，都可以按顺序，也就是说，数组在这里其实是很好的选择：相当简单又恰当。

而且，确实，一般情况下，至少在单片机上C，我还是没试过malloc会遇到什么问题。
百度搜索过一下，发现问题还挺麻烦，除了heap大小的设置，居然还有不少相关问题......

闲话少说，上这一部分的代码。

我最后的组织思路如下：

按键可以有很多种，矩阵形式，独立按键形式，甚至可能其他更加奇怪的方式——我以前遇到过另一种 矩阵的变形......
但是，凡此种种，区别仅在底层IO的组织和读键方式。

因为任何按键，最终都可以，或者说需要映射到一个 表上，这个表记录着 键码 和 键的状态。

但大多数情况下，我们可以靠 数组的下标 来 记录键码，因此实际上，只需记录键的状态。
另外，考虑到大多数时候我们，对键的处理方式有可能很不一样，比如消抖用计次，比如也许还要考虑连键等的识别。

所以，其实我们可以提供的最底层输出，其实就仅仅是 按键的实时状态映射到 那个表就可以了。

下一楼是源码。

辛昕

类似于 12864 分 Driver 和 Api两层

按键也是

Api的输入是 按键的表。 即 这些键的状态值；
Api 用于对键的识别。
一般情况下，我们都是 单键， 偶尔还有 多键，长键，短键。
一些讲究体验的场合，还有 连键。

这些就是Api干的事情。
它不关心 按键硬件上的组织形式，只关心映射到的 按键实时值，对其处理得到的结果。

至于 MatrixKey,它是针对 矩阵按键 这种硬件组织形式的抽象。

1. // MatrixKey.h
   
2. #ifndef _MATRIX_KEY_
   
3. #define _MATRIX_KEY_
   
4. 
   
5. #include "typedef.h"
   
6. #include "CommonMacro.h"
   
7. 
   
8. typedef void (*fDrv)(U8 logic);
   
9. typedef U8 (*fSam)(void);
   
10. 
    
11. typedef struct
    
12. {
    
13.     fDrv *DriverList;
    
14.     fSam *SamplerList;
    
15.     U8 DrvCount;
    
16.     U8 SamCount;
    
17. }MatrixKeyDriver;
    
18. 
    
19. typedef struct
    
20. {
    
21.     MatrixKeyDriver *KeyDriver;
    
22.     U8 *PressCount;
    
23. }Key;
    
24. 
    
25. 
    
26. void getMatrixKey(Key *key);
    
27. 
    
28. #endif
    
29. 
    
30. // end of file ------------------
    
31. 
    
32. // MatrixKey.c
    
33. #include "MatrixKey.h"
    
34. #include <stdlib.h>
    
35. 
    
36. int isMatrixKeyDriverReg(MatrixKeyDriver key)
    
37. {
    
38.     U8 item;
    
39.    
    
40.     if(key.DriverList == NULL)
    
41.         return False;
    
42.     if(key.SamplerList == NULL)
    
43.         return False;
    
44.    
    
45.     for(item = 0;item < key.DrvCount;item++)
    
46.     {
    
47.         if(key.DriverList[item] == NULL)
    
48.             return False;
    
49.     }
    
50. 
    
51.     for(item = 0;item < key.SamCount;item++)
    
52.     {
    
53.         if(key.SamplerList[item] == NULL)
    
54.             return False;
    
55.     }  
    
56.    
    
57.     return True;
    
58. }
    
59. 
    
60. void freeAllDrivers(fDrv *driver,U8 count)
    
61. {
    
62.     U8 item;
    
63.    
    
64.     for(item = 0;item < count;item++)
    
65.           (*driver[item])(HIGH);
    
66. }
    
67. 
    
68. 
    
69. void getMatrixKey(Key *key)
    
70. {
    
71.     int drv,sam;
    
72.     int keymask = 0;
    
73.    
    
74.    
    
75.     if(isMatrixKeyDriverReg(*(key->KeyDriver)) == False)
    
76.         return;
    
77.    
    
78.     for(drv = 0;drv < key->KeyDriver->DrvCount;drv++)
    
79.     {
    
80.         freeAllDrivers(key->KeyDriver->DriverList,key->KeyDriver->DrvCount);
    
81.         (*key->KeyDriver->DriverList[drv])(LOW);
    
82.         
    
83.         for(sam = 0;sam < key->KeyDriver->SamCount;sam++)
    
84.         {
    
85. 
    
86.             if( (*key->KeyDriver->SamplerList[sam])() == LOW)
    
87.                 (key->PressCount[keymask])++;
    
88.             else
    
89.                 key->PressCount[keymask] = 0;
    
90.             
    
91.             keymask++;  
    
92.         }
    
93.     }
    
94. }
    
95. 
    
96. // end of file -------------------
    
97. 
    

复制代码

1. // 当前的 KeyApi 还很简单，只是一个 单键识别
   
2. 
   
3. #include "KeyApi.h"
   
4. 
   
5. U8 SingleKeyPress(U8 *PressCounter,U8 Size)
   
6. {
   
7.     U8 i;
   
8.     U8 key = 0xff;
   
9.    
   
10.     for(i = 0;i < Size;i++)
    
11.     {
    
12.         if(PressCounter[i] >= 30)
    
13.             key = i;
    
14.     }
    
15.    
    
16.     return key;
    
17. }
    
18. 
    
19. // 因为很简单，所以就不上头文件了。

复制代码

辛昕

1. // 这是 针对我stm32f030板子上的 硬件接法 // 的 驱动写法。
   
2. /*
   
3.          --
   
4.       --  OK --      OK PB1
   
5.          --        PB10
   
6. 
   
7.     --   --   --   PB0
   
8.     --   --   --   PA7
   
9.     --   --   --   PC4
   
10.     --   --   --   PC5
    
11.    PB12  PB11 PB2
    
12. 
    
13.          OK =  PB1 PA7  (0)
    
14.        (8)
    
15.    (9)     (10)
    
16.        (11)
    
17. 
    
18.      17     13     5
    
19.      16     12     4
    
20.      18     14     6
    
21.      19     15     7
    
22. */
    
23. 
    
24. #include "DriverMatrixKey.h"
    
25. 
    
26. #include "stm32f0xx_gpio.h"
    
27. #include "stm32f0xx_rcc.h"
    
28. 
    
29. #include <stdlib.h>
    
30. 
    
31. void MatrixKey_IO_Initial(void)
    
32. {
    
33.     GPIO_InitTypeDef gpio;
    
34.    
    
35.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
    
36.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
    
37.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
    
38.    
    
39.    
    
40.     // PB1 PB2 PB10 PB11 PB12 ----------
    
41.     gpio.GPIO_Pin   = GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
    
42.     gpio.GPIO_Mode  = GPIO_Mode_OUT;
    
43.     gpio.GPIO_OType = GPIO_OType_PP;
    
44.     gpio.GPIO_Speed = GPIO_Speed_50MHz;
    
45.     gpio.GPIO_PuPd  = GPIO_PuPd_UP;
    
46.     GPIO_Init(GPIOB,&gpio);
    
47.    
    
48.     // PA7 PB0 PC4 PC5 -----------------
    
49.    
    
50.     gpio.GPIO_Mode = GPIO_Mode_IN;
    
51.     gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
    
52.    
    
53.     gpio.GPIO_Pin = GPIO_Pin_7;
    
54.     GPIO_Init(GPIOA,&gpio);  
    
55.    
    
56.     gpio.GPIO_Pin = GPIO_Pin_0;
    
57.     GPIO_Init(GPIOB,&gpio);
    
58.    
    
59.     gpio.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5;
    
60.     GPIO_Init(GPIOC,&gpio);   
    
61. }
    
62. 
    
63. void drv1(U8 logic)
    
64. {
    
65.      if(logic == HIGH)
    
66.         GPIOB->BSRR = GPIO_Pin_1;
    
67.      else
    
68.         GPIOB->BRR = GPIO_Pin_1;     
    
69. }
    
70. 
    
71. void drv2(U8 logic)
    
72. {
    
73.      if(logic == HIGH)
    
74.         GPIOB->BSRR = GPIO_Pin_2;
    
75.      else
    
76.         GPIOB->BRR = GPIO_Pin_2;   
    
77. }
    
78. 
    
79. void drv3(U8 logic)
    
80. {
    
81.      if(logic == HIGH)
    
82.         GPIOB->BSRR = GPIO_Pin_10;
    
83.      else
    
84.         GPIOB->BRR = GPIO_Pin_10;   
    
85. }
    
86. 
    
87. 
    
88. void drv4(U8 logic)
    
89. {
    
90.      if(logic == HIGH)
    
91.         GPIOB->BSRR = GPIO_Pin_11;
    
92.      else
    
93.         GPIOB->BRR = GPIO_Pin_11;   
    
94. }
    
95. 
    
96. 
    
97. void drv5(U8 logic)
    
98. {
    
99.      if(logic == HIGH)
    
100.         GPIOB->BSRR = GPIO_Pin_12;
     
101.      else
     
102.         GPIOB->BRR = GPIO_Pin_12;   
     
103. }
     
104. 
     
105. 
     
106. U8 sam1(void)
     
107. {
     
108.     if(GPIOA->IDR & GPIO_Pin_7)
     
109.         return HIGH;
     
110.     else
     
111.         return LOW;
     
112. }
     
113. 
     
114. U8 sam2(void)
     
115. {
     
116.     if(GPIOB->IDR & GPIO_Pin_0)
     
117.         return HIGH;
     
118.     else
     
119.         return LOW;
     
120. }
     
121. 
     
122. U8 sam3(void)
     
123. {
     
124.     if(GPIOC->IDR & GPIO_Pin_4)
     
125.         return HIGH;
     
126.     else
     
127.         return LOW;
     
128. }
     
129. 
     
130. U8 sam4(void)
     
131. {
     
132.     if(GPIOC->IDR & GPIO_Pin_5)
     
133.         return HIGH;
     
134.     else
     
135.         return LOW;
     
136. }
     
137. 
     
138. static fDrv Drv[5];
     
139. static fSam Sam[4];
     
140. 
     
141. void MatrixKey_DriverReg(MatrixKeyDriver *matrix)
     
142. {
     
143.     Drv[0] = drv1;
     
144.     Drv[1] = drv2;
     
145.     Drv[2] = drv3;
     
146.     Drv[3] = drv4;
     
147.     Drv[4] = drv5;
     
148.    
     
149.     Sam[0] = sam1;
     
150.     Sam[1] = sam2;
     
151.     Sam[2] = sam3;
     
152.     Sam[3] = sam4;
     
153.    
     
154.     matrix->DriverList = Drv;
     
155.     matrix->SamplerList = Sam;
     
156.     matrix->DrvCount = 5;
     
157.     matrix->SamCount = 4;
     
158.    
     
159.     MatrixKey_IO_Initial();   
     
160. }
     
161. 
     
162. 
     
163. 
     
164. // end of file -------------------
     
165. 
     

复制代码