C协程库：Protothreads源文件和示例

sky-Hawk where

Protothreads是Adam Dunkels写的C协程库非常的轻，只用头文件就实现了。

源文件： pt-1.4.tar.gz (213.07 KB, 下载次数: 0)

2013-3-18 09:34 上传

点击文件名下载附件
下载地址在这里：http://dunkels.com/adam/pt/download.html

前文的压缩包里有示例
从http://dunkels.com/adam/pt/转贴sample如下

Examples:

• A reliable communication protocol
• Delays - text scrolling on an LCD panel
• A code lock
• The bounded buffer with protothread semaphores
• A radio driver written both with protothreads and events
  

A reliable communication protocolIn computer communication, there are many cases in which a protocol needs to cope with packet loss. In order to provide a reliable channel, lost packets must be retransmitted. This example shows a simple communication protocol that uses (the absence of) acknowledgment packets to detect a lost packet. If a lost packet is detected, the packet is retransmitted.
The example shows two protothreads, one for the sender and one for the receiver.

1. #include "pt.h"
   
2. 
   
3. PT_THREAD(sender(struct pt *pt))
   
4. {
   
5.   PT_BEGIN(pt);  
   
6.   do {
   
7.     send_packet();
   
8.     /* Wait until an ackowledgement has been received, or until the
   
9.        timer expires. If the timer expires, we should send the packet
   
10.        again. */
    
11.     timer_set(&timer, TIMEOUT);
    
12.     PT_WAIT_UNTIL(pt, acknowledgment_received() ||
    
13.                       timer_expired(&timer));
    
14.   } while(timer_expired(&timer));  
    
15.   PT_END(pt);
    
16. }
    
17. 
    
18. PT_THREAD(receiver(struct pt *pt))
    
19. {
    
20.   PT_BEGIN(pt);
    
21.   /* Wait until a packet has been received, and send an
    
22.      acknowledgment. */
    
23.   PT_WAIT_UNTIL(pt, packet_received());
    
24.   send_acknowledgement();  
    
25.   PT_END(pt);
    
26. }

复制代码

Delays - text scrolling on an LCD panelProtothreads can be used for introducing delays inside a function, without using a full threading model. The following example shows a function writing text to a one-line LCD panel. If the text is longer than the size of the panel, the text should be scrolling in from the right.

1. #include "pt.h"
   
2. #include "timer.h"
   
3. 
   
4. struct state {
   
5.   char *text;
   
6.   char *scrollptr;
   
7.   struct pt pt;
   
8.   struct timer timer;
   
9. };
   
10. 
    
11. PT_THREAD(display_text(struct state *s))
    
12. {
    
13.   PT_BEGIN(&s->pt);
    
14. 
    
15.   /* If the text is shorter than the display size, show it right
    
16.      away. */
    
17.   if(strlen(s->text) <= LCD_SIZE) {
    
18.     lcd_display_text(s->text);
    
19.   } else {   
    
20.     /* If the text is longer than the display, we should scroll in the
    
21.        text from the right with a delay of one second per scroll
    
22.        step. We do this in a for() loop, where the loop variable is
    
23.        the pointer to the first character to be displayed. */
    
24.     for(s->scrollptr = s->text;
    
25.         strlen(s->scrollptr) > LCD_SIZE;
    
26.         ++s->scrollptr) {
    
27.       lcd_display_text(s->scrollptr);
    
28. 
    
29.       /* Wait for one second. */
    
30.       timer_set(&s->timer, ONE_SECOND);
    
31.       PT_WAIT_UNTIL(&s->pt, timer_expired(&s->timer));
    
32.     }
    
33.   }
    
34.   
    
35.   PT_END(&s->pt);
    
36. }

复制代码

A code lockThis example is a bit more complicated and shows how to implement a simple code lock - the kind of device that is placed next to doors and that you have to push a four digit number into in order to unlock the door.
The code lock waits for key presses from a numeric keyboard and if the correct code is entered, the lock is unlocked. There is a maximum time of one second between each key press, and after the correct code has been entered, no more keys must be pressed for 0.5 seconds before the lock is opened.

