开发者社区> 毛毛虫的爹> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

RTLinux编程总结

简介: <div class="bct fc05 fc11 nbw-blog ztag"> <p>做过一个有关RTLinux的项目,时间一长,差不多忘光了,现在尽量把原来做过的东西总结一下,以备后用,同时正在做类似项目的一个借鉴<br>平台<br>主机:redhat 8.0<br>目标机:PC104模块、ISA总线脉冲输出、实时串口通信<br>         linux-2.4.18.tar.bz2
+关注继续查看

做过一个有关RTLinux的项目,时间一长,差不多忘光了,现在尽量把原来做过的东西总结一下,以备后用,同时正在做类似项目的一个借鉴
平台
主机:redhat 8.0
目标机:PC104模块、ISA总线脉冲输出、实时串口通信
         linux-2.4.18.tar.bz2 +rtlinux-3.2-pre1.tar.bz2
简述
Linux是典型的分时应用系统,对于实时性要求很高的应用,必须对内核本身动手术。而RTLinux则采取了一种比较聪明也比较折中的办法:他们实现一个最底层的精简的调度器,用于调度实时线程,原来的内核本身则成为实时调度器的一个优先级最低的任务。这样,当有实时任务时,普通内核已经建立于其上的普通进程被强制中断,实时线程被强制执行;只有当若有实时线程都让出cpu之后,普通内核才被运行,再由普通内核去调度执行普通的应用程序……
实例

  1. #include <rtl_fifo.h>
  2. #include <rtl.h>
  3. #include <rtl_sched.h>
  4. #include <time.h>
  5. #include <pthread.h>
  6. #include <rtl_time.h>
  7. #include <signal.h>
  8. #include "rt_com.h"
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. MODULE_LICENSE("GPL v2");
  12. MODULE_AUTHOR("Wind-Son");
  13. MODULE_DESCRIPTION("Pulse-Control system");
  14. typedef unsigned short __u16;
  15. void io_bit_on(__u16 port, unsigned int pos, __u16 *status)
  16. {
  17.         __asm__ __volatile__(
  18.                 "movl %1,%?x\n\t"
  19.                 "movl %0,%?x\n\t"
  20.                 "btsl %2,(%?x)\n\t"
  21.                 "mov (%?x),%%al\n\t"
  22.         "out %%al,(%%dx)\n\t"
  23.         "out %%al,$0x80\n\t"
  24.                 :
  25.                 :"m"(status), "rm"(port), "Ir"(pos)
  26.         );
  27. }
  28. void io_bit_off(__u16 port, unsigned int pos, __u16 *status)
  29. {
  30.         __asm__ __volatile__(      
  31.                 "movl %1,%?x\n\t"
  32.                 "movl %0,%?x\n\t"
  33.                 "btrl %2,(%?x)\n\t"
  34.                 "mov (%?x),%%al\n\t"
  35.         "out %%al,(%%dx)\n\t"
  36.         "out %%al,$0x80\n\t"
  37.                 :
  38.                 :"m"(status), "rm"(port), "Ir"(pos)
  39.         );
  40. }
  41. #define dbg_print rtl_printf
  42. #define MIN_TIME              5000
  43. static void get_time_interval(void)
  44. {
  45. }
  46. void* pulse_generate_thread(void *arg)
  47. {
  48.         static __u16 io_status = 0;
  49.         struct sched_param p;
  50.         hrtime_t current_time;
  51.         REAL_TIME_GET_ENABLE;
  52.         int intrrupt_sched_period = 180000;
  53.         p.sched_priority = 1;
  54.         struct timespec resolution;
  55.        
  56.         rtl_setclockmode(CLOCK_REALTIME, RTL_CLOCK_MODE_PERIODIC,
  57.                         intrrupt_sched_period);
  58.         clock_getres(rtl_getschedclock(), &resolution);
  59.         intrrupt_sched_period = timespec_to_ns(&resolution);
  60.        
  61.         pthread_make_periodic_np(pthread_self(), clock_gethrtime(rtl_getschedclock()),
  62.                 intrrupt_sched_period);
  63.         pthread_setschedparam (pthread_self(), SCHED_FIFO, &p);
  64.         for (;;) {
  65.                 dbg_print("debug entry\n");
  66.                 while (!ready)
  67.                     pthread_wait_np();
  68.                 dbg_print("debug exit\n");
  69.                 if (!init_rt_clock) {
  70.                        
  71.                         init_rt_clock = 1;
  72.                         pthread_wait_np();
  73.                         current_time = clock_gethrtime(CLOCK_REALTIME);
  74.                 } else {
  75.                     if (intrrupt_sched_period < MIN_TIME)
  76.                                 intrrupt_sched_period = MIN_TIME;
  77.                     current_time += intrrupt_sched_period;
  78.                        
  79.                     clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, hrt2ts(current_time), NULL);
  80.                 }
  81.                
  82.                 io_bit_on(IO_PORT_OUT, XPULSE, &io_status);
  83.                
  84.             intrrupt_sched_period = get_time_interval();
  85.         }
  86.         return 0;
  87. }
  88. static void init_for_rt_mm(void)
  89. {
  90. }
  91. static void rt_alloc_mm(void)
  92. {
  93.         thread_wait_np();
  94.         buf = kmalloc(size, GFP_ATOMIC);
  95. }
  96. static int kmalloc_thread(void * kthread_arg)
  97. {
  98.         unsigned long timeout = HZ;
  99.         init_for_rt_mm();
  100.         for (;;) {
  101.                 while (!get_flag(MM_ALLOC_FLAG)) {
  102.                        
  103.                         if( signal_pending(current))
  104.                                 return 0;
  105.                         timeout = interruptible_sleep_on_timeout(&wq, timeout);
  106.                 }
  107.                 rt_alloc_mm();
  108.                 clear_flag(MM_ALLOC_FLAG);
  109.         }
  110.         return -1;
  111. }
  112. wait_queue_head_t wq;
  113. static pid_t kmalloc_kthread_id;
  114. static int kmalloc_kthread_state = 1;
  115. static int pulse_generate_thread_created = 0;
  116. static int main_ctrl_thread_created = 0;
  117. static pthread_t pulse_generate_pthread;      
  118. static pthread_t main_ctrl_pthread;
  119. static pthread_mutex_t cache_mutex;
  120. void rt_mm_request(void)
  121. {
  122.         set_flag(MM_ALLOC_FLAG);
  123.        
  124.         while(get_flag(MM_ALLOC_FLAG))      
  125.                 pthread_wait_np();
  126. }
  127. void* main_ctrl_thread(void *arg)
  128. {
  129.         int work_sched_period = 160000;
  130.         struct timespec resolution;
  131.         int ret1 = rtl_setclockmode(rtl_getschedclock(), RTL_CLOCK_MODE_PERIODIC,
  132.                 work_sched_period);              
  133.         if (ret1) {
  134.                 dbg_print("seting periodic mode failed\n");
  135.                 clear_flag(WORK_SCHED_MODE);
  136.         }
  137.         clock_getres(rtl_getschedclock(), &resolution);
  138.         work_sched_period = timespec_to_ns(&resolution);
  139.         pthread_make_periodic_np(pthread_self(), clock_gethrtime(rtl_getschedclock()),
  140.             work_sched_period);
  141.         init_task();      
  142.         for (;;) {
  143.                 if (work) {
  144.                         dbg_print("work\n");
  145.                         rt_mm_request();
  146.                         calc_time_interval();
  147.                         if (exit)
  148.                             break;
  149.                 } else
  150.                         pthread_wait_np();
  151.         }
  152.         exit_task();
  153.     return 0;
  154. }
  155. int init_module(void)
  156. {
  157.         pthread_attr_t attr;
  158.         struct sched_param p;
  159.         int ret;
  160.         rtf_destroy(0);
  161.         rtf_destroy(1);
  162.         rt_com_clr_in(0);
  163.         rt_com_clr_out(0);
  164.        
  165.         int fifo_status = rtf_create(0,100);
  166.         if(fifo_status)
  167.                 dbg_print("FIFO Create failed!");
  168.         fifo_status = rtf_create(1, 4000);
  169.         if(fifo_status)
  170.                 dbg_print("FIFO Create failed!");
  171.        
  172.         rt_com_setup(0, 9600, RT_COM_PARITY_NONE, 1, 8);
  173.         hrtime_t now = gethrtime();
  174.         pthread_attr_init(&attr);
  175.         pthread_mutex_init(&cache_mutex, NULL);
  176.         pthread_attr_setfp_np(&attr, 1);
  177.        
  178.         ret = pthread_create(&pulse_generate_pthread, &attr,
  179.                 pulse_generate_thread, (void *)0);
  180.         if (!ret)
  181.                 pulse_generate_thread_created = 1;
  182.         pthread_make_periodic_np (pulse_generate_pthread, now + 2 * 240000, 80000);
  183.         p . sched_priority = 1;
  184.         pthread_setschedparam (pulse_generate_pthread, SCHED_FIFO, &p);
  185.        
  186.         ret = pthread_create(&main_ctrl_pthread, &attr, main_ctrl_thread, (void *)1);
  187.         if (!ret)
  188.                 main_ctrl_thread_created=1;
  189.         pthread_make_periodic_np (main_ctrl_pthread, now + 2 * 160000, 30000);
  190.         p . sched_priority = 2;
  191.         pthread_setschedparam (main_ctrl_pthread, SCHED_FIFO, &p);
  192.         init_waitqueue_head(&wq);
  193.         kmalloc_kthread_id = kernel_thread(kmalloc_thread, NULL, 0);
  194.         if (kmalloc_kthread_id < 0) {
  195.                 printk(KERN_ERR "fork failed, errno %d\n", -kmalloc_kthread_id);
  196.                 return kmalloc_kthread_id;
  197.         }
  198.         return ret;
  199. }
  200. void cleanup_module(void)
  201. {
  202.        
  203.         int ret = kill_proc(kmalloc_kthread_id, SIGKILL, 1);
  204.         if (!ret) {
  205.                 int count = 10 * HZ;
  206.                
  207.                 while (kmalloc_kthread_state && --count) {
  208.                         current->state = TASK_INTERRUPTIBLE;
  209.                         schedule_timeout(1);
  210.                 }
  211.         }
  212.         if (main_ctrl_thread_created) {
  213.                 pthread_cancel(main_ctrl_pthread);
  214.                 pthread_join(main_ctrl_pthread, NULL);
  215.                 pthread_delete_np(main_ctrl_pthread);
  216.         }
  217.         if (pulse_generate_thread_created) {
  218.                 pthread_cancel(pulse_generate_pthread);
  219.                 pthread_join(pulse_generate_pthread, NULL);
  220.                 pthread_delete_np(pulse_generate_pthread);
  221.         }
  222.         rt_com_setup(0, -1, 0, 0, 0);
  223.         rtf_destroy(0);
  224.         rtf_destroy(1);
  225.         pthread_mutex_destroy (&cache_mutex);
  226. }

