如何移植uCOS-III到Linux系统 How to Port uCOS-III on Linux OS

最新推荐文章于 2024-08-13 17:10:17 发布
最新推荐文章于 2024-08-13 17:10:17 发布
阅读量5.9k 收藏 5
点赞数 1
分类专栏： uCOS-III 文章标签： linux signal os hook function thread

如何移植uCOS-III到Linux操作系统？？？

ex1.png

关于uCOS-II移植到Linux系统的核心代码
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


       基本移植已被映射到Linux信号，并在OS_CPU_C.C中实施;注意在这个移植方案中没有汇编语言文件。一些功能被内联在OS_CPU.H中。换句话说，就是这里只有一个Linux进程（也只有一个线程），以及所有任务的创建和调度都是由microC/OS - II来做的。


       在当前任务堆栈进行信号传递。OSTCBStkPtr是指向ucontext_t堆栈结构，供接下去使用。


++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

       •OS_TASK_SW( )：使用Linux系统调用的上下文切换杀（）系统调用，它发送信号SIGUSR1给自己。


       •OSCtxSw( )：切换任务是做一个中断发生后，一个新的任务变得准备运行，任务自愿放弃CPU的。这个函数被调用的信号SIGUSR1和SIGALRM的处理程序。切换是由setcontext（）。


       •OSTickISR( )  是一个标准的执行代码，如在书中所述。它被函数OSTimeTickSigHandler（）周期性地调用。


       •OSInitHookBegin（）：这个钩子是用来初始化Linux的信号和句柄。它调用LinuxInit（）。


       •LinuxInitInt( )  已被要求用户在最高优先级的用户应用任务中调用。它启动时钟节拍。


       •OSTaskIdleHook( )  是空的，休眠一段时间或直到下一次信号被发生（调用一个select（）系统调用）。


       •OSTaskStkInit( )  初始化一个ucontext_t结构的任务堆栈和调整TCBs域。SysV系统调用getcontext（）和makecontext( )有助于处理此过程。


       •OSStartHighRdy( )  使用setcontext（）恢复先前上下文。由于该功能只能使用一次，应该在未来的调用中被OSCtxSw取代。


       •OS_CPU_SR：此类型映射到一个sigset_t。它是用来阻塞和恢复信号。由于Linux移植采用了Critical Method ＃3，它贯穿整个系统。


       •OS_CRITICAL_METHOD：= 3; Linux移植必须记住信号掩码的先前状态。


       •OS_ENTER_CRITICAL( )  是一个宏，通过Linuxsigprocmask（）系统调用，阻塞SIGALRM和SIGUSR1信号。


       •OS_EXIT_CRITICAL( )  恢复信号掩码的先前状态。


       •OS_TASK_DEF_STK_SIZE：在Linux上的合理大小是2000words。这主要是由于处理堆栈上的信号。


++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


/* 
 *                                                uC/OS-II 
 *                                          The Real-Time Kernel 
 * 
 *                                               Linux Port 
 * 
 * File        : $Source: /proj/cvs-gfa/Micrium/Software/uCOS-II/Ports/linux-hal/os_cpu.h,v $ 
 * By          : (c) George Fankhauser, Sensaco Consulting GmbH,  
 *               Switzerland, http://www.sensaco.com   
 * Version     : $Revision: 1.1.1.1 $ 
 * 
 * Changed by  : $Author: gfa $ 
 *               $Date: 2003/11/20 10:19:14 $ 
 * 
 * $Log: os_cpu.h,v $
 * Revision 1.1.1.1  2003/11/20 10:19:14  gfa
 * check in ucos II for linux
 * 
 */ 
 
/*
 * \file  
 *  
 * Definition moved here so it can be used in the assembler file OS_CPU_A.ASM. 
 * See below for the meaning of this define  
 * 
 * \author George Fankhauser 
 */ 
 
#include <unistd.h> 
#include <signal.h> 
#include <string.h>  /// memcpy, memset used in os_task.c ! 
 
#ifndef OS_CPU_A /* skip the rest if we're including from the assembler file */ 
 
#ifdef  OS_CPU_GLOBALS 
#define OS_CPU_EXT 
#else 
#define OS_CPU_EXT  extern 
#endif 
 