The code uses external functions for timers and for checking the keyboard. These functions are included in the full source code for this example, which is included in the downloadable tarball.

1. /*
   
2. * This is the code that has to be entered.
   
3. */
   
4. static const char code[4] = {'1', '4', '2', '3'};
   
5. 
   
6. /*
   
7. * Declaration of the protothread function implementing the code lock
   
8. * logic. The protothread function is declared using the PT_THREAD()
   
9. * macro. The function is declared with the "static" keyword since it
   
10. * is local to this file. The name of the function is codelock_thread
    
11. * and it takes one argument, pt, of the type struct pt.
    
12. *
    
13. */
    
14. static
    
15. PT_THREAD(codelock_thread(struct pt *pt))
    
16. {
    
17.   /* This is a local variable that holds the number of keys that have
    
18.    * been pressed. Note that it is declared with the "static" keyword
    
19.    * to make sure that the variable is *not* allocated on the stack.
    
20.    */
    
21.   static int keys;
    
22. 
    
23.   /*
    
24.    * Declare the beginning of the protothread.
    
25.    */
    
26.   PT_BEGIN(pt);
    
27. 
    
28.   /*
    
29.    * We'll let the protothread loop until the protothread is
    
30.    * expliticly exited with PT_EXIT().
    
31.    */
    
32.   while(1) {
    
33. 
    
34.     /*
    
35.      * We'll be reading key presses until we get the right amount of
    
36.      * correct keys.
    
37.      */
    
38.     for(keys = 0; keys < sizeof(code); ++keys) {
    
39. 
    
40.       /*
    
41.        * If we haven't gotten any keypresses, we'll simply wait for one.
    
42.        */
    
43.       if(keys == 0) {
    
44. 
    
45.         /*
    
46.          * The PT_WAIT_UNTIL() function will block until the condition
    
47.          * key_pressed() is true.
    
48.          */
    
49.         PT_WAIT_UNTIL(pt, key_pressed());
    
50.       } else {
    
51.        
    
52.         /*
    
53.          * If the "key" variable was larger than zero, we have already
    
54.          * gotten at least one correct key press. If so, we'll not
    
55.          * only wait for the next key, but we'll also set a timer that
    
56.          * expires in one second. This gives the person pressing the
    
57.          * keys one second to press the next key in the code.
    
58.          */
    
59.         timer_set(&codelock_timer, 1000);
    
60. 
    
61.         /*
    
62.          * The following statement shows how complex blocking
    
63.          * conditions can be easily expressed with protothreads and
    
64.          * the PT_WAIT_UNTIL() function.
    
65.          */
    
66.         PT_WAIT_UNTIL(pt, key_pressed() || timer_expired(&codelock_timer));
    
67. 
    
68.         /*
    
69.          * If the timer expired, we should break out of the for() loop
    
70.          * and start reading keys from the beginning of the while(1)
    
71.          * loop instead.
    
72.          */
    
73.         if(timer_expired(&codelock_timer)) {
    
74.           printf("Code lock timer expired.\n");
    
75.           
    
76.           /*
    
77.            * Break out from the for() loop and start from the
    
78.            * beginning of the while(1) loop.
    
79.            */
    
80.           break;
    
81.         }
    
82.       }
    
83. 
    
84.       /*
    
85.        * Check if the pressed key was correct.
    
86.        */
    
87.       if(key != code[keys]) {
    
88.         printf("Incorrect key '%c' found\n", key);
    
89.         /*
    
90.          * Break out of the for() loop since the key was incorrect.
    
91.          */
    
92.         break;
    
93.       } else {
    
94.         printf("Correct key '%c' found\n", key);
    
95.       }
    
96.     }
    
97. 
    
98.     /*
    
99.      * Check if we have gotten all keys.
    
100.      */
     
101.     if(keys == sizeof(code)) {
     
102.       printf("Correct code entered, waiting for 500 ms before unlocking.\n");
     
103. 
     
104.       /*
     
105.        * Ok, we got the correct code. But to make sure that the code
     
106.        * was not just a fluke of luck by an intruder, but the correct
     
107.        * code entered by a person that knows the correct code, we'll
     
108.        * wait for half a second before opening the lock. If another
     
109.        * key is pressed during this time, we'll assume that it was a
     
110.        * fluke of luck that the correct code was entered the first
     
111.        * time.
     
112.        */
     
113.       timer_set(&codelock_timer, 500);      
     
114.       PT_WAIT_UNTIL(pt, key_pressed() || timer_expired(&codelock_timer));
     
115. 
     
116.       /*
     
117.        * If we continued from the PT_WAIT_UNTIL() statement without
     
118.        * the timer expired, we don't open the lock.
     
119.        */
     
120.       if(!timer_expired(&codelock_timer)) {
     
121.         printf("Key pressed during final wait, code lock locked again.\n");
     
122.       } else {
     
123. 
     
124.         /*
     
125.          * If the timer expired, we'll open the lock and exit from the
     
126.          * protothread.
     
127.          */
     
128.         printf("Code lock unlocked.\n");
     
129.         PT_EXIT(pt);
     
130.       }
     
131.     }
     
132.   }
     
133. 
     
134.   /*
     
135.    * Finally, we'll mark the end of the protothread.
     
136.    */
     
137.   PT_END(pt);
     
138. }

