精华内容
下载资源
问答
  • Liunx进程之间通信的方式有多种,这里列举一种常用的massage queue的方法实现公交车乘客区和司机区的音量控制,并向上层公开接口
  • 嵌入式系统设计与应用:第7讲 嵌入式Linux进程控制开发.ppt
  • 本文详细描述了一种利用 ptrace 系统调用,实现嵌入式系统内部进程通信的监视方法,并提供了相应的实现方案。
  • 关于嵌入式Linux系统进程调度 摘 要: 本文结合源代码着重分析了Linux进程调度的依据、策略和调度程序schedule()。 关键词: 嵌入式Linux;进程调度;实时进程;调度策略。 1 前言 处理机(CPU)是整个计算机系统的...
  • 嵌入式操作系统进程状态详解,不了解嵌入式进程的可以好好看看,很有用
  •  ●进程控制块是操作系统为记录和描述进程基本信息及状态,由操作系统创建并分配给进程的一个数据结构。  在操作系统中,一个程序可对应一个进程,也可对应多个进程。如果一个程序同时对应了多个进程,那么就称这...
  • 1 嵌入式Linux系统分析1.1 嵌入式系统嵌入式系统(Embedded Systems)是以应用为中心,以计算机技术为基础,软件硬件可剪裁(可编程、可重构),适用于应用系统对功能、可靠性、成本、体积、功耗有严格要求的专用...
  • 行业分类-嵌入式设备-基于新型存储器的嵌入式系统及其进程的休眠与唤醒方法.zip
  • 这是利用EVC软件进行嵌入式(WIN CE)开发的一个实验,实现的是进程的创建
  • 进行进程切换就是从正在运行的进程中收回处理器,然后再使待运行进程来占用处理器。  这里所说的从某个进程收回处理器,实质上就是把进程存放在处理器的寄存器中的中间数据找个地方存起来,从而把处理器的寄存器腾...
  • 嵌入式进程

    2020-05-11 15:21:14
    ➢内存以及其他分配给进程系统资源 进程的属性 进程号(PID) 父进程号(PPID) 进程名 用户 cpu% 内存% 优先级 开启时间等 进程最重要的属性是进程号(PID) ,以及父进程号(PPID) 。一个进程有唯一的进程号,如果一...

    什么是进程?

    进程是一个正在执行的程序的实例。

    进程由哪些元素组成?

    ➢程序的当前上下文,程序当前的执行状态
    ➢程序的当前执行目录
    ➢程序访问的文件和目录
    ➢程序的访问权限
    ➢内存以及其他分配给进程的系统资源

    进程的属性

    • 进程号(PID)
    • 父进程号(PPID)
    • 进程名
    • 用户
    • cpu%
    • 内存%
    • 优先级
    • 开启时间等

    进程最重要的属性是进程号(PID) ,以及父进程号(PPID) 。一个进程有唯一的进程号,如果一个进程创建 了一个子进程, 那么它的进程号就是子进程的父进程号。
    1号进程(init) :即PID=1,负责引导系统、启动守护进程以及运行其他必要的程序。

    扩展:
    扩展来源

    • 系统允许一个进程创建新进程,即子进程,子进程还可以创建新的子进程,形成进程树结构模型。整个linux系统的所有进程其实就是一个树形结构。树根是系统自动创建的,即内核态下执行的0号进程,它是所有进程的祖先。由0号进程创建1号进程(内核态),1号负责执行内核的部分初始化工作及进行系统配置,并创建若干个用于高速缓存和虚拟主存管理的内核线程。随后,1号进程调用 execve() 运行可执行程序init,并演变成用户态1号进程, 即init进程。它按照配置文件/etc/initab的要求,完成系统启动工作,创建编号为1号、2号……的若干终端注册进程getty。
    • 每个getty进程设置其进程组标识号,并监视配置到系统终端的接口线路。当检测到来自终端的连接信号时,getty进程将通过函数 execve() 执行 注册程序login,此时用户就可输入注册名和密码进入登录过程,如果成功,由login程序再通过函数 execv() 执行shell,该shell进程 接收getty进程的pid,取代原来的getty进程。再由shell直接或间接地产生其他进程。
      这里1号进程有一个从内核到用户状态的改变

    fork()系统调用的功能和执行过程

    fork系统调用可以产生一个新进程。

    #include<unistd.h>
    pid_ _t fork( void );
    

    如果fork执行成功,就向父进程返回子进程的PID,并向子进程返回0。这意味着即使只调用一次fork, 也会返回两次。
    fork创建的子进程是父进程的副本,二者的UID、GID、 环境、资源、打开的文件、共享的内存段等完全相同。但是PID和PPID不同。

    #include <unistd.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    int main(void)
    {
       pid_ t child;       //进程标识
       if((child = fork())==-1){        //用fork()生成子进程,失败则直接退出
          perror("fork");
          exit(EXIT_FAILURE);
       }else if(child == 0) {       //在子进程中实现
           puts("in child");
           printf("\tchild pid = %d\n", getpid());     //输出子进程的PID
           printf("\tchild ppid = %d\n", getppd());    //输出父进程的PID
           exit(EXIT_SUCCESS);
        } else {                     //在父进程中实现
             puts("in parent");
             printf("\tparent pid = %d\n", getpid());    //输出父进程号
             printf("\tparent ppid = %d\n", getppid());  //输出父进程的父进程号
         }
         exit(EXIT_ SUCCESS);
    }
    

    在这里插入图片描述
    程序执行结果表明, 不能预计父进程是在子进程之前还是之后运行,程序的执行是无序的(异步的),因此,不应该在子进程中执行依赖于父进程的代码,反之亦然,因为二者异步执行。
    父进程由bash启动。 父进程先执行结束,则子进程将系统守护进程systemd作为自己的父进程。

    传统Unix模型中创建和修改进程的操作

    • fork:用来创建一个新的进程,此进程几乎是当前进程的一个完全拷贝
    • exec:可以在进程中用另外的程序来替换掉当前进程运行的程序

    等待进程结束函数

    wait函数族最重要的两个函数是 waitwaitpid 函数

    wait函数:

    用wait来等待一个子进程终止运行称为回收进程。
    当父进程忘了用wait()函数等待已终止的子进程时,子进程就会进入一种无父进程的状态,此时子进程就是僵尸进程。wait()要与fork()配套出现,如果在使用fork()之前调用wait(),wait()的返回-1,正常情况下wait()的返回值为子进程的PID,如果先终止父进程,子进程将继续正常进行,只是它将由init进程(PID=1)继承,当子进程终止时,init进程捕获这个状态。

    pid_t wait(int *status)
    

    如果参数的值不是NULL,wait就会把子进程退出时的状态取出以整型存入,说明子进程是正常退出还是被非正常结束的。

    waitpid函数:

    • waitpid()会暂时停止目前进程的执行,直到有信号来到或子进程结束,并收集子进程的资源。如果在调用waitpid时子进程已经结束,则waitpid会立即返回子进程结束状态值。子进程的结束状态值由参数status返回,而子进程的进程号也会一并返回。 如果执行成功则返回子进程号(PID),如果有错误发生则返回-1。失败原因存于errno中。
    pid_ t waitpid(pid_ _t pid, int* status, int options);
    
    • pid:欲等待的子进程号
    • status:保存子进程的结束状态
    • option:可以为0或下面的OR(两个常数)组合(可以用“|”将它们连接起来):
      ➢WNOHANG 如果没有任何已经结束的子进程则马上返回,不会像wait那样永久等待。
      ➢WUNTRACED 如果子进程进入暂停执行情况则马上返回,但结束状态不予以理会。
      例如:

    ret=waitpid(-1,NULL,WNOHANG | WUNTRACED);
    ret=waitpid(-1,NULL,0);

    展开全文
  • 嵌入式Linux进程调度的研究.pdf
  • 在操作系统中,进程是享用系统资源的对象,是资源分配的基本单位。  为了提高处理器的利用率,可以像下图所描述的那样使程序并发执行。乍看起来,系统似乎是以参与并发执行的程序为对象来分配处理器这个资源的,...
  • 守护进程是Linux系统开发中很重要的知识点,很多朋友对这个问题掌握的不是很深入,今天我就写写这方面的问题,可以帮助大家熟悉守护进程的编写过程。
  • 随着物联网、智能电网、智能移动设备的发展,我们将能在任何时候任何地方获取我们所需的信息,本文设计一款基于ARM-Linux嵌入式系统的多进程并发服务器。它拥有传统服务器的功能,可远程访问和操作,同时又具有体积...
  • Linux在嵌入式系统中有关进程调度算法的实时性改进.PDF
  • 基于linux嵌入式系统的多进程开发实验
  • 分析了普通Linux 内核实时性不足的主要原因。 介绍了目前较为有效的改进Linux 实时性的方法。具体地研究了普通Linux 内核在嵌入式系统中的有关进程调度算法的实时性不足的具体因素,并提出了具体的解决办法。
  • 描述了具有典型意义的多CPU嵌入式系统的体系结构,详细介绍了一种应用于此种嵌入式系统的分布式操作系统进程问消息通信的方法,又将此方法和常用的分布式操作系统的进程问消息通信方法进行了比较。
  • 嵌入式操作系统;xlanchen@2007.6.12;xlanchen@2007.6.12;进程;xlanchen@2007.6.12;xlanchen@2007.6.12;xlanchen@2007.6.12;xlanchen@2007.6.12;xlanchen@2007.6.12;xlanchen@2007.6.12;xlanchen@2007.6.12;xlanchen@...
  •  在此需要说明的是:最初,调度的对象是进程,由于现在操作系统都引入了线程这个概念,从而使进程蜕变为资源分配和管理的对象,而线程就成了调度的对象。尽管对象发生了变化,但在调度的策略和方法方面并没有发生...
  • 简介: 本文详细描述了一种利用 ptrace 系统调用,实现嵌入式系统内部进程通信的监视方法,并提供了相应的实现方案。     概述 复杂的嵌入式系统中,常常同时运行着...

    简介: 本文详细描述了一种利用 ptrace 系统调用,实现嵌入式系统内部进程通信的监视方法,并提供了相应的实现方案。

     
     




    概述

    复杂的嵌入式系统中,常常同时运行着相当多的进程。这些进程之间频繁的进行着大量的通信动作。进程的运行状态与这些不断发生的通信有着直接和紧密的联系。通过对进程间通信的监视,开发人员可以掌控系统内部运转的状态。发现错误时,利用获取到的进程间通信的信息,调试工程师更容易发现问题之所在。

    但是,嵌入式系统与开发人员的接口往往较为单一。开发人员广泛使用通常是基于串口或是网络接口的终端( console )方式。在这个模式下,开发人员难以细致准确的观察进程间的通信。而且对于计算能力薄弱的嵌入式系统来说,在终端上打印出通信报文既会影响系统内部的运行,同时,也会使屏幕上充斥的过多的无用信息,使开发人员的分析工作无从下手。

    为了解决这个问题,在嵌入式 Linux 的平台上,我们开发了一整套用于监视嵌入式系统内进程间通信的软件,用于调试我们开发的嵌入式产品。本文详细介绍了监视嵌入式系统内进程间通信的技术原理和实现监视软件的推荐方案。

    监视方法的基本原理

    Linux 中的 ptrace 系统调用是监视进程间通信的关键。 ptrace 为我们提供了一种观察和控制其它进程的方法。利用 ptrace ,我们可以截获正在运行的进程的所有的系统调用。所谓截获是指,监视程序可以在这些系统调用发生和退出时,获得系统调用的参数,甚至修改参数。这些系统调用包括: read , write , sendtorecv 等等。在 Linux 中,用户可以通过“ man syscalls ”来查看当前版本的Linux 所支持的系统调用。

    在我们的 Linux 嵌入式产品中, AF_UNIX 域的 socket 被广泛使用。它被用来完成进程间通信的工作。 AF_UNIX 域的 socket 的编程模型与通常的 socket 编程模型完全相同。我们的使用方法是:接收进程创建一个 AF_UNIX 域的 socket ,设定其模式为数据报(SOCK_DGRAM )。在这之后,为其绑定一个含路径的文件名,例如: /var/tmp/receive.unix 。这个文件名被内核用于标识socket。发送进程创建一个相同模式的 AF_UNIX 域的 socket 。然后,调用 sendto 向接收进程发送消息。用来标识接收进程 socket 的就是前面提到的文件名,也就是 /var/tmp/receive.unix 。而接收进程使用 recvfrom 系统调用,就可以收到发送进程发出的消息。

    因此,通过 ptrace ,一旦我们接管了被监视进程的 sendto 和 recvfrom 系统调用,将使我们能够截获到使用这两个系统调用进行通信的数据。

    ptrace 系统调用的定义如下:

           #include <sys/ptrace.h> 
           long int ptrace(enum __ptrace_request request, pid_t pid, \
                           void * addr, void * data);
    

    它共有四个参数。 request 的值决定 ptrace 执行什么样的任务。 pid 指明被追踪的进程的 id 。 request 参数决定了是否需要一个有效的 addr 参数,还是仅用 NULL 即可。如果有必要使用有效的 addr 参数,它的含义是被追踪的进程的进程空间的偏移量。 data 类似于 addr 参数,有时也可以使用 NULL 来代替。如果它被使用,它的含义是指向一些数据,这些数据希望被放置到被监视的进程的用户空间中。

    一个完整的示例代码将向我们展示监视进程间通信的技术细节和关键点。代码按前后顺序分段说明。

                   #include <stdio.h>
                   #include <stdlib.h>
                   #include <sys/ptrace.h>
                   #include <sys/wait.h>
                   #include <linux/user.h>
                   #include <sys/socket.h>
                   #include <sys/un.h>
                   #include <linux/net.h>
    

    为了在程序中使用 ptrace 系统调用,我们需要增加 ptrace.h 头文件。为了能够获得截获的系统调用的函数入参,我们需要使用struct user_regs_struct 结构。它在 user.h 中被定义。由于在程序中使用了信号,因此,我们也需要 wait.h 。我们要监视通信动作, socket.h 和 un.h 则是必不可少的。

    下面是程序的入口主函数:

            int main (int argc, char *argv[])
            {
                int status;
                int syscall_entry = 0;
                int traced_process;
                struct user_regs_struct u_in;
    

    status 用于记录被监视进程的状态变化; syscall_entry 记录被监视进程当前是进入系统调用,还是从系统调用中返回; u_in 用来获得截获的系统调用的参数; traced_process 则是被监视进程的 PID 值。

                 traced_process = atoi(argv[1]); /* 从命令行得到监视进程的PID */
                 ptrace(PTRACE_ATTACH, traced_process, NULL, NULL);
                 wait(&status);    /* 等待被监视进程状态变化 */
                 ptrace(PTRACE_SYSCALL, traced_process, NULL, NULL);
    

    参数为 PTRACE_ATTACH 的 ptrace 对被监视进程在内核中的进程结构进行修改。使被监视进程成为当前程序的子进程。一旦被监视进程的状态发生变化, wait() 将返回。程序再次调用 ptrace 。这次的参数为 PTRACE_SYSCALL 。被监视进程的进程结构再次被修改,其 trace 标志被激活。内核将在被监视进程的每一次系统调用时,触发当前程序的运行。

                 While (1) {
                     /* 等待被监视程序调用系统调用或是发生其它状态变化 */
                     wait(&status); 
                     
                     /* 如果被监视进程退出,函数返回真。程序退出 */
                     if ( WIFEXITED(status) ) 
                         break;
                     
                     ptrace(PTRACE_GETREGS, traced_process, 0, &u_in);
                     if (u_in.orig_eax == 102 && u_in.ebx == SYS_SENDTO) { 
                         if (syscall_entry == 0) {  /* syscall entry */
                             insyscall = 1;
                             printf("call sendto()\n");
                         }
                         else {  /* Syscall exit */
                             Syscall_entry = 0;
                         }
                     }
                     ptrace(PTRACE_SYSCALL, traced_process, NULL, NULL);
                  } /* while */
    
                               return 0;
                          }  /* main */
    

    被监视进程的 trace 标志被激活后,它的每一次系统调用都会被内核检查。我们程序也随之被内核用信号通知。使用参数PTRACE_GETREGS 的 ptrace() 将获得截获的系统调用的参数。最重要的参数是系统调用号。它保存在了 u_in.orig_eax 中。通过系统调用号,我们可以确定发生的是那一个系统调用。系统调用号可以在 Linux 的源代码中查找。它的定义在 linux-source-2.6.xx/arch/x86/kernel/syscall_table_32.S 中。它的部分代码如下所示:

                .long sys_fstatfs       /* 100 */
                .long sys_ioperm
                .long sys_socketcall
                .long sys_syslog
    

    在这里,我们最关心的是 sendto 系统调用。在 Linux 的内核中, sendto 的真实入口是 socketcall 系统调用。它是 bind , sendto 等socket相关系统调用的入口。在这个系统调用中,通过一个 call number 来区分出 bind , sendto 等不同的子系统调用。在我们的程序中,这个 call number 保存在 u_in.ebx 中。 从上面的 syscall_table_32.S 示例代码就可以看出, socketcall 的系统调用号是102(从100向下数两行)。而 call number 则在 net.h 有定义,我们关心的 sendto 的 call number 被定义为 SYS_SENDTO ,其绝对值为11。有了这两个重要的数据,我们的程序据此判断当前发生的系统调用是否为 sendto 。这一点表现为代码:

                 if (u_in.orig_eax == 102 && u_in.ebx == SYS_SENDTO) 
    

    被监视进程进入系统调用和退出系统调用时,都会触发 wait() 返回,使我们的程序有机会运行。因此,我们需要使用 syscall_entry 来记录当前时刻是被监视进程进入系统调用,还是退出系统调用。这是一个开关量,非常容易理解。 最后,每次处理完,都需要再次调用参数为 PTRACE_SYSCALL 的 ptrace ,准备监视下一次的系统调用。

    上面的程序虽然很简单,但已经可以完整的表现出利用 ptrace 截获被监视进程的 sendto 系统调用的过程。值得补充一点的是,利用ptrace 也可以获得 sendto 向外发送的数据。

    sendto 系统调用的定义是:

            #include <sys/types.h>
            #include <sys/socket.h>
            size_t sendto(int s, const void *msg, size_t len, int flags, \
                          const struct sockaddr *to, socket len_t tolen);
    

    sendto 包含了六个参数,特别是 msg 参数指出了发送的数据内容。参数 to 指出了发送的目标。利用 PTRACE_PEEKDATA 参数的 ptrace,监视程序将可以获得 sendto 的全部的六个参数。这样监视程序就完全获得了被监视进程要向外发送的数据和发送目标。具体的实现细节在此不再展开论述。请参考 man ptrace 说明手册。

    监视系统的体系和应用

    利用上面讨论的技术,我们开发了可以运行在 mips 目标板上的监视程序,名为 ipcmsg 。它是一个命令行程序。在我们的应用环境中,它的使用方法是:

           root@host:~$ ipcmsg -p pid -l xxx.xxx.xxx.xxx -b 6000
    

    pid 是被监视进程的 pid ,可以通过 ps 命令获得。 -l 参数后面指定 PC 主机的 IP 地址。 -b 参数指明了接收的端口号。

    最初进行监视时, ipcmsg 是没有 IP 地址和端口号参数的。所有信息是输出到串口控制台中。这既影响了运行的效率(大量的在串口上的输出会影响目标板的运行速度),也不利于信息的处理。由于我们的目标板具备以太网接口,我们很容易的想到将 ipcmsg 截获的数据包转发到 PC 主机上。使用 PC 主机更便于对进程间通信的数据包进行分析。在 PC 主机上,我们使用 wireshark 这个非常流行的开源的网络报文分析软件接收来自目标板的信息。整个监视系统的架构如下图所示:


    图1 架构
    架构 

    在实际的使用过程中,我们使用以太网线将目标板与 PC 主机相连。然后,在目标板上启动 ipcmsg ,并为其指定监视进程的 pid ipcmsg运行后,我们在PC主机上启动 wireshark 接收来自 ipcmsg 的数据包。这些数据包中包含了 mips 目标板上进程间通信的信息。利用我们为 ipcmsg 专门开发的 wireshark 插件,在 wireshark 上,我们可以详细的分解 ipcmsg 转发来的数据包,非常直观的分析进程间通信的过程和可能存在的问题。下面是 wireshark 分解 ipcmsg 数据包的实际运行图:


    图2 运行图
    运行图 

    从图中可以看到,我们从 ipcmsg 获得了进程间通信的方式,参数( path 是 AF_UNIX域 socket 地址参数),方向和内容,以及进程名称。这些信息帮助我们对嵌入式系统的运行状态进行分析。而这一切非常直观和便于操作。

    展开全文
  • 这里说的嵌入式系统,是嵌入式linux系统,嵌入式linux系统其实和电脑端的linux系统一样,作为一个系统,就不可能就跑一个程序或者任务,大多都会有好几个进程,这样的话就会用到进程间的通信功能;常用的进程间通信...

    这里说的嵌入式系统,是嵌入式linux系统,嵌入式linux系统其实和电脑端的linux系统一样,作为一个系统,就不可能就跑一个程序或者任务,大多都会有好几个进程,这样的话就会用到进程间的通信功能;常用的进程间通信主要有以下几种方式:

    1. 消息队列;

    2. socket(本地socket和INET socket)

    3.管道(有名管道和无名管道)

    4.信号

    5.共享内存


    以上5中方式,其中信号、共享内存其实不是严格意义上的进程间通信,信号一般用于通知,并没有携带数据;共享内存,一般是用于共享大块数据(比如视频数据等),这个也不是单独使用的,一般需要结合其他的方式,进行标志同步(数据准备好了,告你来取吧~);那么剩下的三种方式,我们来分析一下其优劣。

    消息队列:消息队列属于比较轻量级的通讯,消息属于一对一交互,数据量一般不会太大,消息接收可以设置阻塞或者非阻塞;使用消息队列通讯时,不能用select做IO复用;如果系统下的多个程序的框架有一对多的情况,那么就不适合用消息队列了。

    管道:管道分为有名管道和无名管道,无名管道一般是用于父子进程间通讯用,不能在两个独立启动的可执行程序中使用;有名字管道,从其名字上就可以看出,创建时,会指定一个名字,然后创建后,会在指定的路径下生成一个管道文件,两个程序可以使用其进行通讯,管道是可以使用select监听,实现IO复用的。但是管道只能一对一的通信,不适用于多个进程间的通信;

    socket:socket放在最后,是想让socket作为压轴的,socket的具体使用,又可以分为下面四种方式:

    1>本地 socket 数据包式通信(基于本地socket文件的UDP的方式)

    2>本地 socket 数据流式通信 (基于本地socket文件的TCP的方式)

    3>INET socket 数据包式通信 (基于IP、PORT的UDP)

    4>INET socket 数据流式通信 (基于IP、PORT的UDP)

    其中,本地socket,也是会在系统下指定的路径建一个socket的文件,基于此进行通信,其实本地socket就是基于数据队列的通信(通过查看源代码可以找到这部分),本地socket和互联网的socket通信使用是一样的,可以是面向连接的数据流通信,也可以是面向无连接的数据包方式;

    后面的INET的socket通信就是大家熟悉的网络通信,如果使用这两种方式,那么你的程序不仅可以实现进程间的数据交互,还可以跨设备通信!

    通信方式以及特点的分析完了,今天要谈的主要是网络编程的应用,也就是socket,其他的进程间通信方式就不多说了,主要说是socket,怎么用?什么时候用哪一个方式?主要聊聊这些。

    既然用了嵌入式linux系统,那么我建议尽量不要把什么功能都放在一起,一个程序里完成,这个不利于程序的维护和扩展,尽量按照功能或者业务去分开实现,比如说设备里用到了数据采集、4G模块、平台交互等等,这就可以把数据采集单独放在一个程序里去处理,4G模块的上网、断网重连维护、通话、短信等放在一个程序里,平台交互一般是和服务器通信,涉及到协议的打包与解包,也单独一个程序处理;这样互相独立,很方便扩展,也便于查找问题。下面接着说socket,既然系统间分了几个程序,那么他们之间是需要通信的,通信方式有以下三个方式:

    1.点对点,每个,模块间都相互建立通讯,很显然,这种方式不利于功能扩展,通信太多;

     

    2.类似于C/S模型,这种扩展是没问题,但是不同“客户端”之间通信就比较麻烦了,每次都需要“服务端”去转发数据。

    3.星形架构,这种还是比较合理的,既满足了扩展性,也满足了不同模块间的数据通信;

     接下来,就基于这第三种架构来讲讲socket在这里的应用这里面的消息中心,是作为一个服务端, 外围模块作为客户端,注册到消息中心上面,然后这个链接方式,可以是socket的四种方式都可以,一般是用流式域套接字,内部通信,使用流式面向连接,便于模块管理,这里特别想说的是数据包式的UPD方式通信,结合其特点:面向无连接,可以用于做调试接口。这个调试接口的意思是在消息中心里,启动一个UDP的端口服务器监听,然后我们可以在做一个调试命令,一个udp客户端的小程序,在这个小程序里面,我们可以把调试相关的命令、数据获取、日志级别修改操作加进去,这样这个调试命令就可以不建连接,直接给框架里的任意一个模块发送数据,或者获取数据。还可以发送模拟数据,比如采集模块未启动,用调试命令模拟一条采集模块的数据,发送给平台交互模块,也可以透传数据给任意一个注册到消息中心的模块。

    另外就是,可以在消息中心里加上INET的UDP或者TCP端口监听,这样可以在电脑上用网络调试助手连接到设备系统内部,这样很方便调试,发送调试数据。

    大家可以看下 openwrt里的ubus,这里介绍的星形架构的方式,和ubus很像,这种方式很不错的。

    已经是深夜了,就到这里吧,文笔不好望大家谅解,以后慢慢学习提高~

     

    微信订阅号:

     

    展开全文
  • 基于ARM-Linux嵌入式系统的多进程并发服务器设计.pdf
  • 行业分类-嵌入式设备-一种多应用进程嵌入式系统终端资源管理系统及方法.zip
  • 系统以并发方式运行的各个进程,不可避免地要共同使用一些共享资源以及相互之间的通信。因此,对于一个完善的多进程操作系统来说,系统必须具有完各的同步和通信机制。  为了实现各进程之间的合作和无冲突的运行,...
  • 行业分类-嵌入式设备-一种基于进程调度的嵌入式系统优化方法.zip
  • 嵌入式系统原理与设计 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 笔记本不是嵌入式产品 嵌入式系统是以应用为中心以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,904
精华内容 30,761
关键字:

嵌入式系统进程