复制代码

其实现在有关Linux实时应用的原理和应用方面的介绍已经不少,所以我主要是想从自己的亲身实践中的经验教训出发总结一下。
我遇到的主要问题主要有以下几个:
1、硬实时调度精度不够的问题。刚开始产生脉冲驱动的线程我按照例子程序采样如下方式
   pthread_make_periodic_np();  //设置调度方式和周期等参数
    pthread_setschedparam (pthread_self(), SCHED_FIFO, &p);
    pthread_wait_np(); //让出cpu进入睡眠
  可实际情况总是不理想,输出波形不够稳定,离预想的效果也很远。试着将调度策略SCHED_FIFO改其他几种方式,也一样。最后尝试用clock_nanosleep()才达到了比较理想的效果。理论上clock_nanosleep()应该达到ns级别的精度,当然实际精度还要取决于硬件。
2、实时线程所能到达的实时效果和精度极限也就是定时器本身的精度了。有过在51上做开发经验的都有这样一个意识:定时器中断处理例程里尽量只做最简单、最必须的工作,但毕竟还是有开销的。如果你对精度还有更高的要求,可在main_ctrl_thread()即负责计算脉冲间隔时间的例程中加入补偿值,以抵消脉冲输出例程中的时间开销。
3、实时线程中频繁的动态申请内存时常宕机。后来经过实验摸索才采取了上面代码中所述的拐弯抹角的办法。如果谁碰到过类似问题有更好的办法,还望指出。
4、应用程序直接向串口输出时总出错。
   开始方法是system("/bin/ls ./data/ >> /dev/ttyS0";在没有实时线程的影响的情况下,这样是没有问题。开启实时线程后就老出错。
后改成如下方式就好了:由实时模块通过实时调用rt_com_write()和rt_com_read()读写串口;再通过实时管道rtl_fifo转发到应用程序
另外,纯粹经验谈,实时线程如果不主动让出cpu,任何用户程序无法运行,包括你的键盘响应!如果你的某个环节可能陷入循环,你能做的就只有poweroff了;被迫重启后在ext2文件系统上随之而来的是漫长的fscheck……所以我在调试阶段,基本上是只要有循环的的方,就加上pthread_wait_np();以后再慢慢把不必要的去掉。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
修改Linux服务器时间的命令
修改Linux服务器时间的命令
0 0
如何从虚拟机上的linux使用sz命令传输windows大于4G的文件
如何从虚拟机上的linux使用sz命令传输windows大于4G的文件
0 0
linux基本功系列之uptime命令实战
linux基本功系列之uptime命令实战
0 0
linux基本功系列之sudo命令实战一
linux基本功系列之sudo命令实战一
0 0
linux基本功系列之-rpm命令实战
linux基本功系列之-rpm命令实战
0 0
linux基本功系列之su命令
linux基本功系列之su命令
0 0
linux基本功系列之wc命令实战
linux基本功系列之wc命令实战
0 0
linux基本功系列之-lsattr命令实战
linux基本功系列之-lsattr命令实战
0 0
linux基本功系列之chattr命令
linux基本功系列之chattr命令
0 0
linux基本功系列之find命令实战
linux基本功系列之find命令实战
0 0
+关注
毛毛虫的爹
好好学习,天天向上
文章
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载