EEPW论坛

由于手头上的工具较为陈旧，这次搭建环境也是费了不少的力气，不多说，开贴分享，求高人指正。

基本环境采用的是开发套件光盘自带的软件：KEIL MDK4.6和J-Link4.68，仿真器是J-Link V7，基本上安装都没有太多问题。

光盘里MDK软件木有和谐，和谐补丁在此，有需要的筒子可以下载试试：——回复可见内容——

此和谐补丁来自互联网且纯属学习使用，如果涉及产权问题，请站内M我删除或者直接请版主删除。

缺少一个动态链接文件，需要的筒子可以下载试试，——回复可见内容——，解压后将agdirdi.dll文件拷贝到\Keil\ARM\BIN目录下就ok了。

前面有TX提出降低J-Link软件的版本，这是一个解决办法，但是知道是校验SN产生的问题，就可以用一个目前看来，釜底抽薪、一劳永逸的办法，修改SN。这里要用到winhex，——回复可见内容——，用winhex打开J-Link的固件，修改2个地方，就能修改自己J-Link的SN了。

修改结束后保存，用AT91-ISP软件将修改后的固件烧录进J-Link，运行J-Link ARM，会提示firmware升级，直接不理会（以后通过Keil调用J-Link的时候都会有这个提示，一律点否），进去后就发现SN改变了，再也不用担心由于SN引起的clone问题了。

我这里SN改成了16777215（貌似有溢出），以后调试，再无问题。

V7版本J-link修改后正常，兼容版V8的筒子们也可以参考，王总表打我脸。

关于H-Jtag：如果你有USB HJtag可以在win7 64位以上操作系统使用，但是想尝试并口HJtag的话，64位系统就放弃这个想法吧，H-Jtag并口驱动不支持win7 64位以上的系统。 

折腾了好几天，老设备才能正常的用起来，高手们表藐视，请回复支持DIY精神。

第一次接触μTenux

完成了环境的搭建，着手开始对μTenux进行了解。鄙人对嵌入式OS了解不够深入，只能从一些粗浅的地方开始学习。

打开workspace，像我这种初学者有点不适应，说实话，第一次接触好几个项目在同一个KEIL workspace下面编译开发（很有eclipse的味道）。仔细看看，一共有appusermain、kernel、libcpu、libdev、libtm和bin这6个工程在里面，后面的一些错误的操作，也和这种结构有关。

keil下这种工程结构有个很痛苦的地方，如果需要查看某个函数或变量的定义，就必须将文件所在的工程set as active project，如果某个函数或变量的定义不在当前工程，我还没找到办法查看定义，只能够用查找的方式，在整个workspace文件里面查找，不知道在其他编译环境下是什么情况，各位大侠们有什么好的解决办法？

还有一个有关工程结构整出的乌龙，原因是由于惯性思维，一直认为应用程序在appusermain工程里面编写，理所当然的下载文件也由appusermain工程生成。但实际上，工程batch build所产生hex或axf文件，必须由bin工程产生，其他工程只生成库文件，否则会出现很多类似L6236E这样的编译错误。感谢uloong公司的阿奔和龙哥，在端午节的时候还在帮忙分析解决。经过一段时间的摸索，逐渐适应了这种结构，其实感觉很严谨，蛮不错的。不知道新发布的内核源码1.6版本结构改了没。

把例程打印信息稍作修改，算是完成第一次接触μTenux。

工程结构的问题，觉得自己在嵌入式OS方面还有很长的路要走。

从下次开始，逐渐开始摸索μTenux的基本特性，譬如任务、信号量、中断等等，进一步了解μTenux。

希望通过本次活动能有所斩获，与筒子们共勉。

μTenux实验一（任务）

下载了1.6版本的源码，直奔sam3s4c的工程，顿时觉得眼睛舒服了很多，简洁明了哇。

简单看了一下内核规范，感觉需要记忆的东西太多，干脆直接读代码，有问题再去翻内核规范。

发现创建任务的时候，都会有一个taskid和E_OK的比较，翻看规范才知道，E_OK=0，使用tk_cre_tsk()函数创建任务成功的话会返回一个正值，否则返回一个负值。手痒痒，做了一个小小的修改。

build，load，打开串口，reset，一系列动作后，串口返回这么个咚咚。

看来，我分析的不错，内核规范还得时刻set to top（想去再整个显示器了……，一个不够用啊）。

1) 如果打开调试支持和钩子函数（HOOK），重新构造运行，会有什么不同？