/*
 * DATA TYPES (Compiler and architecture specific)         
 */ 
typedef unsigned char   BOOLEAN; 
typedef unsigned char   INT8U;      /* Unsigned  8 bit quantity          */ 
typedef signed   char   INT8S;      /* Signed    8 bit quantity          */ 
typedef unsigned short int   INT16U;     /* Unsigned 16 bit quantity          */ 
typedef signed   short int   INT16S;     /* Signed   16 bit quantity          */ 
typedef unsigned int   INT32U;     /* Unsigned 32 bit quantity          */ 
typedef signed   int   INT32S;     /* Signed   32 bit quantity          */ 
typedef float           FP32;       /* Single precision floating point   */ 
typedef INT32U   OS_STK;     /* Each stack entry is 32 bit wide   */ 
typedef sigset_t OS_CPU_SR;  /// the 'status register' corresponds to signals 
 


/*
 * used in os_cpu_c
 */
void OSTaskSwHook (void);


/*
 * linuxInit does the setup of the signal handler.
 */ 
void linuxInit(void);  
 
/** linuxInitInt starts periodic interrupts. */ 
void linuxInitInt(void); 
 
/*
 * Macro to block interrupts (on Linux: signals) 
 * 
 * Critical method 1 which does not restore the signal state may lead to hanging 
 * timer interrupts, especially when debugging (i.e. real time is much faster than debug 
 * time). 
 */ 
#define OS_CRITICAL_METHOD 3 
 
/*
 * We add all the virtual interrupt signals to the mask and save the old process 
 * signal mask to the backup 'status register'. 
 */ 
#define OS_ENTER_CRITICAL() { sigset_t set; \ 
sigemptyset(&set); \ 
sigaddset(&set, SIGALRM); \ 
sigaddset(&set, SIGIO); \ 
sigprocmask(SIG_SETMASK, &set, &cpu_sr); \ 
} 
/*
 * Macro to unblock interrupts 
 * 
 * Here we just restore the state that was returned by previous call to sigprocmask 
 */ 
#define OS_EXIT_CRITICAL() { sigprocmask(SIG_SETMASK, &cpu_sr, NULL); \ 
}  
/*  
 * Stack grows from HIGH to LOW memory on linux x86 
 */ 
#define  OS_STK_GROWTH      1 
 
/*
 * This macro posts a Linux signal to ourselves; it is returned in the handler with the 
 * threads context. The SIGUSR1 handler saves the context and then calls OSCtxSw(). 
 * 
 * (use OSCtxSw() directly when no sw int available) 
 */ 
#define OS_TASK_SW() { kill(getpid(), SIGUSR1); }  
 
#endif //OS_CPU_A 

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/*  
 *                                                uC/OS-II  
 *                                          The Real-Time Kernel  
 *  
 *                                               Linux Port  
 *  
 * File        : $Source: /proj/cvs-gfa/Micrium/Software/uCOS-II/Ports/linux-hal/os_cpu_c.c,v $  
 * By          : (c) George Fankhauser, Sensaco Consulting GmbH,   
 *               Switzerland, http://www.sensaco.com    
 * Version     : $Revision: 1.1.1.1 $  
 *  
 * Changed by  : $Author: gfa $  
 *               $Date: 2003/11/20 10:19:14 $  
 *  
 * $Log: os_cpu_c.c,v $ 
 * Revision 1.1.1.1  2003/11/20 10:19:14  gfa 
 * check in ucos II for linux 
 *  
 */   
   
/*
 * \file   
 * User context switching code derived from Topsy 2.0 port to Linux and Solaris  
 * (see http://www.tik.ee.ethz.ch/~topsy).  
 *  
 * \author George Fankhauser  
 */    
   
#define  OS_CPU_GLOBALS    
#include "includes.h"    
   
#include <asm/sigcontext.h> // for context switching    
#define __USE_GNU    
#include <ucontext.h>    
#undef __USE_GNU    
#include <ucontext.h>   // for context switching    
#include <string.h>    
#include <unistd.h>   // used for syscalls:    
                      // ualarm in Threads/unix/TMClock.c    
              // kill   in Topsy/unix/SyscallMsg.c    
              // getpid in Topsy/unix/SyscallMsg.c    
