Perf-V开发板三：定时中断方式的流水灯实验

mabo124

        不知道什么原因Perf-V IDE下中断无法工作，我实现的流水灯是使用查询方式下进行的，但是根据官方群技术支持工作人员所述是可以定时中断方式工作的，所以我便在虚拟机下进行了验证，果不其然其工作杠杠的（我在反向进行修改，将虚拟机下的工程移植到Perf-V IDE下，但是没有成功，这部分工作还将继续摸索中，究其原因还是不太喜欢linux下开发吧）。现总结如下。
        1. 修改E203 SOC核，如前一贴所述。
        2. 找到hifive1.h文件，修改对led0-3的宏定义，如下图1所示。hifive1.h路径如图1中红色框所示。

图1  hifive1.h文件

         主程序如下所示。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include "platform.h"
   
4. #include <string.h>
   
5. #include "plic/plic_driver.h"
   
6. <font style="background-color: magenta;">#include "../../bsp/env/hifive1.h"</font>
   
7. #include "encoding.h"
   
8. #include <unistd.h>
   
9. #include "stdatomic.h"
   
10. #define uchar unsigned char
    
11. #define uint unsigned int
    
12. uint32_t count=0;
    
13. uint32_t delay_mark=0;
    
14. void delay(uint32_t times);
    
15. void reset_demo (uint32_t times);
    
16. void GPIO_SET(uint32_t pin_num,uint32_t pin_val,uint32_t pin_model);
    
17. 
    
18. // Structures for registering different interrupt handlers
    
19. // for different parts of the application.
    
20. typedef void (*function_ptr_t) (void);
    
21. 
    
22. 
    
23. void no_interrupt_handler (void) {};
    
24. 
    
25. function_ptr_t g_ext_interrupt_handlers[PLIC_NUM_INTERRUPTS];
    
26. 
    
27. 
    
28. // Instance data for the PLIC.
    
29. 
    
30. plic_instance_t g_plic;
    
31. 
    
32. 
    
33. /*Entry Point for PLIC Interrupt Handler*/
    
34. void handle_m_ext_interrupt(){
    
35.   plic_source int_num  = PLIC_claim_interrupt(&g_plic);
    
36.   if ((int_num >=1 ) && (int_num < PLIC_NUM_INTERRUPTS)) {
    
37.     g_ext_interrupt_handlers[int_num]();
    
38.   }
    
39.   else {
    
40.     exit(1 + (uintptr_t) int_num);
    
41.   }
    
42.   PLIC_complete_interrupt(&g_plic, int_num);
    
43. }
    
44. 
    
45. 
    
46. /*Entry Point for Machine Timer Interrupt Handler*/
    
47. void handle_m_time_interrupt(){
    
48.          
    
49.    clear_csr(mie, MIP_MTIP);
    
50.    volatile uint64_t * mtime       = (uint64_t*) (CLINT_CTRL_ADDR + CLINT_MTIME);
    
51.    volatile uint64_t * mtimecmp    = (uint64_t*) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
    
52.     uint64_t now = *mtime;
    
53.     uint64_t then = now +0.5* RTC_FREQ;
    
54.    *mtimecmp = then;
    
55.   count++;
    
56.        
    
57. if(count==1)
    
58. {
    
59.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
    
60.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD4_r));
    
61.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD5_r));
    
62.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD6_r));
    
63.        
    
64.         GPIO_SET(led1,0,output);
    
65.         GPIO_SET(led2,1,output);
    
66.         GPIO_SET(led3,1,output);       
    
67.         GPIO_SET(led4,1,output);
    
68. }
    
69. if(count==2)
    
70. {
    
71.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
    
72.                GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD4_g));
    
73.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD5_g));
    
74.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD6_g));
    
75.        
    
76.         GPIO_SET(led1,1,output);
    
77.         GPIO_SET(led2,0,output);
    
78.         GPIO_SET(led3,1,output);       
    
79.         GPIO_SET(led4,1,output);
    
80. }
    
81. if(count==3)
    