在实验代码里面，使用了很多预编译，基本上都是针对调试和钩子函数的，找到USE_DBGSPT和USE_HOOK_TRACE 的定义，从0U改成1U。

重建后，每次SVC都会打印输出相关的信息（不知道是否准确）。

2) 如何任务 C 在任务循环中不是进行循环，而是也调用 tk_slp_tsk，会出现什么情况？为什么？

无论TaskC在循环内或者去掉循环直接调用休眠，最终系统都要运行到“Push any key to shutdown the micro Tenux”。

个人理解与程序流程有关，在TaskC进入休眠态时，TaskB和TaskA也都在休眠态，那么这个时候操作系统无任务可进行调度，由于TaskC和TaskA均由TaskB执行，所以程序跳转ER TaskSample( void)，并返回E_OK。追溯到调用TaskSample的usermain，下一语句已经是tm_putstring((UB*)"Push any key to shutdown the micro Tenux.\n")。至此，等键盘输入后结束。

3) 找找参考程序中有没有永远不会执行的代码？实际修改一下，看看判断的是否准确？为什么？

个人认为TaskA和TaskC中有一段代码（红框内）似乎永远无法执行。

这里的无条件循环语句for(;;)木有break或goto，只能不停地sleep，结束休眠后再从头执行for(;;)语句，为了证实我的分析，我在TaskA的for(;;)语句中加了一行tm_putstring((UB*)"Task A will start;\n")，执行后每次TaskA结束休眠态后，都仅执行循环语句。

不知道上面对思考题的分析对不对，请大牛赐教。

嵌入式操作系统的学习的确千头万绪，有好多函数和变量目前都没仔细了解到，只能把内核规范作为手册，不理解的地方猛戳手册和搜索引擎。

TBC......

μTenux实验二（信号量）

直接读代码，按照实验教程就能得到结果，过程比较简单。直接上串口打印信息。

从打印信息来看，TaskA和TaskB轮流在对信号量进行操作。基本上符合程序的流程。

1) 如何将本实验中信号量的例子改为互斥信号量？尝试修改一下！（TaskA优先级高于TaskB）

这里首先要整清楚，什么是互斥信号量。

互斥实际上就是要保证某一个资源，只能够由特定的某个任务独享，无论等待中的任务优先级高低，都必须保证当前任务独享这个资源，当前任务释放后，这个资源才能被其他任务使用。

那么互斥信号量，就是完成互斥控制的信号量。一般是一个二值参数，要么释放，要么独享。

不知道这种理解对不对。

对实验代码的信号量进行设置：csem.isemcnt = 1;csem.maxsem = 1;

并使TaskB在任务循环中不释放信号量，直接将释放信号量的代码注释掉。

完成上述处理后，理论上，TaskA不会再有机会对信号量进行操作，也就是TaskB将独享信号量的操作权，达到资源独享的互斥控制效果。但是出问题咧。

从打印信息来看，A虽然在B等待的状态下不能操作信号量，但是A挂起后，B也无法操作信号量了，系统所有任务都挂起的话，μTenux会退出（μTenux没有像μCos一样，默认有一个无法删除的Idle任务，不过可以在初始化函数中创建一个）。虽然进行了一次互斥控制，但是不够完美。

思考着能不能在TaskB的任务循环首句增加一句ercd = tk_sig_sem(semid, 1);这样可以使TaskB在任务循环开始的时候释放信号量，而在任务循环最后不释放信号量，从而使TaskA无法等到信号量，完成TaskB对资源的独享。

编译，下载，却发现打印信息和预计的相差甚远。

从打印信息来分析，虽然TaskB在TaskA执行前并未释放信号量，但是TaskA依然能够获取信号量的处理权，咋回事？

原来TaskB任务循环的首句ercd = tk_sig_sem(semid, 1);会进行一次系统调度，也就是说虽然A在等待信号量未分配到资源进入等待状态，但是B中一旦调用ercd = tk_sig_sem(semid, 1);，加之优先级A>B，A会优先于B执行，虽然B在自己的循环中释放了信号量，但是A会立刻抢占cpu运行权，对信号量进行操作。

翻查内核规范，注意到tk_wai_sem()函数的参数中有一个TMO_POL，当在 tmout 中设置 TMO_POL=0 时，表明时限值（timeout value）被设定成 0，即使没有获得资源， 也会返回 E_TMOUT，而不进入等待状态。

立马修改代码，将TaskA调用tk_wai_sem()函数时的参数改为TMO_POL=0 ，并将循环内的语句顺序烧嘴修改。使A等不到信号量后不是进入等待状态，而是进入休眠状态。而休眠态的A，无论B是否释放信号量，都无法对信号量进行操作，达到B独享的互斥控制效果。

