用自带驱动控制一个步进电机

     最近忙活了一下硬件结构，现在继续开始开发。为了节省时间和精力，也是自己驱动渣渣，所以直接用自带的驱动了。主要用到了sprintf(),system()函数以及usleep()函数。
     sprintf()函数原型为int sprintf(char *str, char * format [, argument, ...])，用于将格式化的数据写入字符串，这里是将需要在终端输入的指令写入tmp中。
     system()原型为int system(const char * string)，会调用fork()产生子进程，由子进程来执行参数string字符串所代表的命令，此命令执行完后随即返回原调用的进程。也就是将上面转换指令为tmp放到后台运行，并能返回现在的程序。
     usleep()原型为void usleep(int micro_seconds)，功能为把进程挂起一段时间， 单位是微秒（百万分之一秒）。这个没什么说的。
     然后将GPIO的初始化、释放、方向设置以及压值设置分别做成独立函数，要记得用malloc()后进行free()，之后进行调用就很方便了。
     这是程序在板子上的工作打印内容。
     

     用这块板子控制步进电机很稳，现象如下所示。
    http://v.youku.com/v_show/id_XMTgzMjMxMjYzNg==.html
      程序如下所示。

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. #include
   
9. #include
   
10. #include
    
11. #include
    
12. 
    
13. 
    
14. #define GPIO_OUTPUT 1  //Set the gpio derection output
    
15. #define GPIO_INPUT  0  //Set the gpio derection input
    
16. 
    
17. #define GPIO_HIGH 1 //Set the gpio output high
    
18. #define GPIO_LOW  0  //Set the gpio input low
    
19. 
    
20. /**
    
21. * @brief: init_GPIO function
    
22. * Describe : GPIO_x_y init
    
23. * @Param: x:
    
24. * @Param: y:
    
25. */
    
26. void init_GPIO(int x, int y)
    
27. {
    
28.     char* tmp;
    
29.     int gpio;
    
30.    
    
31.     tmp = (unsigned char*)malloc(64);
    
32.     gpio = 32 * x + y;
    
33.     sprintf(tmp,"echo %d > /sys/class/gpio/export",gpio);
    
34.     printf("GPIO%d_%d init.\n",x, y);
    
35.     system(tmp);
    
36.     free(tmp);
    
37. }
    
38. 
    
39. /**
    
40. * @brief: release_GPIO function
    
41. * Describe : to release GPIO_x_y
    
42. * @Param: x:
    
43. * @Param: y:
    
44. */
    
45. void release_GPIO(int x, int y)
    
46. {
    
47.     char* tmp;
    
48.     int gpio;
    
49.    
    
50.     tmp = (unsigned char*)malloc(64);
    
51.     gpio = 32 * x + y;
    
52.     sprintf(tmp,"echo %d > /sys/class/gpio/unexport",gpio);
    
53.     printf("GPIO%d_%d release.\n",x, y);
    
54.     system(tmp);
    
55.     free(tmp);
    
56. }
    
57. 
    
58. /**
    
59. * @brief: direction_GPIO function
    
60. * Describe : to release GPIO_x_y
    
61. * @Param: x:
    
62. * @Param: y:
    
63. * @Param: n: direction   1:out   0:in
    
64. */
    
65. void direction_GPIO(int x, int y, int n)
    
66. {
    
67.     char* tmp;
    
68.     int gpio;
    
69.    
    
70.     tmp = (unsigned char*)malloc(64);
    
71.     gpio = 32 * x + y;
    
72.     if(n==1){
    
73.         sprintf(tmp,"echo 'out' > /sys/class/gpio/gpio%d/direction",gpio);
    
74.         printf("The direction of GPIO%d_%d is output.\n",x, y);
    
75.     }
    
76.    
    
77.     if(n==0){
    
78.         sprintf(tmp,"echo 'in' > /sys/class/gpio/gpio%d/direction",gpio);
    
79.         printf("The direction of GPIO%d_%d is input.\n",x, y);
    
80.     }
    
81.     system(tmp);
    
82.     free(tmp);
    
83. }
    
84. 
    
85. /**
    
86. * @brief: value_GPIO function
    
87. * Describe : when the direction of the
    
88. * gpio is out, set it's value
    
89. * @Param: x:
    
90. * @Param: y:
    
91. * @Param: n: out value   1:High   0:low
    
92. */
    
93. void value_GPIO(int x, int y, int n)
    
94. {
    
95.     char* tmp;
    
96.     int gpio;
    
97.    
    
98.     tmp = (unsigned char*)malloc(64);
    
99.     gpio = 32 * x + y;
    
100.    
     
101.     sprintf(tmp,"echo %d > /sys/class/gpio/gpio%d/value", n, gpio);
     
102.     printf("The value of GPIO%d_%d is %d.\n",x, y, n);
     
103. 
     
104.     system(tmp);
     
105.     free(tmp);
     
106. }
     
107. 
     
108. //gpio_fd = open("/sys/class/gpio/gpio12/value",O_RDONLY);
     
109. /**
     
110. * @brief: main function  
     
111. * @Param: argc: number of parameters
     
112. * @Param: argv: parameters list
     
113. */
     
114. int main(int argc, char *argv[])
     
115. {
     
116.         int i =1000;
     
117.         printf("hello world ！ \n");
     
118.         init_GPIO(5,9);
     
119.         init_GPIO(5,7);
     
120.        direction_GPIO(5,9,GPIO_OUTPUT);
     
121.        direction_GPIO(5,7,GPIO_OUTPUT);
     
122.         value_GPIO(5,7,GPIO_HIGH);
     
123.         while(i>0){
     
124.                 value_GPIO(5,9,GPIO_HIGH);
     
125.                usleep(10000);  //10ms
     
126.                value_GPIO(5,9,GPIO_LOW);
     
127.                 usleep(10000);  //10ms
     
128.             i--;
     
129.         }
     
130. 
     
131.         release_GPIO(5,9);
     
132.         release_GPIO(5,7);
     
133.         return 1;
     
134. }
     
135. 
     

复制代码