rtthread之工作队列
中断处理分为上半部和下半部
一般来说中断处理的上半部和下半部都是不允许出现睡眠和阻塞的。但是对于下半部，并不是一刀切，下半部的实现方式有软中断和tasklet（不允许睡眠和阻塞）以及工作队列（允许睡眠和阻塞）。
上半部：一般中断的中断处理函数为上半部，要求做耗时少的动作，尽量迅速，一定不能休眠和阻塞。
下半部：由于上半部只能执行耗时少的操作，所以耗时长的操作就放在下半部，两个的界限并不是很明显，取决于我们要将哪个操作放在上半部还是下半部。
下面讨论一下工作队列的原理及实现
实现原理：工作队列（workqueue）是一种将工作推后执行的形式，工作队列可以把工作推后，交由一个内核线程去执行，也就是说，这个下半部分可以在进程上下文中执行。最重要的就是工作队列允许被重新调度甚至是睡眠。工作队列的本质是创建一个一个普通的内核线程，我们称为工作者线程。
以下是几个工作队列抽象出来的数据结构
1：struct rt_workqueue表示一个工作队列对象（包含一个工作者线程）。
2：struct rt_work为工作队列上的任务。当我们将一个任务加入一个工作队列时候，会将该任务挂接到struct rt_workqueue的任务链表上，当工作线程未就绪的时候，这个工作者线程就会唤醒，去遍历这个链表上的所有任务，执行完后，将该任务从链表上拿走，工作者线程继续休眠。
3：双向链表操作原理请查看文章（数据结构-------双向链表），内存申请释放请查看文章（rtthread之小内存算法）。
数据结构定义
//内存申请，实现及原理请参考rtthread之小内存算法
#ifndef RT_KERNEL_MALLOC
#define RT_KERNEL_MALLOC(sz) rt_malloc(sz)
#endif
//内存释放
#ifndef RT_KERNEL_FREE
#define RT_KERNEL_FREE(ptr) rt_free(ptr)
#endif
//工作队列对象，包含工作者线程
struct rt_workqueue
{
rt_list_t work_list;
rt_thread_t work_thread;
};
//任务对象，包含工作任务及数据
struct rt_work
{
rt_list_t list;
void (*work_func)(struct rt_work* work, void* work_data);
void *work_data;
};原理实现
1.工作者线程
//工作者线程，处理挂接到该工作队列上的任务或者工作
static void _workqueue_thread_entry(void* parameter)
{
struct rt_work* work;
struct rt_workqueue* queue;
uint32_t level = 0;
uint8_t workqueue_empty = 0;
queue = (struct rt_workqueue*) parameter;
RT_ASSERT(queue != RT_NULL);
while (1)
{
level = rt_hw_interrupt_disable();
//判断工作队列上是否有任务，没有则挂起工作者线程
workqueue_empty = rt_list_isempty(&(queue->work_list));
rt_hw_interrupt_enable(level);
if (workqueue_empty)
{
//没有任务，则挂起工作者线程
rt_thread_suspend(rt_thread_self());
rt_schedule();
}
level = rt_hw_interrupt_disable();
//有任务，则获取对应任务的信息
work = rt_list_entry(queue->work_list.next, struct rt_work, list);
//从工作队列任务表中删除当前任务
rt_list_remove(&(work->list));
rt_hw_interrupt_enable(level);
//执行任务
work->work_func(work, work->work_data);
}
}
2.工作队列初始化及创建工作者线程
//创建及初始化工作队列对象，创建工作者线程，返回工作队列对象
struct rt_workqueue *rt_workqueue_create(const char* name, rt_uint16_t stack_size, rt_uint8_t priority)
{
struct rt_workqueue *queue = RT_NULL;
//申请一个工作队列对象句柄
queue = (struct rt_workqueue*)RT_KERNEL_MALLOC(sizeof(struct rt_workqueue));
if (queue != RT_NULL)
{
//初始化工作队列任务链表，指向自己
rt_list_init(&(queue->work_list));
//创建工作者处理线程
queue->work_thread = rt_thread_create(name, _workqueue_thread_entry, queue, stack_size, priority, 10);
if (queue->work_thread == RT_NULL)
{
RT_KERNEL_FREE(queue);
return RT_NULL;
}
//开启工作者线程
rt_thread_startup(queue->work_thread);
}
return queue;
}3.向工作队列添加任务
//将任务加入到工作队列中
rt_err_t rt_workqueue_dowork(struct rt_workqueue* queue, struct rt_work* work)
{
uint32_t level = 0;
RT_ASSERT(queue != RT_NULL);
RT_ASSERT(work != RT_NULL);
level = rt_hw_interrupt_disable();
//将任务加入到工作队列任务链表中
rt_list_remove(&(work->list));
rt_list_insert_after(queue->work_list.prev, &(work->list));
//如果当前工作者线程处于挂起态，则唤醒该工作者线程
if (queue->work_thread->stat != RT_THREAD_READY)
{
rt_hw_interrupt_enable(level);
rt_thread_resume(queue->work_thread);
rt_schedule();
}
else
rt_hw_interrupt_enable(level);
return RT_EOK;
}
4.删除工作队列
//删除工作队列
rt_err_t rt_workqueue_destroy(struct rt_workqueue* queue)
{
RT_ASSERT(queue != RT_NULL);
//删除工作者线程
rt_thread_delete(queue->work_thread);
//释放工作队列对象空间
RT_KERNEL_FREE(queue);
return RT_EOK;
}5.将任务从工作队列中删除
//将任务从工作队列中删除
rt_err_t rt_workqueue_cancel_work(struct rt_workqueue* queue, struct rt_work* work)
{
uint32_t level = 0;
RT_ASSERT(queue != RT_NULL);
RT_ASSERT(work != RT_NULL);
level = rt_hw_interrupt_disable();
//从工作队列中移除任务
rt_list_remove(&(work->list));
rt_hw_interrupt_enable(level);
return RT_EOK;
}
应用：
在使用spi flash模拟u盘开发过程中，由于spi flash读写速度操作比较慢耗时，且在flash操作中封装了互斥操作，对于操作系统不能在中断中使用互斥量等操作，需要使用中断下半部的思想，将读取操作添加到工作队列中，从而实现模拟u盘的操作。
修改步骤：
1.创建工作队列
struct rt_workqueue *usb_irq_workqueue = NULL;
void USB_CDC_VCP_Thread(void* parameter)
{
.......
if(usb_irq_workqueue == NULL)
{
usb_irq_workqueue = rt_workqueue_create("usb_workqueue", 4096, 1);
rt_kprintf("[USB] usb irq workqueque creat %s\r\n",(usb_irq_workqueue != NULL)?"ok":"failed");
}
.......
}
2.修改usb中断操作,将任务添加到工作队列
struct usb_work_data
{
USB_OTG_CORE_HANDLE *pdev;
uint8_t epnum;
};
//修改Usb输入端点处理任务函数
void usb_msc_data_in(struct rt_work* work, void* work_data)
{
struct usb_work_data *usb_data = NULL;
usb_data = (struct usb_work_data *)work_data;
USBD_DCD_INT_fops->DataInStage(usb_data->pdev , usb_data->epnum);
}
//修改Usb输出端点处理任务函数
void usb_msc_data_out(struct rt_work* work, void* work_data)
{
struct usb_work_data *usb_data = NULL;
usb_data = (struct usb_work_data *)work_data;
USBD_DCD_INT_fops->DataOutStage(usb_data->pdev , usb_data->epnum);
}
extern struct rt_workqueue *usb_irq_workqueue;
static struct usb_work_data usb_data;
static struct rt_work usb_msc_work;
static uint32_t DCD_HandleInEP_ISR(USB_OTG_CORE_HANDLE *pdev)
{
......
if(doepint.b.xfercompl)
{
......
if(usb_irq_workqueue != NULL)
{
//将任务参数及任务函数加入到工作队列中
usb_data.pdev = pdev;
usb_data.epnum = epnum;
usb_msc_work.work_data = (void*)&usb_data;
usb_msc_work.work_func = usb_msc_data_in;
rt_workqueue_dowork(usb_irq_workqueue,&usb_msc_work);
}
......
}
......
}
static uint32_t DCD_HandleOutEP_ISR(USB_OTG_CORE_HANDLE *pdev)
{
......
if(doepint.b.xfercompl)
{
......
if(usb_irq_workqueue != NULL)
{
//将任务参数及任务函数加入到工作队列中
usb_data.pdev = pdev;
usb_data.epnum = epnum;
usb_msc_work.work_data = (void*)&usb_data;
usb_msc_work.work_func = usb_msc_data_out;
rt_workqueue_dowork(usb_irq_workqueue,&usb_msc_work);
}
......
}
......
}