82. {
    
83.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
    
84.        GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD4_b));
    
85.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD5_b));
    
86.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD6_b));
    
87. 
    
88.         GPIO_SET(led1,1,output);
    
89.         GPIO_SET(led2,1,output);
    
90.         GPIO_SET(led3,0,output);       
    
91.         GPIO_SET(led4,1,output);
    
92. }
    
93. if(count==4)
    
94. {
    
95.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
    
96.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD4_r));
    
97.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD4_g));
    
98.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD4_b));
    
99. 
    
100.         GPIO_SET(led1,1,output);
     
101.         GPIO_SET(led2,1,output);
     
102.         GPIO_SET(led3,1,output);       
     
103.         GPIO_SET(led4,0,output);
     
104. }
     
105. if(count==5)
     
106. {
     
107.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
     
108.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD5_r));
     
109.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD5_g));
     
110.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD5_b));
     
111. 
     
112.         GPIO_SET(led1,1,output);
     
113.         GPIO_SET(led2,1,output);
     
114.         GPIO_SET(led3,1,output);       
     
115.         GPIO_SET(led4,1,output);
     
116. }
     
117. if(count==6)
     
118. {
     
119.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
     
120.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD6_r));
     
121.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD6_g));
     
122.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD6_b));
     
123. 
     
124.         GPIO_SET(led1,1,output);
     
125.         GPIO_SET(led2,1,output);
     
126.         GPIO_SET(led3,0,output);       
     
127.         GPIO_SET(led4,1,output);
     
128. }
     
129. if(count==7)
     
130. {
     
131.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
     
132.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD4_r));
     
133.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD5_r));
     
134.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD6_r));
     
135. 
     
136.         GPIO_SET(led1,1,output);
     
137.         GPIO_SET(led2,0,output);
     
138.         GPIO_SET(led3,1,output);       
     
139.         GPIO_SET(led4,1,output);
     
140. }
     
141. if(count==8)
     
142. {
     
143.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
     
144.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD4_g));
     
145.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD5_g));
     
146.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD6_g));
     
147. 
     
148.         GPIO_SET(led1,0,output);
     
149.         GPIO_SET(led2,1,output);
     
150.         GPIO_SET(led3,1,output);       
     
151.         GPIO_SET(led4,1,output);
     
152. }
     
153. if(count==9)
     
154. {
     
155.         uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
     
156.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD4_b));
     
157.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD5_b));
     
158.         GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x0 << ledD6_b));
     
159. 
     
160.         GPIO_SET(led1,1,output);
     
161.         GPIO_SET(led2,1,output);
     
162.         GPIO_SET(led3,1,output);       
     
163.         GPIO_SET(led4,1,output);
     
164. }
     
165. if(count==9)
     
166. {
     
167.         count=0;
     
168. }
     
169. 
     
170.   // read the current value of the LEDS and invert them.
     
171. 
     
172. 
     
173.    
     
174.      // uint32_t leds = GPIO_REG(GPIO_OUTPUT_VAL);
     
175.      // GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << BLUE_LED_OFFSET));
     
176.        
     
177.    
     
178.     //GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << ledD4_r));
     
179.   // Re-enable the timer interrupt.
     
180. <font style="background-color: darkorchid;">  set_csr(mie, MIP_MTIP);</font>
     
181. 
     
182. }
     
183. 
     
184. 
     
185. void print_instructions() {
     
186. 
     
187.   //write (STDOUT_FILENO, instructions_msg, strlen(instructions_msg));
     
188.   //write (STDOUT_FILENO, instructions_msg_sirv, strlen(instructions_msg_sirv));
     
189.   // printf ("%s",instructions_msg_sirv);
     
190. 
     
191. }
     
192. 
     
193. 
     
