求一个C语言编程技巧

wuha

假如我用单片机的几个IO口通过一定的时序操作一个设备，这些IO口已经在程序中宏定义过了，相关的驱动程序在此宏定义基础上也已经写好。但是我想在程序中动态的分时去操作多台一模一样的设备，仅仅是IO口不同而已。如果能在程序中动态的去改变那些设备IO口的宏定义即可，但这个显然不行。有没有其他的办法？也就是说，所有设备仅仅是物理IO不同，但在程序运行期间共用一套驱动函数。

HadesHe

物理层和底层分离

HadesHe

可能用指针也比较方便 寄存器也是个地址吧？

wuha

HadesHe 发表于 2013-9-26 10:42
物理层和底层分离

我现在的驱动相关的函数特别多，要操作不同的设备，也就是IO口定义不同而已，我就想，有什么方法，能让所有的驱动函数可以共用。
我想到一个方法，是所有函数多加个参数，判断是哪个设备，但因为函数太多了，这样也比较麻烦。

laujc

wuha 发表于 2013-9-26 10:50
我现在的驱动相关的函数特别多，要操作不同的设备，也就是IO口定义不同而已，我就想，有什么方法，能让所 ...

与程序时,过程运算不应该用到IO口的,IO只作为输入和输出时使用.
如果是这样写的话,当你输出时,判断一下输出到哪个IO不就可以了?!

qlb1234

樓主似乎不知道，帶#的語句，執行者是編譯器，而非單片機？
所以你需要的是一系列的（指針）變量，而非宏定義。

STM32_Study

最简单的方式，把你的IO宏定义操作，改成函数操作即可

wuha

qlb1234 发表于 2013-9-26 10:57
樓主似乎不知道，帶#的語句，執行者是編譯器，而非單片機？
所以你需要的是一系列的（指針）變量，而非宏定 ...

嗯，宏定义我知道不行，看来只能用函数指针了。把IO口的动作封装成函数，然后在调用所有驱动程序时，把最底层函数通过指针指向不同的IO口动作函数。

qlb1234

比如

1. #include <xxx.h>
   
2. void td(int time, char * p)
   
3. {
   
4.     if(time == 1)
   
5.     {
   
6.         p = P1;
   
7.     }
   
8.     else
   
9.     {
   
10.         p = P2;
    
11.     }
    
12. }
    
13. 
    
14. void op(void)
    
15. {
    
16.     *p = 0x01;
    
17. }
    
18. 
    
19. void main(void)
    
20. {
    
21.     char * p;
    
22.     while(1)
    
23.     {
    
24.         td(1, p);
    
25.         op();
    
26.         td(2, p);
    
27.         op();
    
28.     }
    
29. }

复制代码

wxty

这里有同样问题：http://www.amobbs.com/thread-5532088-1-1.html

wuha

wxty 发表于 2013-9-26 13:39
这里有同样问题：http://www.amobbs.com/thread-5532088-1-1.html

谢谢，我定义了个全局变量，直接在最底层操作IO口时判断全局变量，从而操作不同的IO口，所有上层函数都不需要动了。使用时改变全局变量就行了。这样理解简单，我已经改好了。

Gorgon_Meducer

wuha 发表于 2013-9-26 15:23
谢谢，我定义了个全局变量，直接在最底层操作IO口时判断全局变量，从而操作不同的IO口，所有上层函数都不 ...

用全局变量来处理这个问题，你这是一个悲剧的开始……
从你的描述来看，代码结构并不简单……我要提醒你，由于你使用了全局变量，这就成为了多个任务的共享资源，
你要为这个全局变量，以及全局变量直接相关的底层IO建立临界区，否则，在涉及到简单的多任务，甚至是前后台
的情况下，很有可能会出现问题。

wuha

Gorgon_Meducer 发表于 2013-9-26 18:22
用全局变量来处理这个问题，你这是一个悲剧的开始……
从你的描述来看，代码结构并不简单……我要提醒你 ...