复制代码

The bounded buffer with protothread semaphoresThe following example shows how to implement the bounded buffer problem using the protothreads semaphore library. The example uses three protothreads: one producer() protothread that produces items, one consumer() protothread that consumes items, and one driver_thread() that schedules the producer and consumer protothreads.
Note that there is no need for a mutex to guard the add_to_buffer() and get_from_buffer() functions because of the implicit locking semantics of protothreads - a protothread will never be preempted and will never block except in an explicit PT_WAIT statement.

1. #include "pt-sem.h"
   
2. 
   
3. #define NUM_ITEMS 32
   
4. #define BUFSIZE 8
   
5. 
   
6. static struct pt_sem full, empty;
   
7. 
   
8. static
   
9. PT_THREAD(producer(struct pt *pt))
   
10. {
    
11.   static int produced;
    
12.   
    
13.   PT_BEGIN(pt);
    
14.   
    
15.   for(produced = 0; produced < NUM_ITEMS; ++produced) {
    
16.   
    
17.     PT_SEM_WAIT(pt, &full);
    
18.    
    
19.     add_to_buffer(produce_item());   
    
20.    
    
21.     PT_SEM_SIGNAL(pt, &empty);
    
22.   }
    
23. 
    
24.   PT_END(pt);
    
25. }
    
26. 
    
27. static
    
28. PT_THREAD(consumer(struct pt *pt))
    
29. {
    
30.   static int consumed;
    
31.   
    
32.   PT_BEGIN(pt);
    
33. 
    
34.   for(consumed = 0; consumed < NUM_ITEMS; ++consumed) {
    
35.    
    
36.     PT_SEM_WAIT(pt, &empty);
    
37.    
    
38.     consume_item(get_from_buffer());   
    
39.    
    
40.     PT_SEM_SIGNAL(pt, &full);
    
41.   }
    
42. 
    
43.   PT_END(pt);
    
44. }
    
45. 
    
46. static
    
47. PT_THREAD(driver_thread(struct pt *pt))
    
48. {
    
49.   static struct pt pt_producer, pt_consumer;
    
50. 
    
51.   PT_BEGIN(pt);
    
52.   
    
53.   PT_SEM_INIT(&empty, 0);
    
54.   PT_SEM_INIT(&full, BUFSIZE);
    
55. 
    
56.   PT_INIT(&pt_producer);
    
57.   PT_INIT(&pt_consumer);
    
58. 
    
59.   PT_WAIT_THREAD(pt, producer(&pt_producer) &
    
60.                      consumer(&pt_consumer));
    
61. 
    
62.   PT_END(pt);
    
63. }

复制代码

A radio driver written both with protothreads and events

This example shows an interrupt handler in a device driver for a TR1001 radio chip. The driver receives incoming data in bytes and constructs a frame that is covered by a CRC checksum. The driver is implemented both with protothreads and with an explicit state machine. The state machine has 11 states and is implemented using the C switch() statement. In contrast, the protothreads-based implementation does not have any explicit states.