看看运行的结果是否和预想的一致。

果然，从打印信息来看，只有TaskB在对信号量进行操作。

呃，折腾了这么久，这个算不算是互斥控制呢？请大神科普。

TBC......

实验三事件标志

事件标志实验相对比较简单，其实就是创建初始化一个事件标志为01，同时创建2个优先级相同的任务A和B。

A的触发事件标志为1(01)，B的触发事件标志为2(10)。

A触发执行时把事件标志set为10；A结束后，B被触发执行并将事件标志set为01；B结束后，A触发执行……；如此反复进行。这里要注意事件标志位SVC函数的含义，tk_clr_flg函数仅仅是清除，并不引起任务的调用，而tk_set_flg函数执行后，一旦此事件标志符合某任务的触发条件，这个任务就会进入运行态或就绪态。

编译，下载，得到串口打印信息。

简要分析打印信息，A和B在各自的循环中将事件标志位设置为对方的触发条件，这样A和B就一直在轮询。基本上ok。实验之余，我将A的事件标志设置为5（101），B的事件标志设置为4（100），初始化事件标志为4（100），B任务最后将事件标志位设置为5（101）。

通过串口信息发现B进入任务循环后再也无法触发任务A。

难道每个任务等待事件标志位仅等待第一位？求科普。

1) 本实验中演示了两个同优先级任务使用事件标志进行交替的方式,如果把一个任务更换为中断,结果如何?

本来想提前学习一下μTenux的中断管理，但发现v1.5和v1.6版本源码的例程中木有中断的例子。

自己尝试设置了不可屏蔽中断和服务程序，但是发现有些变量找不到定义。

先mark，待日后学习了中断再来解答。

2) 本实验中演示了两个同优先级任务使用事件标志进行交替的方式,如果把一个任务的优先级提高,结果如何?什么情况下,会使用到这种方式?
我分别设置了优先级A>B和A <B

优先级A>B：

不解释，很常规。

优先级A<B

通过串口信息，不难分析，B运行后，由于无法等到事件标志位而进入等待状态，这个时候A就进入运行态，在A完成任务后，B才能进入运行态。

看来事件标志位的作用还是很大的，如果一个优先级高的任务中含有从优先级低的任务里面才能获取的变量，那么这个时候用事件标志位去使得高优先级任务等待低优先级任务的参数传递时再好不过的了。

举个例子，如果一个传感器数据处理的系统，数据处理任务优先级高，传感器驱动获取数据的任务优先级较低，那么就可以利用事件标志位，让数据处理任务在需要传感器数据的时候进入等待态，而传感器驱动获取数据的任务进入运行态，在传感器驱动获取数据的任务完成后，再set事件标志位并返回获取的数据，传递给数据处理任务进行处理。

不知这种应用是否得当，求大拿指点哇。

TBC......

自己占个板凳坑，实验一个个做，进程一个个写。

希望能早日进入开发阶段。

实验四 消息邮箱

邮箱特像古代的烽火台，只要人（任务）在看到（等待邮箱消息）烽火台点燃，人（任务）就立刻进入下一个操作。实验的源码写得很易懂，创建-A发送-A等待-B收取-B发送-A接收，流程十分清楚。

源码编译、下载，得到期望的打印信息。

不解释。

想尝试一下多个消息的发送，看看内核规范，源码中邮箱可以设置为FIFO和优先级两种发送模式，设置一下。

FIFO模式：

经典的FIFO，先发送的消息先收到。

优先级模式：

这个模式花了点时间研究T_MSG、U_SMG和T_SMG_PRI之间的关系，但是还存在有问题。

呃，A发送优先级为9的“尼玛速度运行”和优先级为10的“1-2-3,Please starting up....”，B先接收到的是“尼玛速度运行”，再接收“1-2-3,Please starting up....”，是不是和系统的功能一样呢？我觉得是。

为毛B在发送第二条消息的时候（和A的发送模式一样），会返回E_PAR（错误的参数传递），源代码在下面：

#include "MailboxSample.h"


typedef struct u_msg {
    T_MSG               msgque;                 /* Area for message queue */
PRI                 msgpri;                 /* Message priority */
    UB  *usrmsg;    /* Area for message pointer */
} U_MSG;


void MbxSampleTaskA(W stacd,VP exinf);
void MbxSampleTaskB(W stacd,VP exinf);
static ID TaskID_A;
static ID TaskID_B;
static ID MbxID_S;
static ID MbxID_R;

