"LPC54100" running on M0 event-driven Architecture (i)

@20150216

The first contact with asymmetric dual-core MCU, due to a lot of knowledge unfamiliar, these three days encountered a lot of problems. Now finally the event driven on the M0 nuclear run up, send a brief introduction of this event-driven architecture and the 5410x chip learning from these days.
With regard to the event-driven architecture, it is mainly used for low power design and can easily enter sleep mode. General single-chip microcomputer bare Ben are polling, such as:

1. void Main ()
2. {
3. while (1)
4. {
5. Tesk1 ();
6. Tesk2 ();
7. Tesk3 ();
8. }
9. }

Copy Code

In this polling process, it is difficult to determine when to hibernate, how long to sleep, and what level of sleep to use.

The event-driven main function is as follows (take VSF as an example):

2. while (1)
4. {
6. Vsfsm_poll ();
10. Vsf_enter_critical ();
12. if (!vsfsm_get_event_pending ())
14. {
16. Vsf_leave_critical ();
18. __wfi ();
20. }
22. Else
24. {
26. Vsf_leave_critical ();
28. }
30. }

Copy Code

VSF adds an event queue to the program that sleeps when the event queue is empty. The sleep time is determined by the wake-up timer configured by the program, and of course some external hardware interrupts can also be awakened. If you need to use a different sleep level, you also need to do a sleep level manager, different threads require different sleep levels, and then the manager decides the sleep level. Of course, these fine-grained configuration will be more troublesome ...

In fact, the event-driven capable, in the RTOs are capable, many things rtos can do better, more comfortable. However, the event-driven has one of the biggest advantages: the province of RAM, in many low-power MCU, RAM is generally small, although the RTOs can be cropped, but the allocation of each task stack can not be cropped, when more tasks, RAM allocation is also very annoying. The event driver is still a bare-Ben, just put the thread (a function pointer plus an event state) in the queue for management, one by one call. Each thread only spends more than 10 bytes of RAM.

This time with Simon's event-driven VSF platform, the code is on GitHub, and Github.com/versaloon/vsf,21ic has some introductory posts that are interested to see for themselves.
The following example code caught dead, very very coarse, the code in the post added a Chinese explanation

2. Thread 1
4. Define an event state
6. #define EVENT_1_USER_LOCAL_SCANF (vsfsm_evt_user_local + 1)
8. static struct vsfsm_state_t *
10. Event_1_handler (struct vsfsm_t *sm, vsfsm_evt_t evt);
12. struct vsfsm_t event_1_sm =
14. {
16. {Event_1_handler},//Initialize Handler
18. };
20. For generating periodic event timers at intervals of 5 seconds
22. static struct vsftimer_timer_t Event_1_timer =
24. {
26. 5000,//interval is 5 seconds
28. &EVENT_1_SM,//corresponding state machine
30. EVENT_1_USER_LOCAL_SCANF,//Cycle events
32. };
36. struct vsfsm_state_t *
38. Event_1_handler (struct vsfsm_t *sm, vsfsm_evt_t evt)
40. {
42. Switch (EVT)
44. {
46. Case VSFSM_EVT_INIT://Initialize event, default execution
48. Vsftimer_register (&event_1_timer);
50. Break
52. Case EVENT_1_USER_LOCAL_SCANF://Periodic event handling
54. Board_uartputstr ("Event 1rn"); Print out "Event 1"
56. Print_tick (); Print the current system tick
58. Break
60. Default
62. Break
64. }
68. return NULL;
70. }
74. Thread 2, change the thread interval to 3 seconds
76. #define EVENT_2_USER_LOCAL_SCANF (vsfsm_evt_user_local + 1)
78. static struct vsfsm_state_t *
80. Event_2_handler (struct vsfsm_t *sm, vsfsm_evt_t evt);
82. struct vsfsm_t event_2_sm =
84. {
86. {Event_2_handler},
88. };
90. static struct vsftimer_timer_t Event_2_timer =
92. {
94. 3000,
96. &EVENT_2_SM,
98. EVENT_2_USER_LOCAL_SCANF,
100. };
104. struct vsfsm_state_t *
106. Event_2_handler (struct vsfsm_t *sm, vsfsm_evt_t evt)
108. {
110. Switch (EVT)
112. {
114. Case Vsfsm_evt_init:
116. Vsftimer_register (&event_2_timer);
118. Break
120. Case EVENT_2_USER_LOCAL_SCANF:
122. Board_uartputstr ("event 2rn");
124. Print_tick ();
126. Break
128. Default
130. Break
132. }
136. return NULL;
138. }
144. int main (void)
146. {
148. Serial initialization
150. Board_uart_init ();
152. Wake with Utick interrupt
154. Board_utick_init ();
158. Vsftimer_init ();
162. Board_uartputstr ("Start!rn");
166. Vsfsm_init (&EVENT_1_SM);
168. Vsfsm_init (&EVENT_2_SM);
172. Vsf_leave_critical ();
174. while (1)
176. {
178. Vsfsm_poll (); Polling state machine
182. Vsf_enter_critical ();
184. if (!vsfsm_get_event_pending ())//Determine if there are unhandled events
186. {
188. Vsf_leave_critical ();
190. __wfi ();
192. }
194. Else
196. {
198. Vsf_leave_critical ();
200. }
202. }
204. }

Copy Code

Serial output:

PS: Now the Vsftimer does not do the dynamic management of sleep time, but rather a simple rough timing wake-up once to see if there are any events to deal with. This feature I will be perfected in the back.
There's a lot of fun in Simon's architecture, and it's interesting to study.

"LPC54100" running on M0 event-driven Architecture (i)