#include <signal.h>   // used in Threads/unix/TMHal.c and     
                      // Topsy/unix/SyscallMsg.c    
#include <setjmp.h>   // for contextswitches in Threads/unix/TMHal.c    
#include <sys/select.h>    
   
#include <stdio.h>    // if we want to use printf...    
   
   
/*
 *                                          TASK CREATION HOOK  
 *  
 * This function is called when a task is created.  
 * Arguments  : ptcb   is a pointer to the task control block of the task being created.  
 * Note(s)    : 1) Interrupts are disabled during this call.  
 */   
#if OS_CPU_HOOKS_EN > 0    
void OSTaskCreateHook (OS_TCB *ptcb)   
{   
    ptcb = ptcb;   
}   
#endif    
   
/*
 *                                          TASK DELETION HOOK  
 *  
 * This function is called when a task is deleted.  
 * \arg ptcb   is a pointer to the task control block of the task being deleted.  
 * Note(s)    : 1) Interrupts are disabled during this call.  
 */   
#if OS_CPU_HOOKS_EN > 0    
void OSTaskDelHook (OS_TCB *ptcb)   
{   
    ptcb = ptcb;       /* Prevent compiler warning */   
}   
#endif    
   
/*
 *                                           TASK SWITCH HOOK  
 *  
 * This function is called when a task switch is performed.  This allows   
 * you to perform other operations during a context switch.  
 *  
 * Note(s)    : 1) Interrupts are disabled during this call.  
 *              2) It is assumed that the global pointer 'OSTCBHighRdy' points to the   
 *              TCB of the task that will be 'switched in' (i.e. the highest priority   
 *              task) and, 'OSTCBCur' points to the task being switched out (i.e. the   
 *              preempted task).  
 */   
#if (OS_CPU_HOOKS_EN > 0) && (OS_TASK_SW_HOOK_EN > 0)    
void OSTaskSwHook (void)   
{   
}   
#endif    
   
/*
 *                                           STATISTIC TASK HOOK  
 *  
 * This function is called every second by uC/OS-II's statistics task.    
 * This allows your application to add functionality to the statistics task.  
 */   
#if (OS_TASK_STAT_HOOK_EN > 0)    
void OSTaskStatHook (void)   
{   
}   
#endif    
   
/*
 *                                               TICK HOOK  
 *  
 * This function is called every tick.  
 * Note(s)    : 1) Interrupts may or may not be ENABLED during this call.  
 */   
#if (OS_CPU_HOOKS_EN > 0) && (OS_TIME_TICK_HOOK_EN > 0)    
void OSTimeTickHook (void)   
{   
}   
#endif    
   
/*
 *                                     OS INITIALIZATION HOOK  
 *                                            (BEGINNING)  
 *  
 * This function is called by OSInit() at the beginning of OSInit().  
 * Note(s)    : 1) Interrupts should be disabled during this call.  
 */   
#if OS_CPU_HOOKS_EN > 0 && OS_VERSION > 203    
void OSInitHookBegin (void)   
{   
    linuxInit(); /// installs the syscall handler    
}   
#endif    
   
/*
 *                                     OS INITIALIZATION HOOK  
 *                                               (END)  
 *  
 * This function is called by OSInit() at the end of OSInit().  
 * Note(s)    : 1) Interrupts should be disabled during this call.  
 */   
#if OS_CPU_HOOKS_EN > 0 && OS_VERSION > 203    
void OSInitHookEnd (void)   
{   
}   
#endif    
   
/*
 *                                          IDLE TASK HOOK  
 *  
 * This function is called by the idle task.  This hook has been added to   
 * allow you to do such things as STOP the CPU to conserve power.  
 * Note(s)    : 1) Interrupts are enabled during this call.  
 *   
 *      On real hardware a power saving function would be selected.  
 *      On Linux, we sleep a little to lower the load on the system  
 *      or, we block until next signal is delivered by calling select().  
 *        
 *      If either of these methods causes problems just leave the  
 *      function empty.  
 */   