The flow of control in the state machine-based implementation is quite hard to follow from inspection of the code, whereas the flow of control is evident in the protothreads based implementation.

Protothreads-based implementation

1. PT_THREAD(tr1001_rxhandler(unsigned char incoming_byte))
   
2. {
   
3.   PT_YIELDING();
   
4.   static unsigned char rxtmp, tmppos;
   
5. 
   
6.   PT_BEGIN(&rxhandler_pt);
   
7. 
   
8.   while(1) {
   
9. 
   
10.     /* Wait until we receive the first syncronization byte. */
    
11.     PT_WAIT_UNTIL(&rxhandler_pt, incoming_byte == SYNCH1);
    
12. 
    
13.     tr1001_rxstate = RXSTATE_RECEVING;
    
14.    
    
15.     /* Read all incoming syncronization bytes. */
    
16.     PT_WAIT_WHILE(&rxhandler_pt, incoming_byte == SYNCH1);
    
17. 
    
18.     /* We should receive the second synch byte by now, otherwise we'll
    
19.        restart the protothread. */
    
20.     if(incoming_byte != SYNCH2) {
    
21.       PT_RESTART(&rxhandler_pt);
    
22.     }
    
23. 
    
24.     /* Reset the CRC. */
    
25.     rxcrc = 0xffff;
    
26. 
    
27.     /* Read packet header. */
    
28.     for(tmppos = 0; tmppos < TR1001_HDRLEN; ++tmppos) {
    
29. 
    
30.       /* Wait for the first byte of the packet to arrive. */
    
31.       PT_YIELD(&rxhandler_pt);
    
32. 
    
33.       /* If the incoming byte isn't a valid Manchester encoded byte,
    
34.          we start again from the beinning. */
    
35.       if(!me_valid(incoming_byte)) {
    
36.         PT_RESTART(&rxhandler_pt);
    
37.       }
    
38. 
    
39.       rxtmp = me_decode8(incoming_byte);
    
40. 
    
41.       /* Wait for the next byte to arrive. */
    
42.       PT_YIELD(&rxhandler_pt);
    
43. 
    
44.       if(!me_valid(incoming_byte)) {
    
45.         PT_RESTART(&rxhandler_pt);
    
46.       }
    
47. 
    
48.       /* Put together the two bytes into a single Manchester decoded
    
49.          byte. */
    
50. 
    
51.       tr1001_rxbuf[tmppos] = (rxtmp << 4) | me_decode8(incoming_byte);
    
52. 
    
53.       /* Calculate the CRC. */
    
54.       rxcrc = crc16_add(tr1001_rxbuf[tmppos], rxcrc);
    
55. 
    
56.     }
    
57. 
    
58.     /* Since we've got the header, we can grab the length from it. */
    
59.     tr1001_rxlen = ((((struct tr1001_hdr *)tr1001_rxbuf)->len[0] << 8) +
    
60.                     ((struct tr1001_hdr *)tr1001_rxbuf)->len[1]);
    
61. 
    
62.     /* If the length is longer than we can handle, we'll start from
    
63.        the beginning. */
    
64.     if(tmppos + tr1001_rxlen > sizeof(tr1001_rxbuf)) {
    
65.       PT_RESTART(&rxhandler_pt);
    
66.     }
    
67. 
    
68.     /* Read packet data. */
    
69.     for(tmppos = 6; tmppos < tr1001_rxlen + TR1001_HDRLEN; ++tmppos) {
    
70. 
    
71.       PT_YIELD(&rxhandler_pt);
    
72. 
    
73.       if(!me_valid(incoming_byte)) {
    
74.         PT_RESTART(&rxhandler_pt);
    
75.       }
    
76. 
    
77.       rxtmp = me_decode8(incoming_byte);
    
78. 
    
79.       PT_YIELD(&rxhandler_pt);
    
80. 
    
81.       if(!me_valid(incoming_byte)) {
    
82.         PT_RESTART(&rxhandler_pt);
    
83.       }
    
84. 
    
85.       tr1001_rxbuf[tmppos] = (rxtmp << 4) | me_decode8(incoming_byte);
    
86.       rxcrc = crc16_add(tr1001_rxbuf[tmppos], rxcrc);
    
87. 
    
88.     }
    
89. 
    
90.     /* Read the frame CRC. */
    
91.     for(tmppos = 0; tmppos < 4; ++tmppos) {
    
92. 
    
93.       PT_YIELD(&rxhandler_pt);
    
94. 
    
95.       if(!me_valid(incoming_byte)) {
    
96.         PT_RESTART(&rxhandler_pt);
    
97.       }
    
98. 
    
99.       rxcrctmp = (rxcrctmp << 4) | me_decode8(incoming_byte);
    
100.     }
     
101. 
     
102.     if(rxcrctmp == rxcrc) {
     
103.       /* A full packet has been received and the CRC checks out. We'll
     
104.          request the driver to take care of the incoming data. */
     
105. 
     
106.       tr1001_drv_request_poll();
     
107. 
     
108.       /* We'll set the receive state flag to signal that a full frame
     
109.          is present in the buffer, and we'll wait until the buffer has
     
110.          been taken care of. */
     
111.       tr1001_rxstate = RXSTATE_FULL;
     
112.       PT_WAIT_UNTIL(&rxhandler_pt, tr1001_rxstate != RXSTATE_FULL);
     
113.     }
     
114.   }
     
115.   PT_END(&rxhandler_pt);
     
116. }