ER MbxSample( void)
{
    ER ercd=E_OK;
    T_CTSK ctsk;
    T_CMBX cmbx;


    tm_putstring((UB*)"Mailbox sample create step 1-Create Task A;\n");
    ctsk.exinf = (VP)NULL;
    ctsk.tskatr = TA_HLNG|TA_RNG0;
    ctsk.task = MbxSampleTaskA;
    ctsk.itskpri = 20;
    ctsk.stksz = 512;
    TaskID_A = tk_cre_tsk(&ctsk);
    if(TaskID_A < E_OK) {
        ercd=TaskID_A;
        tm_putstring((UB*)"Task A can't creat;\n");
        PutErcd(ercd);
        return ercd;
    }
    
    tm_putstring((UB*)"Mailbox sample create step 2-Create Task B;\n");
    ctsk.exinf = (VP)NULL;
    ctsk.tskatr = TA_HLNG|TA_RNG0;
    ctsk.task = MbxSampleTaskB;
    ctsk.itskpri = 24;
    ctsk.stksz = 512;
    TaskID_B = tk_cre_tsk(&ctsk);
    if(TaskID_B < E_OK) {
        ercd=TaskID_B;
        tm_putstring((UB*)"Task B can't creat;\n");
        PutErcd(ercd);
        return ercd;
    }
    
    tm_putstring((UB*)"Mailbox sample create step 3-Create a send mailbox;\n");
    cmbx.exinf = (VP)NULL;
    cmbx.mbxatr = TA_TPRI|TA_MPRI;
    MbxID_S = tk_cre_mbx(&cmbx);
    if(MbxID_S < E_OK){
        ercd=MbxID_S;
        tm_putstring((UB*)"MailBox_Send can't creat;\n");
        PutErcd(ercd);
        return ercd;
    }


    tm_putstring((UB*)"Mailbox sample create step 4-Create a return mailbox;\n");
    cmbx.exinf = (VP)NULL;
    cmbx.mbxatr = TA_TPRI|TA_MPRI;
    MbxID_R = tk_cre_mbx(&cmbx);
    if(MbxID_R < E_OK){
      ercd=MbxID_R;
      tm_putstring((UB*)"MailBox_Recieve can't creat;\n");
      PutErcd(ercd);
      return ercd;
    }


    tm_putstring((UB*)"Mailbox sample create step 5-Start Task A;\n");
    ercd = tk_sta_tsk(TaskID_A,0);
    if (E_OK != ercd){
        tm_putstring((UB*)"start Task A failed;\n");
        PutErcd(ercd);
    }
    return TRUE;
} 


void MbxSampleTaskA(W stacd,VP exinf)
{
    B c;
    ER ercd;
    U_MSG *pk_rcvmsg,*pk_rcvmsg1;
    U_MSG sndmsg,sndmsg1;


    tm_putstring((UB*)"Mailbox sample create step 6-Start Task B;\n\n");
    ercd = tk_sta_tsk(TaskID_B,0);
    if (E_OK != ercd){
        tm_putstring((UB*)"Task B is starting failed;\n");
        PutErcd(ercd);
    }


    for(;;){
        tm_putstring((UB*)"Task A is running,Input Command(e=exit):\n");
        c = tm_getchar(0);
        if('e' == c) {
            break;
        }
sndmsg.msgpri = 10;
        sndmsg.usrmsg = "1-2-3,Please Starting up....\n";
        tm_putstring((UB*)"Task A send the first message to Task B:");
        tm_putstring((UB*)sndmsg.usrmsg);
        ercd = tk_snd_mbx(MbxID_S,(T_MSG*)&sndmsg);
        if(E_OK == ercd){
            tm_putstring((UB*)"Task A sent a message successfully;\n");
        }else{
            tm_putstring((UB*)"Task A can't send a message;\n");
            PutErcd(ercd);
        }
sndmsg1.msgpri = 9;
sndmsg1.usrmsg = "ÄáÂêËÙ¶È ÔËÐÐ....\n";
        tm_putstring((UB*)"Task A send the second message to Task B:");
        tm_putstring((UB*)sndmsg1.usrmsg);
        ercd = tk_snd_mbx(MbxID_S,(T_MSG*)&sndmsg1);
        if(E_OK == ercd){
            tm_putstring((UB*)"Task A sent a message successfully;\n");
        }else{
            tm_putstring((UB*)"Task A can't send a message;\n");
            PutErcd(ercd);
        }


        tm_putstring((UB*)"Task A is waiting Task B return message;\n\n");

tk_slp_tsk ( -1 ) ;
        ercd = tk_rcv_mbx(MbxID_R,(T_MSG**)&pk_rcvmsg,-1);
ercd = tk_rcv_mbx(MbxID_R,(T_MSG**)&pk_rcvmsg1,-1);
        if(E_OK == ercd){
            tm_putstring((UB*)"Task A have received return message: ");
            tm_putstring((UB*)pk_rcvmsg->usrmsg);
tm_putstring((UB*)"Task A have received return message: ");
            tm_putstring((UB*)pk_rcvmsg1->usrmsg);
        }else{
            tm_putstring((UB*)"Task A can't receive return message: \n");
            PutErcd(ercd);
        }
    }


    tm_putstring((UB*)"Task A will delete mailbox;\n");
    tk_del_mbx(MbxID_S);
    tk_del_mbx(MbxID_R);
    tm_putstring((UB*)"Task A will terminate&delete task B;\n");
    tk_ter_tsk(TaskID_B);
    tk_del_tsk(TaskID_B);
    tm_putstring((UB*)"Task A will terminate&delete self;\n");
    tk_exd_tsk();
}