#if OS_CPU_HOOKS_EN > 0 && OS_VERSION >= 251    
void OSTaskIdleHook (void)   
{   
    // usleep(50); /// as done in Topsy    
    select(0, NULL, NULL, NULL, NULL); /// as done in eCos    
}   
#endif    
   
/*
 *                                           OSTCBInit() HOOK  
 *  
 * This function is called by OS_TCBInit() after setting up most of the TCB.  
 * \arg ptcb    is a pointer to the TCB of the task being created.  
 * Note(s)    : 1) Interrupts may or may not be ENABLED during this call.  
 */   
#if OS_CPU_HOOKS_EN > 0 && OS_VERSION > 203    
void OSTCBInitHook (OS_TCB *ptcb)   
{   
    ptcb = ptcb;        
}   
#endif    
   
   
/*
 *                                 INITIALIZE A TASK'S STACK  
 *  
 * This function is called by either OSTaskCreate() or OSTaskCreateExt() to   
 * initialize the stack frame of the task being created. This function is highly   
 * processor specific.  
 * \arg task    is a pointer to the task code  
 * \arg pdata   is a pointer to a user supplied data area that will be passed to the task  
 *              when the task first executes.  
 * \arg ptos   is a pointer to the top of stack. It is assumed that 'ptos' points to the  
 *              highest valid address on the stack.  
 * \arg opt specifies options that can be used to alter the behavior of OSTaskStkInit().  
 *               \see uCOS_II.H for OS_TASK_OPT_???.  
 *  
 * \return Always returns the location of the new top-of-stack' once the processor   
 * registers have been placed on the stack in the proper order.  
 *  
 * Note(s)    : Interrupts are enabled when your task starts executing. You can change   
 * this by setting this SREG to 0x00 instead. In this case, interrupts would be disabled   
 * upon task startup. The application code would be responsible for enabling interrupts   
 * at the beginning of the task code. You will need to modify OSTaskIdle() and   
 * OSTaskStat() so that they enable interrupts. Failure to do this will make your system   
 * crash!  
 */   
OS_STK* OSTaskStkInit (void (*task)(void* pd), void* pdata, OS_STK* ptos, INT16U opt)   
{   
    INT32U*    stk;   
    ucontext_t uc;   
    INT32U     sigsize = 20 + sizeof(uc);   
   
    opt = opt;            /* 'opt' is not used, prevent warning  */   
       
    getcontext(&uc);   
       
    stk = (INT32U*)((int)ptos - sigsize);   
    uc.uc_link = NULL; /// no successor    
    uc.uc_mcontext.gregs[REG_EBP] = (int)stk;   
    uc.uc_stack.ss_sp = (void*)(((int)stk) - (OS_TASK_DEF_STK_SIZE) + sigsize); /// base address    
    uc.uc_stack.ss_size = OS_TASK_DEF_STK_SIZE - sigsize;   
   
    makecontext(&uc, (void*)task, 1, pdata);   
    memcpy(stk, &uc, sizeof(uc));   
       
    return ((OS_STK *)stk);   
}   
   
   
/*
 * A new thread is started  
 */   
void OSStartHighRdy(void)    
{   
    OSTaskSwHook();   
    OSRunning = TRUE;   
   
    // real work goes here...           
    {   
    ucontext_t* ucp;   
   
    ucp = (struct ucontext*)(OSTCBHighRdy->OSTCBStkPtr);   
    setcontext(ucp);   
    // not reached    
    }   
}   
   
/*
 * called by OSIntExit()  
 *  
 * typically, after signal is handled, a potentially new thread is picked and   
 * resumed  
 */   
void OSIntCtxSw(void)    
{   
    // on Linux this is the same as OSCtxSw; no special treats for hw/sw ints    
    OSCtxSw();   
}   
   
/*   
 * This procedure is called whenever a thread sleeps voluntarily, or, a syscall is made and the  
 * the thread is not the highest priority thread anymore after rescheduling.  
 *  
 * This procedure is called via software interrupt (on Linux synthetic targets: signal and  
 * handler).  
 *  
 * \todo setcontext is a user space implementation of calling sigprocmask and then restoring  
 * registers; should try (ugly) hack using sigreturn which is a real syscall  
 */   