194. void reset_demo (uint32_t times){
     
195. 
     
196.   // Disable the machine & timer interrupts until setup is done.
     
197. 
     
198.   clear_csr(mie, MIP_MEIP);
     
199.   clear_csr(mie, MIP_MTIP);
     
200. 
     
201.   for (int ii = 0; ii < PLIC_NUM_INTERRUPTS; ii ++){
     
202.     g_ext_interrupt_handlers[ii] = no_interrupt_handler;
     
203.   }
     
204. 
     
205. 
     
206.     // Set the machine timer to go off in 3 seconds.
     
207.    
     
208.     volatile uint64_t * mtime       = (uint64_t*) (CLINT_CTRL_ADDR + CLINT_MTIME);
     
209.     volatile uint64_t * mtimecmp    = (uint64_t*) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
     
210.     uint64_t now = *mtime;
     
211.     uint64_t then = now + times*RTC_FREQ;
     
212.     *mtimecmp = then;
     
213. 
     
214.     // Enable the Machine-External bit in MIE
     
215. <font style="background-color: orange;">    set_csr(mie, MIP_MEIP);</font>
     
216.     // Enable the Machine-Timer bit in MIE
     
217. <font style="background-color: orange;">    set_csr(mie, MIP_MTIP);</font>
     
218.     // Enable interrupts in general.
     
219. <font color="black" style="background-color: orange;">    set_csr(mstatus, MSTATUS_MIE);</font>
     
220. }
     
221. 
     
222. 
     
223. void GPIO_SET(uint32_t pin_num,uint32_t pin_val,uint32_t pin_model)
     
224. {
     
225.     if(pin_model==output)
     
226.      {       
     
227.         GPIO_REG(GPIO_OUTPUT_EN) |= (0x01<<pin_num);
     
228.         if(pin_val==1)
     
229.         {
     
230.              GPIO_REG(GPIO_OUTPUT_VAL) |=(0x01<<pin_num);
     
231.         }
     
232.         if(pin_val==0)
     
233.         {
     
234.              GPIO_REG(GPIO_OUTPUT_VAL) &=~(0x01<<pin_num);
     
235.         }
     
236.      }
     
237.     if(pin_model==input)
     
238.     {
     
239.         GPIO_REG(GPIO_INPUT_EN) |= (0x01<<pin_num);
     
240.     }
     
241. 
     
242. }
     
243. 
     
244. int main(int argc, char **argv)
     
245. {
     
246. 
     
247. 
     
248. 
     
249. 
     
250.   /**************************************************************************
     
251.    * Set up the PLIC
     
252.    *
     
253.    *************************************************************************/
     
254.    PLIC_init(&g_plic,
     
255.             PLIC_CTRL_ADDR,
     
256.             PLIC_NUM_INTERRUPTS,
     
257.             PLIC_NUM_PRIORITIES);
     
258. 
     
259.    reset_demo(1);
     
260.         GPIO_SET(ledD4_r,1,output);
     
261.         GPIO_SET(ledD4_g,1,output);
     
262.         GPIO_SET(ledD4_b,1,output);
     
263. 
     
264.         GPIO_SET(ledD5_r,1,output);
     
265.         GPIO_SET(ledD5_g,1,output);
     
266.         GPIO_SET(ledD5_b,1,output);
     
267. 
     
268.         GPIO_SET(ledD6_r,1,output);
     
269.         GPIO_SET(ledD6_g,1,output);
     
270.         GPIO_SET(ledD6_b,1,output);
     
271.        
     
272.         GPIO_SET(led4,1,output);
     
273.         GPIO_SET(led1,1,output);
     
274.         GPIO_SET(led2,1,output);       
     
275.         GPIO_SET(led3,1,output);
     
276.        
     
277.         //GPIO_SET(BLUE_LED_OFFSET,1,output);
     
278. 
     
279.   while (1){
     
280.          
     
281.        
     
282.   }
     
283. 
     
284. 
     
285.   return 0;
     
286. 
     
287. }
     
288. 
     
289. 
     

复制代码

        3. 执行编译命令。

1. make software PROGRAM=demo_gpio BOARD=Perf-V-creative-board

复制代码

        4. 执行加载命令。

1. make upload PROGRAM=demo_gpio BOARD=Perf-V-creative-board

复制代码

       5.  效果如下。