字符设备驱动之循环缓冲队列+读写等待

 buffer.c

#include <linux/fs.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/ioport.h>
#include <linux/pci.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <linux/interrupt.h>
#include <asm/mach/irq.h>
#include <asm/arch/regs-gpio.h>


static int major = 0;
static struct class *cls;

#define BUF_LEN   10
static char kern_buf[BUF_LEN];
static volatile int r = 0, w = 0;

static wait_queue_head_t read_waitq;
static wait_queue_head_t write_waitq;


static int isEmpty(void)
{
 return (r == w);
}

static int isFull(void)
{
 return (r == ((w+1)%BUF_LEN));
}

static int putData(char val)
{
 if (isFull())
 {
  return -1;
 }
 else
 {
  kern_buf[w] = val;
  w = (w+1)%BUF_LEN;
  return 0;
 }
}


static int getData(char *p)
{
 if (isEmpty())
 {
  return -1;
 }
 else
 {
  *p = kern_buf[r];
  r = (r+1)%BUF_LEN;
  return 0;
 }
}


ssize_t buffer_read(struct file *file, char __user *buf, size_t size, loff_t *offset)
{
 int i = 0;
 char val;
 
 do {

  wait_event_interruptible(read_waitq, !isEmpty());

  while ((i < size) && getData(&val) == 0)
  {
   copy_to_user(buf+i, &val, 1);
   wake_up_interruptible(&write_waitq);
   i++;
  }  
  
 } while (i < size);
 
 return size;
}

ssize_t buffer_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
{
 int i = 0;
 char val;
 
 do {

  wait_event_interruptible(write_waitq, !isFull());

  while ((i < size) && !isFull())
  {
   copy_from_user(&val, buf+i, 1);
   putData(val);
   i++;
   wake_up_interruptible(&read_waitq);
  }  
  
 } while (i < size);
 
 return size;
}

static struct file_operations buffer_fops = {
 .owner   =  THIS_MODULE,
 .read    =  buffer_read,
 .write   =  buffer_write,
};

int buffer_init(void)
{
 major = register_chrdev(0, "buffer", &buffer_fops);

 /* sysfs  ==> 挂接到/sys */
 cls = class_create(THIS_MODULE, "buffer_class");
 class_device_create(cls, NULL, MKDEV(major, 0), NULL, "buffer");

 // mdev会根据/sys下的这些内容创建/dev/buffer
 init_waitqueue_head(&read_waitq);
 init_waitqueue_head(&write_waitq);
 
 return 0;
}
void buffer_exit(void)
{
 unregister_chrdev(major, "buffer");

 class_device_destroy(cls, MKDEV(major, 0));
 class_destroy(cls);
}

module_init(buffer_init);
module_exit(buffer_exit);

MODULE_LICENSE("GPL"); 

reader.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char **argv)
{
 int fd;
 char buf[10];
 int i;

 fd = open("/dev/buffer", O_RDONLY);

 read(fd, buf, 10);

 printf("data: ");
 for (i = 0; i < 10; i++)
  printf("%c ", buf[i]);
 printf("\n"); 
 
 return 0;
}

writer.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