void OSCtxSw(void)    
{      
    struct ucontext* uc = (struct ucontext*)OSTCBHighRdy->OSTCBStkPtr;   
   
    // at this point, registers are already saved on stack    
    OSTaskSwHook();   
   
    OSTCBCur = OSTCBHighRdy;   
    OSPrioCur = OSPrioHighRdy;   
   
    //if (uc->uc_mcontext.fpregs == 0) {    
      //  fprintf(stderr, "ctx sw: uc->uc_mcontext.fpregs == 0\n");    
        //uc->uc_mcontext.fpregs = (fpregset_t)0xbffff6cc;    
    //}    
    setcontext(uc);   
}   
   
   
/*
 * \arg signo Signal number  
 * \arg info Signal info  
 * \arg uc User context  
 */   
void OSCtxSwSigHandler(int signo, siginfo_t* info, /*struct ucontext* */ void* uc)   
{   
    /*
     * Linux specific module variable of current signal context, i.e. interrupted thread  
     */    
    OSTCBCur->OSTCBStkPtr = uc; //stk;    
   
    OSCtxSw();   
}   
       
   
/*
 * \todo maybe wrong for linux port?  
 * adjust sp  if nesting == 1 ???? maybe if there is a seperate interrupt stack  
 * linux user space port does not have a special isr stack frame layout   
 */   
void OSTickISR(void)    
{   
    /// register context already saved in sig handler    
    OSIntEnter();   
    if (OSIntNesting == 1) {   
        //OSTCBCur->OSTCBStkPtr = $SP;    
        //asm("mov %%esp, %0" : "=g"(OSTCBCur->OSTCBStkPtr) : );    
    }   
    OSTimeTick(); /// adjusts counters and ready bitmaps    
    OSIntExit();  /// reschedules if necessary    
    OSIntCtxSw(); /// restore context and jump to highest prio task    
}   
   
/*  
 * Periodic signal handler that adjusts timers  
 * On Linux this is not very precise but for most applications sufficient  
 *  
 * Pick a value between 10 and 1000 Hz for the timer  
 *  
 * \todo this handler maybe executed during a restore (i.e. setcontext())  
 * call. This is a problem with the setcontext() user space implementation in  
 * Linux i386. Most SysV and Linux RISC systems don't have this. The tests  
 * below are an indication that this situatiuon has occured; the SIGALRM  
 * is then aborted...  
 *  
 * \todo If this is not fixed by adding a Linux syscall for get/setcontext, a user level  
 * implementation with an 'clock interrupt' lock should be used  
 *   
 * \arg signo Signal number  
 * \arg info Signal info  
 * \arg uc User context  
 */   
void OSTimeTickSigHandler(int signo, siginfo_t* info, /*struct ucontext* */ void* uc)    
{   
    if ((((ucontext_t*)uc)->uc_mcontext.gregs[REG_EIP] >= (unsigned int)setcontext) &&    
        (((ucontext_t*)uc)->uc_mcontext.gregs[REG_EIP]  (unsigned int)(setcontext + 110))) {   
            //fprintf(stderr, "sig timer: thread interrupted in setcontext\n");    
        return;   
    }   
    if (((ucontext_t*)uc)->uc_mcontext.fpregs == 0) {   
            //fprintf(stderr, "sig timer: uc->uc_mcontext.fpregs == 0\n");    
            return;   
    }    
    OSTCBCur->OSTCBStkPtr = uc; //stk;    
    OSTickISR();   
    // restore context    
}   
   
/*  
 * Kick the periodic clock; this must be done \e after microC/OS-II is initialised,   
 * typically at the end of main()  
 *   
 * Either SIGALRM or SIGVTALRM can be used  
 *   
 * Attention：This must be called by the user in the first task  
 */   
void linuxInitInt()   
{   
    ualarm(1000000/OS_TICKS_PER_SEC, 1000000/OS_TICKS_PER_SEC); /// periodic mode    
   
    // alternative    
    //setitimer(ITIMER_VIRTUAL, 1000000/OS_TICKS_PER_SEC); /// SIGVTALRM  time spent by the     
                                  /// process in User Mode    
}   
   
/*  
 * Setup of Linux specific stuff such as stacks, signals, handlers, mask etc.  
 *  
 * This is called inside the HAL by OSInitHookBegin()  
 */   
