第4章第7节 二进制信号量（三）

目前更新到5.3节，请在http://dl.dbank.com/c02ackpwp6下载5.3节的全部文档

本节源代码请在http://dl.dbank.com/c0fp2g5z9s下载

 

图53列出了多个不同状态的任务与这些调度表之间的关系，任务1被信号量sem1阻塞，处于非永久pend态，strDelayQue结构中的strQueHead节点被挂接到delay表，strTcbQue结构中的strQueHead节点被挂接到sem1表，pstrSem指针指向sem1。任务2处于ready态，strTcbQue结构中的strQueHead节点被挂接到ready表。任务3处于非永久delay态，strDelayQue结构中的strQueHead节点被挂接到delay表。任务4被信号量sem1阻塞，处于永久pend态，strTcbQue结构中的strQueHead节点被挂接到sem1表，pstrSem指针指向sem1。任务5被信号量sem2阻塞，处于非永久pend态，strDelayQue结构中的strQueHead节点被挂接到delay表，strTcbQue结构中的strQueHead节点被挂接到sem2表，pstrSem指针指向sem2。任务6处于永久delay态，不与任何调度表有关系。

图 53  TCB与各种调度表的关系

以上是本节新增加的内容，本节使用了4个验证任务TEST_TestTask1~TEST_TestTask4，它们的优先级分别为6，2，4，5，还有2个信号量gstrSemSync和gstrSemMute，它们都被初始化为FIFO类型。

TEST_TestTask3和TEST_TestTask4任务在开始的前3次循环中为互斥任务，在TEST_TestTask3任务获取到gstrSemMute信号量的期间内，TEST_TestTask4任务被gstrSemMute信号量阻塞，当TEST_TestTask3任务释放gstrSemMute信号量后TEST_TestTask4任务获取到gstrSemMute信号量并开始运行，此时TEST_TestTask3任务会被gstrSemMute信号量阻塞，直到TEST_TestTask4任务再次释放gstrSemMute信号量，这两个任务如此循环3次。3次循环之后，这两个任务都被阻塞到gstrSemSync信号量，需要由TEST_TestTask1任务释放gstrSemSync信号量来触发这2个任务的运行。

TEST_TestTask1任务的前10次循环用来释放gstrSemSync信号量，触发被阻塞到这个信号量上的任务。TEST_TestTask2任务一直在获取gstrSemSync信号量，需要由TEST_TestTask1任务激活。TEST_TestTask1任务运行10次循环之后，接下来的5次循环使用MDS_SemFlush函数激活所有被阻塞到gstrSemSync信号量上的任务，5次循环之后，TEST_TestTask1任务会删除gstrSemSync信号量，另外三个任务检测到gstrSemSync信号量被删除，会退出主函数，结束任务的运行。

00021  void TEST_TestTask1(void)

00022  {

00023      U8 i;

00024  

00025      i = 0;

00026  

00027      while(1)

00028      {

00029          DEV_PutStrToMem((U8*)"\r\nTask1 is running ! Tick is: %d",

00030                          MDS_SystemTickGet());

00031  

00032          DEV_DelayMs(1500);

00033  

00034          (void)MDS_TaskDelay(200);

00035  

00036          

00037          if(i < 10)

00038          {

00039              i++;

00040  

00041              DEV_PutStrToMem((U8*)"\r\nTask1 give gstrSemSync %d! Tick is: %d",

00042                              i, MDS_SystemTickGet());

00043  

00044              

00045              (void)MDS_SemGive(&gstrSemSync);

00046          }

00047          

00048          else if(i < 15)

00049          {

00050              i++;

00051  

00052              DEV_PutStrToMem((U8*)"\r\nTask1 flush gstrSemSync %d! Tick is: %d", i,

00053                              MDS_SystemTickGet());

00054  

00055              

00056              (void)MDS_SemFlush(&gstrSemSync);

00057          }

00058          

00059          else if(15 == i)

00060          {

00061              i++;

00062  

00063              DEV_PutStrToMem((U8*)"\r\nTask1 delete gstrSemSync %d! Tick is: %d", i,

00064                              MDS_SystemTickGet());

00065  

00066              

00067              (void)MDS_SemDelete(&gstrSemSync);

00068          }

00069      }

00070  }

00077  void TEST_TestTask2(void)

00078  {

00079      U8 i;

00080  

00081      i = 0;

00082  

00083      while(1)

00084      {

00085          

00086          if(RTN_SMTKDL == MDS_SemTake(&gstrSemSync, SEMWAITFEV))

00087          {

00088              DEV_PutStrToMem((U8*)"\r\nTask2 gstrSemSync deleted! Tick is: %d",

00089                              MDS_SystemTickGet());

00090  

00091              return;

00092          }

00093          else 

00094          {

00095              i++;

00096  

00097              DEV_PutStrToMem((U8*)"\r\nTask2 take gstrSemSync %d! Tick is: %d", i,

00098                              MDS_SystemTickGet());

00099  

00100              DEV_DelayMs(100);

00101          }

00102      }

00103  }

00110  void TEST_TestTask3(void)