/* writer string */
int main(int argc, char **argv)
{
 int fd;
 char buf[10];
 int i;

 if (argc != 2)
 {
  printf("Usage: \n");
  printf("%s string\n", argv[0]);
  return 0;
 }

 fd = open("/dev/buffer", O_WRONLY);

 write(fd, argv[1], strlen(argv[1])); 
 
 return 0;
}

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 我可以给你一个简单的示例程序: #include <stdio.h> #include <string.h> #include <stdlib.h>#define BUFFER_SIZE 8typedef struct { unsigned char buffer[BUFFER_SIZE]; int head; int tail; int count; } RingBuffer;// 初始化环形队列 void init_ring_buffer(RingBuffer *rb) { memset(rb->buffer, 0, BUFFER_SIZE); rb->head = 0; rb->tail = 0; rb->count = 0; }// 向环形队列放入数据 int put_data(RingBuffer *rb, unsigned char data) { if (rb->count == BUFFER_SIZE) { return -1; } rb->buffer[rb->tail] = data; rb->tail = (rb->tail + 1) % BUFFER_SIZE; rb->count++; return 0; }// 从环形队列取出数据 int get_data(RingBuffer *rb, unsigned char *data) { if (rb->count == 0) { return -1; } *data = rb->buffer[rb->head]; rb->head = (rb->head + 1) % BUFFER_SIZE; rb->count--; return 0; }int main(void) { // 使用环形队列缓冲串口接收的数据 RingBuffer rb; init_ring_buffer(&rb); // 串口接收到的数据 unsigned char data; // 将接收到的数据放入环形队列 put_data(&rb, data); // 从环形队列中取出数据 get_data(&rb, &data); return 0; } ### 回答2: 串口接收是通过串口接口接收来自外部设备发送的数据。而环形队列缓冲是一种数据结构,用于在接收数据时存储和处理数据。 在C语言中,可以使用串口的库函数来实现串口通信,并结合环形队列缓冲实现数据的接收。下面是一个使用C语言实现串口接收并使用环形队列缓冲的示例代码: ```c #include <stdio.h> #define MAX_BUFFER_SIZE 100 typedef struct { char data[MAX_BUFFER_SIZE]; int front, rear, count; } CircularBuffer; void initBuffer(CircularBuffer *buffer) { buffer->front = buffer->rear = buffer->count = 0; } void enqueue(CircularBuffer *buffer, char ch) { if (buffer->count < MAX_BUFFER_SIZE) { buffer->data[buffer->rear] = ch; buffer->rear = (buffer->rear + 1) % MAX_BUFFER_SIZE; buffer->count++; } else { printf("Buffer is full!\n"); } } char dequeue(CircularBuffer *buffer) { char ch; if (buffer->count > 0) { ch = buffer->data[buffer->front]; buffer->front = (buffer->front + 1) % MAX_BUFFER_SIZE; buffer->count--; return ch; } else { printf("Buffer is empty!\n"); return 0; } } void receiveData(CircularBuffer *buffer, char *data, int size) { for (int i = 0; i < size; i++) { enqueue(buffer, data[i]); } } int main() { CircularBuffer buffer; initBuffer(&buffer); char receivedData[] = "Hello, World!"; receiveData(&buffer, receivedData, sizeof(receivedData) - 1); // sizeof(receivedData) - 1是为了去除字符串末尾的'\0'字符 // 从缓冲区中逐个取出字符并打印 while (buffer.count > 0) { char ch = dequeue(&buffer); printf("%c", ch); } printf("\n"); return 0; } ``` 以上代码使用了一个`CircularBuffer`结构体来表示环形队列缓冲区,其中`data`是用于存储接收到的字符的数组,`front`和`rear`分别表示环形队列的前端和后端,`count`表示缓冲区中元素的数量。通过`enqueue`函数将接收到的字符放入缓冲区,通过`dequeue`函数将缓冲区中的字符取出。`receiveData`函数在串口接收到数据时调用,将数据存储到缓冲区中。在`main`函数中,首先初始化缓冲区,然后模拟接收到数据并存入缓冲区,最后逐个取出字符并打印出来。 这样就完成了一个用C语言实现串口接收并使用环形队列缓冲的示例代码。通过环形队列缓冲,可以高效地存储和处理串口接收到的数据。 ### 回答3: 使用C语言编写串口接收程序,可以使用环形队列缓冲来存储接收到的数据。 首先,需要定义一个环形队列的结构体,包含队列的大小、当前队列的长度、队头和队尾等信息。在实际编码中,可以用数组来表示环形队列,通过定义一个读指针和写指针指向队列的头尾,对队列进行读写操作。 接着,在程序中打开串口,并设置串口参数,如波特率、数据位、停止位和校验位等。可以使用C语言提供的串口库函数来简化这一步骤,如`open()`、`ioctl()`和`read()`函数等。 然后,需要定义一个缓冲区用来存储从串口接收到的数据。缓冲区可以是一个全局变量,定义为一个字符数组,并初始化为空。同时定义一个变量记录缓冲区中数据的长度。 接下来,在串口接收中断处理函数中,读取从串口接收到的数据,并将数据存入环形队列缓冲中。此时,需要判断队列是否已满,若满了,则丢弃最早的数据,即将队头指针后移一个位置,然后将新数据写入队尾,并更新队尾指针。 在主函数中,可以使用一个循环不断读取并处理缓冲区中的数据。可以通过循环读取队列中的数据,并对每个数据进行相应的处理操作,如输出到终端或者进行数据解析等。 最后,当不再需要接收串口数据时,需要关闭串口,并释放相应资源。 综上所述,通过使用环形队列缓冲,可以实现串口接收程序,有效地管理接收数据。这样可以提高数据处理的效率和程序的稳定性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值