void linuxInit()    
{      
    struct sigaction act;   
    sigset_t mask;   
                
    sigemptyset(&mask);   
    act.sa_sigaction = OSTimeTickSigHandler;   
    act.sa_flags = SA_SIGINFO;// | SA_ONSTACK;      
    act.sa_mask = mask;   
    sigaction(SIGALRM, &act, NULL);   
    sigaction(SIGVTALRM, &act, NULL);   
     
    sigemptyset(&mask);   
    act.sa_sigaction = OSCtxSwSigHandler;   
    act.sa_flags = SA_SIGINFO;// | SA_ONSTACK;      
    act.sa_mask = mask;   
    sigaction(SIGUSR1, &act, NULL);   
}

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

详解FreeRTOS：FreeRTOS中断配置（基础篇—6）
不脱发的程序猿
06-28 3378
FreeRTOS的中断配置是一个很重要的内容，需要根据所使用的 MCU 来具体配置。这需要了解 MCU 架构中有关中断的知识。
linux0.11分析之内存分配（结合uCos和VxWorks）
hui6391731的专栏
04-09 840
文章分析了Linux0.11内存分配和释放函数malloc以及free的实现，并且结合uCos和Vxworks的内存管理，进行了阐述。
ucos 在 linux x86 上的移植
05-07
将 ucos 移植到 linux x86 上.
UC/OS和uClinux的比较
ncdawen的专栏
03-12 1159
摘要：嵌入式操作系统是嵌入式系统应用的核心软件。本文通过对两种典型的开源嵌入式操作系统的对比，分析和总结嵌入式操作系统应用中的若干问题，归纳嵌入式操作系统的选型依据。    关键词：嵌入式系统 操作系统 uC/OS uClinux引言随着现代计算机技术的飞速发展和互联网技术的广泛应用，从PC时代过渡到了以个人数字助理、手持个人电脑和信息家电为代表的3C（计算机、通信、消费电子）一体的后
ucos运行linux文件,关于移植ucosii到windows和linux平台下的思路
weixin_39936086的博客
05-07 459
最近给学生上ucosii，因为课本上是在dos下运行ucosii，我不知道怎么的，对此一点兴趣没有，总觉得dos古老的东西了，再没兴趣去玩它。但是学校条件很差，没有开发板来实际玩ucosii，因此光看代码效果比较差。于是我原先想在linux下运行ucosii，后来又想既然linux下可以做，那么windows下也就同样可以。受原书作者的影响，我开始是打算采用和dos下相同的办法移植，即修改中断描述...
在linux上模拟uCOS-II实时操作系统.pdf
09-05
uCOS-II是一个短小而功能强大的实时嵌入式操作系统。在Jean J.Labrosse先生所着.由邵贝贝教授翻译的Micro/uCOS-II THE REAL-TIME
ucos上封装linux接口的系统函数,ucos/lwip移植心得
weixin_42511201的博客
05-08 543
ucos/lwip移植心得2007-09-12 16:01经过几天调试除掉几个bug以后,ucos+lwip在我的44b0+8019开发板上终于跑得比较稳定了.一只觉得lwip是一个不错的开放源码的tcp/ip协议栈,想把自己对lwip的移植和理解写出来.但是由于最近比较忙,lwip的移植也是利用业余时间做的,今天写好了第一部分(lwip的processmodel)先贴上来,如果大家有兴趣我再接...
ucos for linux port 代码
09-20
《UCOS for Linux Port 代码》是一份专为在Linux平台上移植和运行UCOS操作系统而设计的源码集合。这份代码旨在帮助开发者理解和实践UCOS操作系统的核心机制，以及如何将其移植到Linux系统上，以便在Linux环境下充分...
ucos创建自己的任务
jdfh_5334的博客
08-13 422
p_stk_base is a pointer to the task’s stack base address. The task’s stack is used to store local variables, function parameters, return addresses, and possibly CPU registers during an interrupt.// 任务栈空间基地址的指针。用来进行提示和警告。OS_OPT_TASK_STK_CHK //运行任务堆栈检测。
stm32引脚功能
最新发布
03-08
For detailed information on configuring individual port configurations refer to official documentation provided alongside your chosen evaluation board setup instructions specifically mentioning how ...
linux ucos3开发环境,移植uCOS-II到Cortex-M3平台
weixin_39987985的博客
05-07 265
本文的目的是希望读者能够通过本文的内容掌握移植uCOS-II的规范方法。如果只是需要移植文件，可以直接去Micriμm的官网上下载。移植uCOS-II，主要的移植工作是编写如下三个文件：OS_CPU.HOS_CPU_C.COS_CPU_A.ASM下面就按照这三个文件的顺序来介绍。本文以STM32F107+RealView Compiler开发环境为例。如果使用的其他的开发环境，个别代码可能需要做些...
在linux上模拟uCOS-II实时操作系统的实现
08-14
uCOS-II是一个短小而功能强大的实时嵌入式操作系统。在Jean J.Labrosse先生所著.由邵贝贝教授翻译的Micro/uCOS-II THE REAL-TIME KERNEL(Second Edition)一书中对这一操作系统作出了精彩的讲解，该书是一部关于uCOS-II操作系统的经典教材，同时在书中提供了关于uCOS-II在windows环境下的移植的4个范例。
实时操作系统从RTOS移植到实时Linux
07-22
本文介绍了实时操作系统从RTOS移植到实时Linux
ucos移植
MoMo的奋斗
07-25 823
[toc]1. 关于ucosii的移植1. 总体步骤 前期了解 目标芯片（内核） ucosii内核原理 2. ucosii内核原理 ucosii内核可分为： 任务调度，任务同步，内存管理，三部分任务调度为每个任务分配一个不同的优先级 以下情况会发生任务切换任务等待资源或者自我延时 退出中断 SysTick中断是os的”心跳”，会发生周期性任务切换，所以必须调用OSTimeTick(); os_co
uC/OS-II - Port for the LINUX Operating System
CyberLabs的专栏
10-30 3584
uC/OS-II - Port for the LINUX Operating System Copyright (C) 2004-... Werner.Zimmermann|AT|hs-esslingen.de Overview uC/OS-II (uCOS II) is a small, yet powerful real-time operating system devel
linux文件系统在ucos上,初探在uCOS II上实现大容量内存文件系统
weixin_32915107的博客
05-13 443
和普通磁盘文件系统相比, 内存文件系统具有存取速度快、可动态改变文件系统大小和数据掉电即丢失的优点, 因此它适用于高速的临时数据处理。Linux 下的Tmpfs、Proc 文件系统以及Freebsd 下的MFS 都是一种内存文件系统。但是, 这些通用操作系统上的内存文件系统不能直接运用到嵌入式系统中, 因此探索了适合嵌入式大容量数据处理的嵌入式内存文件系统的实现。本文阐述了嵌入式内存文件系统的设计...
zynq petalinux AMP双核运行linux+ucos（或者裸机）之间进行 IPI 软中断通讯的实现
听我瞎扯淡的博客
04-14 4146
前几天试验了xilinx官方remotporc AMP程序，运行是运行起来了，但是感觉太复杂了，我只想要一个能启动停止cpu1，能在两个cpu之间方便通讯的功能就行了，看着remotproc框架一堆的代码，编译出来的elf文件体积还超级大心里就非常不爽，想着干脆自己实现一个简单处理驱动程序算了，so...经过几天的痛苦研究，也算完整实现了想要的功能 由于linux应用程序不能处理硬件中断，因此这个IPI通讯只能在驱动层进行处理，所以第一步，要编写一个驱动程序，实现cpu1的bin（不是elf）文件加载，控
ucosii操作系统和linux,请高手介绍下uCOSII和Linux的差异？
weixin_39819283的博客
04-29 216
宝慕林4294392区别：ucos有执行效率高、占用空间小、实时性和可扩展性强等特点，linux有稳定性、强大网络功能和出色的文件系统等优点。联系：是两种性能优良源码公开且被广泛应用的的免费嵌入式操作系统，可以作为研究实时操作系统和非实时操作系统的典范。μC/OS II(Micro-Controller Operating System Two)是一个可以基于ROM运行的、可裁剪的、抢占式、实时多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值