void MbxSampleTaskB(W stacd,VP exinf)
{
    ER ercd;
    U_MSG *pk_rcvmsg,*pk_rcvmsg1;
    U_MSG sndmsg,sndmsg1;


    for(;;){
        tm_putstring((UB*)"Task B is waiting a message;\n");
        ercd = tk_rcv_mbx(MbxID_S,(T_MSG**)&pk_rcvmsg,-1);
        if(E_OK == ercd){
            tm_putstring((UB*)"Task B have received the first message: ");
            tm_putstring((UB*)pk_rcvmsg->usrmsg);
        }else{
            tm_putstring((UB*)"Task B can't receive a message: ");
            PutErcd(ercd);
        }
ercd = tk_rcv_mbx(MbxID_S,(T_MSG**)&pk_rcvmsg1,-1);
        if(E_OK == ercd){
            tm_putstring((UB*)"Task B have received the second message: ");
            tm_putstring((UB*)pk_rcvmsg1->usrmsg);
        }else{
            tm_putstring((UB*)"Task B can't receive a message: ");
            PutErcd(ercd);
        }
sndmsg.msgpri = 10;
        sndmsg.usrmsg = "I have got up...\n";
        tm_putstring((UB*)"Task B return a message to Task A:");
        tm_putstring((UB*)sndmsg.usrmsg);
        tm_putstring((UB*)"\n");
        ercd = tk_snd_mbx(MbxID_R,(T_MSG*)&sndmsg);
        if(E_OK != ercd){
            tm_putstring((UB*)"Task B can't return a message;\n");
            PutErcd(ercd);
        }
sndmsg.msgpri = 9;
sndmsg1.usrmsg = "ÒѾ­ÔÚÔËÐÐÁË...\n";
        tm_putstring((UB*)"Task B return a message to Task A:");
        tm_putstring((UB*)sndmsg1.usrmsg);
        tm_putstring((UB*)"\n");
        ercd = tk_snd_mbx(MbxID_R,(T_MSG*)&sndmsg1);
        if(E_OK != ercd){
            tm_putstring((UB*)"Task B can't return a message;\n");
            PutErcd(ercd);
        }

tk_wup_tsk (TaskID_A) ;
    }
}

如果接收邮箱参数改为cmbx.mbxatr = TA_TPRI|TA_MFIFO;就能正常了，不过A无法接收优先级类型的消息了。

难道是优先级高的任务不能够从低优先级任务获取优先级类型的信息？百思不得其解，求大拿指点。

-----------------------------------------------------我是华丽的解答线---------------------------------------------------------------------

就在我决定关机的一瞬间，我发现问题所在鸟。

任务B第二条消息的优先级sndmsg.msgpri = 9;和第一条消息的参数一样，手欠啊，果断修改之。

世界清静了：

要小心啊，就少输入个1，一直折腾到现在。

1) 如果把发送消息和反馈消息放在同一个邮箱中，如何实现？如果不能实现会出现什么样的状况？
不想做理论分析，直接修改代码做实验。

直接注释掉接收信箱的创建代码，发送和接受都使用MbxID_S。

原来问题里面的状况是指，只有一个A任务在不断的循环，根本无法进入到任务B的循环中。

题目要求用一个邮箱完成收发，果断想到事件标志位，果断修改代码。

创建事件标志，分别设置A和B的标志操作，注释掉接收邮箱，仅用send邮箱完成massage的接受和发送任务，run......

原来一个邮箱就ok啦。

困，先码到这，TBC......