复制代码

Event-based implementation

1. /* No bytes read, waiting for synch byte. */
   
2. #define RXSTATE_READY   0
   
3. /* Second start byte read, waiting for header. */
   
4. #define RXSTATE_START   1
   
5. /* Reading packet header, first Manchester encoded byte. */
   
6. #define RXSTATE_HEADER1 2
   
7. /* Reading packet header, second Manchester encoded byte. */
   
8. #define RXSTATE_HEADER2 3
   
9. /* Reading packet data, first Manchester encoded byte. */
   
10. #define RXSTATE_DATA1   4
    
11. /* Reading packet data, second Manchester encoded byte. */
    
12. #define RXSTATE_DATA2   5
    
13. /* Receiving CRC16 */
    
14. #define RXSTATE_CRC1    6
    
15. #define RXSTATE_CRC2    7
    
16. #define RXSTATE_CRC3    8
    
17. #define RXSTATE_CRC4    9
    
18. /* A full packet has been received. */
    
19. #define RXSTATE_FULL    10
    
20. 
    
21. void
    
22. tr1001_rxhandler(unsigned char c)
    
23. {
    
24.   switch(tr1001_rxstate) {
    
25.   case RXSTATE_READY:
    
26.     if(c == SYNCH1) {
    
27.       tr1001_rxstate = RXSTATE_START;     
    
28.       rxpos = 0;
    
29.     }
    
30.     break;
    
31.   case RXSTATE_START:
    
32.     if(c == SYNCH1) {
    
33.       tr1001_rxstate = RXSTATE_START;
    
34.     } else if(c == SYNCH2) {
    
35.       tr1001_rxstate = RXSTATE_HEADER1;
    
36.       rxcrc = 0xffff;
    
37.     } else {
    
38.       tr1001_rxstate = RXSTATE_READY;
    
39.     }
    
40.     break;
    
41.   case RXSTATE_HEADER1:
    
42.     if(me_valid(c)) {
    
43.       tr1001_rxbuf[rxpos] = me_decode8(c);      
    
44.       tr1001_rxstate = RXSTATE_HEADER2;
    
45.     } else {
    
46.       tr1001_rxstate = RXSTATE_ERROR;
    
47.     }
    
48.     break;
    
49.   case RXSTATE_HEADER2:
    
50.     if(me_valid(c)) {
    
51.       tr1001_rxbuf[rxpos] = (tr1001_rxbuf[rxpos] << 4) |
    
52.         me_decode8(c);
    
53.       rxcrc = crc16_add(tr1001_rxbuf[rxpos], rxcrc);
    
54.       
    
55.       ++rxpos;
    
56.       if(rxpos >= TR1001_HDRLEN) {
    
57.         tr1001_rxlen = ((((struct tr1001_hdr *)tr1001_rxbuf)->len[0] << 8) +
    
58.                  ((struct tr1001_hdr *)tr1001_rxbuf)->len[1]);
    
59.         if(rxpos + tr1001_rxlen == sizeof(tr1001_rxbuf)) {
    
60.           tr1001_rxstate = RXSTATE_DATA1;
    
61.         }
    
62.       } else {
    
63.         tr1001_rxstate = RXSTATE_HEADER1;
    
64.       }
    
65.     } else {
    
66.       tr1001_rxstate = RXSTATE_READY;
    
67.     }
    
68.     break;
    
69.   case RXSTATE_DATA1:
    
70.     if(me_valid(c)) {
    
71.       tr1001_rxbuf[rxpos] = me_decode8(c);
    
72.       tr1001_rxstate = RXSTATE_DATA2;
    
73.     } else {
    
74.       tr1001_rxstate = RXSTATE_READY;
    
75.     }
    
76.     break;
    
77.   case RXSTATE_DATA2:
    
78.     if(me_valid(c)) {
    
79.       tr1001_rxbuf[rxpos] = (tr1001_rxbuf[rxpos] << 4) |
    
80.         me_decode8(c);
    
81. 
    
82.       rxcrc = crc16_add(tr1001_rxbuf[rxpos], rxcrc);
    
83.       
    
84.       ++rxpos;
    
85.       if(rxpos == tr1001_rxlen + TR1001_HDRLEN) {
    
86.         tr1001_rxstate = RXSTATE_CRC1;
    
87.       } else if(rxpos > sizeof(tr1001_rxbuf)) {
    
88.         tr1001_rxstate = RXSTATE_READY;
    
89.       } else {
    
90.         tr1001_rxstate = RXSTATE_DATA1;
    
91.       }
    
92.     } else {
    
93.       tr1001_rxstate = RXSTATE_READY;
    
94.     }
    
95.     break;
    
96.   case RXSTATE_CRC1:
    
97.     if(me_valid(c)) {
    
98.       rxcrctmp = me_decode8(c);
    
99.       tr1001_rxstate = RXSTATE_CRC2;
    
100.     } else {
     
101.       tr1001_rxstate = RXSTATE_READY;
     
102.     }
     
103.     break;
     
104.   case RXSTATE_CRC2:
     
105.     if(me_valid(c)) {
     
106.       rxcrctmp = (rxcrctmp << 4) | me_decode8(c);
     
107.       tr1001_rxstate = RXSTATE_CRC3;
     
108.     } else {
     
109.       tr1001_rxstate = RXSTATE_READY;
     
110.     }
     
111.     break;
     
112.   case RXSTATE_CRC3:
     
113.     if(me_valid(c)) {
     
114.       rxcrctmp = (rxcrctmp << 4) | me_decode8(c);
     
115.       tr1001_rxstate = RXSTATE_CRC4;
     
116.     } else {
     
117.       tr1001_rxstate = RXSTATE_READY;
     
118.     }
     
119.     break;
     
120.   case RXSTATE_CRC4:
     
121.     if(me_valid(c)) {
     
122.       rxcrctmp = (rxcrctmp << 4) | me_decode8(c);
     
123.       if(rxcrctmp == rxcrc) {
     
124.         tr1001_rxstate = RXSTATE_FULL;
     
125.         tr1001_drv_request_poll();
     
126.       } else {
     
127.         tr1001_rxstate = RXSTATE_READY;
     
128.       }
     
129.     } else {
     
130.       tr1001_rxstate = RXSTATE_READY;
     
131.     }
     
132.     break;
     
133.   case RXSTATE_FULL:
     
134.     /* Just drop the incoming byte. */
     
135.     break;
     
136.   default:
     
137.     /* Just drop the incoming byte. */
     
138.     tr1001_rxstate = RXSTATE_READY;
     
139.     break;
     
140.   }
     
141. }

复制代码

sky-Hawk where

感谢分享，学习！