谢傻孩子提醒，我这个虽然驱动相关的功能程序复杂了些，但主程序调用还是比较简单的分时调用，我会注意这点的。

macaroni

1. #define ADC1_Port           GPIOB     
   
2. #define ADC1_SCK_Pin        ADC_SCK1
   
3. #define ADC1_SDA_Pin        ADC_SDA1
   
4. 
   
5. #define ADC2_Port           GPIOB
   
6. #define ADC2_SCK_Pin        ADC_SCK2
   
7. #define ADC2_SDA_Pin        ADC_SDA2
   
8. 
   
9. #define ADC3_Port           GPIOA
   
10. #define ADC3_SCK_Pin        ADC_SCK3
    
11. #define ADC3_SDA_Pin        ADC_SDA3
    
12. 
    
13. #define ADC4_Port           GPIOB
    
14. #define ADC4_SCK_Pin        ADC_SCK4
    
15. #define ADC4_SDA_Pin        ADC_SDA4
    
16. 
    
17. 
    
18. #define CS5513_1                0x00
    
19. #define CS5513_2                0x01
    
20. #define CS5513_3                0x02
    
21. #define CS5513_4                0x03
    
22. 
    
23. /** @defgroup Private_TypesDefinitions
    
24.   * @{
    
25.   */
    
26. typedef void    (*pFunctionWriteBit)(void);
    
27. typedef uint8_t (*pFunctionReadBit)(void);
    
28. typedef enum    SWITCHTAG   {OFF,ON} SWITCH;
    
29. 
    
30. 
    
31. /** @defgroup Private_Defines
    
32.   * @{
    
33.   */
    
34. 
    
35. 
    
36. /** @defgroup Private_Macros
    
37.   * @{
    
38.   */
    
39. 
    
40. 
    
41. /** @defgroup Private_Variables
    
42.   * @{
    
43.   */
    
44.   
    
45. SWITCH   ADC_SAMPLE_SWITCH[4]  =   {OFF,OFF,OFF,OFF};
    
46. uint32_t ADC_SAMPLE_COUNT[4]   =   {  0,  0,  0,  0};
    
47. /** @defgroup Private_FunctionPrototypes
    
48.   * @{
    
49.   */
    
50. 
    
51. /** @defgroup Private_Functions
    
52.   * @{
    
53.   */
    
54. void SetADC_SCK1(void)  {GPIO_SetBits(ADC1_Port,ADC_SCK1);}
    
55. void SetADC_SCK2(void)  {GPIO_SetBits(ADC2_Port,ADC_SCK2);}
    
56. void SetADC_SCK3(void)  {GPIO_SetBits(ADC3_Port,ADC_SCK3);}
    
57. void SetADC_SCK4(void)  {GPIO_SetBits(ADC4_Port,ADC_SCK4);}
    
58. 
    
59. void ResetADC_SCK1(void){GPIO_ResetBits(ADC1_Port,ADC_SCK1);}
    
60. void ResetADC_SCK2(void){GPIO_ResetBits(ADC2_Port,ADC_SCK2);}
    
61. void ResetADC_SCK3(void){GPIO_ResetBits(ADC3_Port,ADC_SCK3);}
    
62. void ResetADC_SCK4(void){GPIO_ResetBits(ADC4_Port,ADC_SCK4);}
    
63. 
    
64. 
    
65. uint8_t ReadADC_SDA1(void){return GPIO_ReadInputDataBit(ADC1_Port,ADC1_SDA_Pin);}
    
66. uint8_t ReadADC_SDA2(void){return GPIO_ReadInputDataBit(ADC2_Port,ADC2_SDA_Pin);}
    
67. uint8_t ReadADC_SDA3(void){return GPIO_ReadInputDataBit(ADC3_Port,ADC3_SDA_Pin);}
    
