嵌入式環形緩沖區的設計與實現

2016-09-28 00:00:00 廣州睿豐德信息科技有限公司閱讀

睿豐德科技專注RFID識別技術和條碼識別技術與管理軟件的集成項目。質量追溯系統、MES系統、金蝶與條碼系統對接、用友與條碼系統對接

環形緩沖區是嵌入式系統中十分重要的一種數據結構，比如在一個視頻處理的機制中，環形緩沖區就可以理解為數據碼流的通道，每一個通道都對應著一個環形緩沖區，這樣數據在讀取和寫入的時候都可以在這個緩沖區里循環進行，程序員可以根據自己需要的數據大小來決定自己使用的緩沖區大小。
環形緩沖區，顧名思義這個緩沖區是環形的，那么何謂環形這個意思也很好理解，就是用一個指針去訪問該緩沖區的最后一個內存位置的的后一位置時回到環形緩沖區的起點。類似一個環一樣。這樣形容就很好理解了，當然有辦法實現了。我在這里采用了2種方式實現了環形緩沖區，一個是用數組的方法，一個是用鏈表的方法。
數組是一塊連續的內存，所以順序訪問時只要根據下標的增加而增加，但是最后一個元素之后需要回到起始位置，這就需要我們對這個地方進行特殊處理。只要最后一個地址訪問結束能順利回到起始地址，這個緩沖區就可以實現。代碼如下：
[cpp] view plaincopyprint?
01./* File name: ringbuf.c
02. * Author : wanxiao
03. * Function :Implement a circular buffer,
04. you can read and write data in the buffer zone.
05. */
06.
07.#include <stdio.h>
08.
09.#define MAXSIZE 8
10.
11.int ringbuf[MAXSIZE];
12.int readldx=0;
13.int writeldx=0;
14.
15.int next_data_handle(int addr)
16.{
17. return (addr+1) == MAXSIZE ? 0:(addr+1) ;
18.}
19.
20.int write_data(int data)
21.{
22. int i;
23. *(ringbuf+writeldx) = data;
24. writeldx = next_data_handle(writeldx);
25. for(i=0;i<MAXSIZE;i++)
26. {
27. printf("%4d",*(ringbuf+i));
28. if(MAXSIZE-1 == i)
29. printf("/n");
30. }
31.}
32.
33.int read_data()
34.{
35. printf("read data is : %d/n",*(ringbuf+readldx));
36. readldx = next_data_handle(readldx);
37.}
38.
39.int main(int argc , char **argv)
40.{
41. int data;
42. char cmd;
43.
44. do{
45. printf("select:/nw/t--write/nr/t--read/nq/t--quit/n");
46. scanf("%s",&cmd);
47.
48. switch(cmd)
49. {
50. case 'w' :
51. printf("please input data:");
52. scanf("%d",&data);
53. write_data(data);
54. break;
55. case 'r' :
56. data = read_data();
57. break;
58. case 'q' :
59. printf("quit/n");
60. break;
61. default :
62. printf("Command error/n");
63. }
64. }while(cmd != 'q');
65. return 0;
66.}
/* File name: ringbuf.c
* Author : wanxiao
* Function :Implement a circular buffer,
you can read and write data in the buffer zone.
*/
#include <stdio.h>
#define MAXSIZE 8
int ringbuf[MAXSIZE];
int readldx=0;
int writeldx=0;
int next_data_handle(int addr)
{
return (addr+1) == MAXSIZE ? 0:(addr+1) ;
}
int write_data(int data)
{
int i;
*(ringbuf+writeldx) = data;
writeldx = next_data_handle(writeldx);
for(i=0;i<MAXSIZE;i++)
{
printf("%4d",*(ringbuf+i));
if(MAXSIZE-1 == i)
printf("/n");
}
}
int read_data()
{
printf("read data is : %d/n",*(ringbuf+readldx));
readldx = next_data_handle(readldx);
}
int main(int argc , char **argv)
{
int data;
char cmd;
do{
printf("select:/nw/t--write/nr/t--read/nq/t--quit/n");
scanf("%s",&cmd);
switch(cmd)
{
case 'w' :
printf("please input data:");
scanf("%d",&data);
write_data(data);
break;
case 'r' :
data = read_data();
break;
case 'q' :
printf("quit/n");
break;
default :
printf("Command error/n");
}
}while(cmd != 'q');
return 0;
}
鏈表實現，實際上就是一個單向循環鏈表。這個方法的優點是不需要最后一個元素進行特殊處理，但是實現起來比數組稍微麻煩一點，單思路還是很清晰簡單的。代碼如下：
[cpp] view plaincopyprint?
01.#include <stdio.h>
02.#include <stdlib.h>
03.
04.
05.typedef struct signal_loop_chain
06.{
07. int data;
08. struct signal_loop_chain *next;
09.}NODE;
10.
11.NODE *Create_loop_chain(int n)
12.{
13. int i;
14. NODE *head , *previous , *current ;
15. previous = (NODE *)malloc(sizeof(NODE));
16. if(previous == NULL)
17. exit(1);
18.
19. previous->data =0;
20. previous->next = NULL;
21. head = previous ;
22.
23. for(i=0 ; i<n ; i++)
24. {
25. current = (NODE*)malloc(sizeof(NODE));
26. if(current == NULL)
27. exit(1);
28.
29.// scanf("%d",¤t->data);
30. current->next = head;
31. previous->next = current;
32. previous = current ;
33. }
34. return head ;
35.}
36.
37.int Show(NODE *head)
38.{
39. NODE *current;
40. current = head->next ;
41. printf("List:/n");
42. while(current != head)
43. {
44. printf("%4d",current->data);
45. current = current->next;
46. }
47. printf("/n");
48.}
49.
50.int read_buf(NODE *head)
51.{
52. NODE *current;
53. current = head->next;
54. while(1)
55. {
56. printf("read number is %d/n",current->data);
57. current = current->next;
58. sleep(1);
59. }
60.
61.}
62.
63.int write_buf(NODE *head)
64.{
65. NODE *current;
66. int i = 0;
67. current = head->next;
68. while(1)
69. {
70. current->data = i++;
71. printf("write number is %d/n",current->data);
72. current = current->next;
73. sleep(1);
74. }
75.}
76.
77.int main(int argc , char **argv)
78.{
79. int num;
80. char cmd;
81. NODE *head;
82. printf("please input node_num /n");
83. scanf("%d",&num);
84. head = Create_loop_chain(num);
85. printf("The ringbuf was found/n");
86. Show(head);
87.
88. while(1){
89. printf("please select r or w/n");
90. scanf("%c",&cmd);
91.
92. if(cmd == 'r'){
93. read_buf(head);
94. Show(head);
95. }
96.
97. if(cmd == 'w'){
98. write_buf(head);
99. Show(head);
100. }
101.
102. }
103. return 0;
104.}
#include <stdio.h>
#include <stdlib.h>
typedef struct signal_loop_chain
{
int data;
struct signal_loop_chain *next;
}NODE;
NODE *Create_loop_chain(int n)
{
int i;
NODE *head , *previous , *current ;
previous = (NODE *)malloc(sizeof(NODE));
if(previous == NULL)
exit(1);
previous->data =0;
previous->next = NULL;
head = previous ;
for(i=0 ; i<n ; i++)
{
current = (NODE*)malloc(sizeof(NODE));
if(current == NULL)
exit(1);
// scanf("%d",¤t->data);
current->next = head;
previous->next = current;
previous = current ;
}
return head ;
}
int Show(NODE *head)
{
NODE *current;
current = head->next ;
printf("List:/n");
while(current != head)
{
printf("%4d",current->data);
current = current->next;
}
printf("/n");
}
int read_buf(NODE *head)
{
NODE *current;
current = head->next;
while(1)
{
printf("read number is %d/n",current->data);
current = current->next;
sleep(1);
}
}
int write_buf(NODE *head)
{
NODE *current;
int i = 0;
current = head->next;
while(1)
{
current->data = i++;
printf("write number is %d/n",current->data);
current = current->next;
sleep(1);
}
}
int main(int argc , char **argv)
{
int num;
char cmd;
NODE *head;
printf("please input node_num /n");
scanf("%d",&num);
head = Create_loop_chain(num);
printf("The ringbuf was found/n");
Show(head);
while(1){
printf("please select r or w/n");
scanf("%c",&cmd);
if(cmd == 'r'){
read_buf(head);
Show(head);
}
if(cmd == 'w'){
write_buf(head);
Show(head);
}
}
return 0;
}
以上都是針對單進程而言。對于系統，尤其是嵌入式Linux系統中，緩沖區的保護機制就變得尤為重要了，因為我們的數據時不停的在讀寫，內存不停的變化，如果牽扯到多任務（多進程，多線程），我們就需要加鎖對其進行保護措施。這里我在鏈表的實現下加了信號量加以保護。
[c-sharp] view plaincopyprint?
01.#include <stdio.h>
02.#include <stdlib.h>
03.#include <pthread.h>
04.#include <semaphore.h>
05.
06.sem_t mutex;
07.
08.typedef struct signal_loop_chain
09.{
10. int data;
11. struct signal_loop_chain *next;
12.}NODE;
13.
14.NODE *Create_loop_chain(int n)
15.{
16. int i;
17. NODE *head , *previous , *current ;
18. previous = (NODE *)malloc(sizeof(NODE));
19. if(previous == NULL)
20. exit(1);
21.
22. previous->data =0;
23. previous->next = NULL;
24. head = previous ;
25.
26. for(i=0 ; i<n ; i++)
27. {
28. current = (NODE*)malloc(sizeof(NODE));
29. if(current == NULL)
30. exit(1);
31.
32. current->next = head;
33. previous->next = current;
34. previous = current ;
35. }
36. return head ;
37.}
38.
39.int Show(NODE *head)
40.{
41. NODE *current;
42. current = head->next ;
43. printf("List:/n");
44. while(current != head)
45. {
46. printf("%4d",current->data);
47. current = current->next;
48. }
49. printf("/n");
50.}
51.
52.int read_buf(NODE *head)
53.{
54. NODE *current;
55. current = head->next;
56. while(1)
57. {
58. sem_wait(&mutex);
59. printf("read number is %d/n",current->data);
60. current = current->next;
61. sem_post(&mutex);
62. sleep(2);
63. }
64.
65.}
66.
67.int write_buf(NODE *head)
68.{
69. NODE *current;
70. int i = 0;
71. current = head->next;
72. while(1)
73. {
74. sem_wait(&mutex);
75. current->data = i++;
76. printf("write number is %d/n",current->data);
77. current = current->next;
78. sem_post(&mutex);
79. sleep(1);
80. }
81.}
82.
83.int main(int argc , char **argv)
84.{
85. int num,ret;
86. char cmd;
87. NODE *head;
88. pthread_t id1,id2;
89.
90. ret = sem_init(&mutex ,0,1);
91. if(ret != 0){
92. perror("sem_init error");
93. }
94. printf("please input node_num /n");
95. scanf("%d",&num);
96. head = Create_loop_chain(num);
97. printf("The ringbuf was found/n");
98. Show(head);
99.
100. ret = pthread_create(&id1,NULL,(void *)write_buf,head);
101. ret = pthread_create(&id2,NULL,(void *)read_buf,head);
102.
103. pthread_join(id1,NULL);
104. pthread_join(id2,NULL);
105.
106.
107. return 0;
108.}

RFID管理系統集成商 RFID中間件條碼系統中間層物聯網軟件集成

上一條嵌入式 hi3518平臺uboot引導nfs文件系統
下一條 hisi平臺mii網絡模式和rmii網絡模式的uboot制作

嵌入式 環形緩沖區的設計與實現

嵌入式環形緩沖區的設計與實現