00111  {

00112      U8 i;

00113  

00114      i = 0;

00115  

00116      while(1)

00117      {

00118          

00119          if(i < 3)

00120          {

00121              i++;

00122  

00123              

00124              (void)MDS_SemTake(&gstrSemMute, SEMWAITFEV);

00125  

00126              DEV_PutStrToMem((U8*)"\r\nTask3 take gstrSemMute %d! Tick is: %d", i,

00127                              MDS_SystemTickGet());

00128  

00129              DEV_DelayMs(500);

00130  

00131              (void)MDS_TaskDelay(150);

00132  

00133              DEV_PutStrToMem((U8*)"\r\nTask3 give gstrSemMute %d! Tick is: %d", i,

00134                              MDS_SystemTickGet());

00135  

00136              

00137              (void)MDS_SemGive(&gstrSemMute);

00138          }

00139          else 

00140          {

00141              i++;

00142  

00143              

00144              if(RTN_SMTKDL == MDS_SemTake(&gstrSemSync, SEMWAITFEV))

00145              {

00146                  DEV_PutStrToMem((U8*)"\r\nTask3 gstrSemSync deleted! Tick is: %d",

00147                                  MDS_SystemTickGet());

00148  

00149                  return;

00150              }

00151              else 

00152              {

00153                  DEV_PutStrToMem((U8*)"\r\nTask3 take gstrSemSync %d! Tick is: %d",

00154                                  i, MDS_SystemTickGet());

00155  

00156                  DEV_DelayMs(500);

00157  

00158                  (void)MDS_TaskDelay(150);

00159              }

00160          }

00161      }

00162  }

00169  void TEST_TestTask4(void)

00170  {

00171      U8 i;

00172  

00173      i = 0;

00174  

00175      while(1)

00176      {

00177          

00178          if(i < 3)

00179          {

00180              i++;

00181  

00182              

00183              (void)MDS_SemTake(&gstrSemMute, SEMWAITFEV);

00184  

00185              DEV_PutStrToMem((U8*)"\r\nTask4 take gstrSemMute %d! Tick is: %d", i,

00186                              MDS_SystemTickGet());

00187  

00188              DEV_DelayMs(500);

00189  

00190              (void)MDS_TaskDelay(200);

00191  

00192              DEV_PutStrToMem((U8*)"\r\nTask4 give gstrSemMute %d! Tick is: %d", i,

00193                              MDS_SystemTickGet());

00194  

00195              

00196              (void)MDS_SemGive(&gstrSemMute);

00197          }

00198          else 

00199          {

00200              i++;

00201  

00202              

00203              if(RTN_SMTKDL == MDS_SemTake(&gstrSemSync, SEMWAITFEV))

00204              {

00205                  DEV_PutStrToMem((U8*)"\r\nTask4 gstrSemSync deleted! Tick is: %d",

00206                                  MDS_SystemTickGet());

00207  

00208                  return;

00209              }

00210              else 

00211              {

00212                  DEV_PutStrToMem((U8*)"\r\nTask4 take gstrSemSync %d! Tick is: %d",

00213                                  i, MDS_SystemTickGet());

00214  

00215                  DEV_DelayMs(500);

00216  

00217                  (void)MDS_TaskDelay(200);

00218              }

00219          }

00220      }

00221  }

 

按照这4个任务设定的循环时间和任务优先级，开始时应该会看到TEST_TestTask1任务触发TEST_TestTask2任务，同时TEST_TestTask3任务和TEST_TestTask4任务互斥运行。当TEST_TestTask3任务和TEST_TestTask4任务互斥运行3次之后，它们不再互斥运行，而是变为同TEST_TestTask2任务一样，需要由TEST_TestTask1任务激活，此时应该看到TEST_TestTask1任务会顺序激活其它3个任务。当TEST_TestTask1任务运行10个循环之后，会使用MDS_SemFlush函数同时激活所有其它3个任务，应该会看到这3个任务全部被激活运行。TEST_TestTask1任务执行MDS_SemFlush函数5次之后会删除同步信号量，其它3个任务会发现信号量被删除而退出任务。

本节运行结果截图如下：

图 54  任务获取信号量的打印信息

读者可以访问http://blog.sina.com.cn/ifreecoding网站下载视频，观看全部数据的打印过程，从打印数据可以看到实际输出结果与我们的设计是一致的。

 

使用工具软件解析本节任务切换过程的数据，结果如下图所示：

 

 

图 55  4.7节任务切换过程图

为了对比二进制信号量FIFO和PRIO属性的区别，我们将gstrSemSync信号量由FIFO属性改为PRIO属性，重新编译运行输出结果，解析PRIO属性的输出数据，结果如图56所示：

图 56  信号量改为PRIO属性后的任务切换过程图

我们对比图55和图56可以发现中间部分有明显的区别，中间部分是由TEST_TestTask1任务释放信号量激活其它3个任务的过程。在图55中，TEST_TestTask1任务释放信号量之后，TEST_TestTask2、TEST_TestTask3和TEST_TestTask4任务轮流被激活，而在图56中，TEST_TestTask1任务释放信号量之后却只有TEST_TestTask2任务被激活，这是因为图55的信号量采用的是FIFO属性的，会按照信号量阻塞任务的顺序轮流激活任务，而图56的信号量采用的是PRIO属性的，会激活被信号量所阻塞任务中的优先级最高的任务，因此只有优先级最高的TEST_TestTask2任务会被激活。