68. uint8_t ReadADC_SDA4(void){return GPIO_ReadInputDataBit(ADC4_Port,ADC4_SDA_Pin);}
    
69. 
    
70. /* ·´Ïò */
    
71. const pFunctionWriteBit SetSck[4]             = {
    
72.                                             ResetADC_SCK1,
    
73.                                             ResetADC_SCK2,
    
74.                                             ResetADC_SCK3,
    
75.                                             ResetADC_SCK4
    
76.                                           };
    
77. /* ·´Ïò */
    
78. const pFunctionWriteBit ResetSck[4]    =  {
    
79.                                             SetADC_SCK1,
    
80.                                             SetADC_SCK2,
    
81.                                             SetADC_SCK3,
    
82.                                             SetADC_SCK4
    
83.                                           };
    
84. 
    
85. const pFunctionReadBit ReadSda[4]      =  {
    
86.                                             ReadADC_SDA1,
    
87.                                             ReadADC_SDA2,
    
88.                                             ReadADC_SDA3,
    
89.                                             ReadADC_SDA4
    
90.                                           };
    
91.   
    
92. void EnableADCPinExitInterrupt(uint8_t channel)
    
93. {
    
94.    
    
95. }
    
96. 
    
97. void DisableADCPinExitInterrupt(uint8_t channel)
    
98. {
    
99.    
    
100. }
     
101. 
     
102. ERRORCODE EnableSample(uint8_t channel)
     
103. {
     
104.     /* reset sclk */
     
105.     ResetSck[channel]();
     
106.     //SetSck[channel]();
     
107.     /* reset count */
     
108.     ADC_SAMPLE_COUNT[channel] = 0;
     
109.     /* enable exit sda high to low interrupt */
     
110.    
     
111.     EnableADCPinExitInterrupt(channel);
     
112.     ADC_SAMPLE_SWITCH[channel] = ON;
     
113.    
     
114.     /* if count > 5 the data is valid */
     
115.     return SUCCEED;
     
116. }
     
117. 
     
118. ERRORCODE DisableSample(uint8_t channel)
     
119. {
     
120.     /* set sck */
     
121.     SetSck[channel]();
     
122.     //ResetSck[channel]();
     
123.     /* reset count */
     
124.     ADC_SAMPLE_COUNT[channel] = 0xFFFFFFFF;
     
125.     /* disable exit sda high to low interrupt */
     
126.     //DISABLE_EXIT;
     
127.     DisableADCPinExitInterrupt(channel);
     
128.     ADC_SAMPLE_SWITCH[channel] = OFF;
     
129.    
     
130.     /*  */
     
131.     return SUCCEED;
     
132. }
     
133. 
     
134. ERRORCODE GetADCSampleValue(uint8_t channel,uint32_t *value)
     
135. {
     
136.     uint8_t count = 0;   
     
137.     *value = 0;
     
138.     for (count = 0;count < 24;count++)
     
139.     {
     
140.         /* set sck high  */
     
141.         SetSck[channel]();
     
142.         SetSck[channel]();
     
143.         SetSck[channel]();
     
144.         SetSck[channel]();
     
145.         /* read sda      */
     
146.         *value |= (uint32_t)ReadSda[channel]();
     
147.         (*value) <<= 1;
     
148.         SetSck[channel]();
     
149.         SetSck[channel]();
     
150.         SetSck[channel]();
     
151.         SetSck[channel]();
     
152.         SetSck[channel]();
     
153.         
     
154.         /* reset sck low */
     
155.         ResetSck[channel]();
     
156.         ResetSck[channel]();
     
157.         ResetSck[channel]();
     
158.         ResetSck[channel]();
     
159. //        ResetSck[channel]();/* Just for Delay */
     
160. //        ResetSck[channel]();
     
161.     }
     
162.     (*value) >>= 1;
     
163.     //SetSck[channel]();
     
164.    
     
165.     return SUCCEED;
     
166. }
     
167. 小思路···

复制代码