STM32

结合时间触发+消息+protothread思想+支持优先级的非抢占调度器

2019-12-13 18:20发布

站内问答 / STM32/STM8
11516 101 102
本帖最后由 summarize 于 2013-5-19 14:47 编辑

废话少说，先上stm8s103 IAR库工程代码压缩包。
Schedule-IAR-STM8S103.rar (416.35 KB, 下载次数: 538) 2013-5-19 14:15 上传 点击文件名下载附件

工程是在stm8s103f3单片机上调度通过，已经用消息实现了 UART1_TX模块的共享，即UART1_RX接收到的数据+0x11后再通过UART_TX模块发送回去，同时ADC1 通道3的转换结果也通过UART1_TX模块发送出去.见下图

1.ADC1转换结果每1秒上传一次到PC。测试式给ADC1通道3供的是5V电，所以结果是0x03ff.即1023.

共享时接收到的数据.png (61.3 KB, 下载次数: 0) 下载附件 2013-5-19 14:16 上传

3.支持非抢占式优先级调度，优先级顺序就是创建任务时的顺序，由高到底。其实现思想是，每一个任务运行结束后，都重新回到第一个创建的任务处按顺序查找某个任务是否满足运行条件，所以先创建的任务会先被“发现”其满足运行条件并运行之，核心代码如下

a.任务控制块数据结构
  1. struct SchTcb
  2. {
  3. #if SCH_CFG_Q_EN > 0u
  4.   void          *pData;       //消息指针
  5.   SCH_UINT8 Size;         //消息大小
  6. #endif

  8.   SCH_DLY_TYPE        TimeCounter;  //定时计数器,时基为 "SCH_SYS_TICKS_MS"
  9.   void          (*pTask)();   //任务指针
  10.   struct SchTcb *pNextTCB;    //下一个任务控制块指针
  11. };
复制代码b.调度核心
  1. void SCHTaskSchedStart(void)
  2. {
  3. SCHED_SART:
  4.        
  5.   pCurTCB = pFirstTCB;                        //指向第一个创建的任务,之后按创建时的顺序执行下去

  7.   while (1)                                 
  8.   {
  9.     SCHTimeTick();                            //如果任务Tick满足条件,则将其置于可执行状态

  11.     if (SCH_TASK_RUN == pCurTCB->TimeCounter) //任务处于可执行状态
  12.     {
  13.       pCurTCB->TimeCounter = SCH_TASK_PEND;   //设置为挂起状态,保证任务只执行一次

  15.       pCurTCB->pTask();                       //执行当前任务控制块指向的任务

  17.       goto SCHED_SART;                        //每执行完一个任务,都重新查找一次可执行最高优先级任务
  18.     }

  20.     pCurTCB = pCurTCB->pNextTCB;              //指向下一个任务控制块,查找下个任务是否可执行
  21.   }
  22. }
复制代码“schedule.c”和"schedule.h"已经设置为只读属性，无特殊情况不建议修改，"sch_cfg.h"则为开放给用户的接口，可定义数据类型、调度器节拍和配置是否使用消息。

本人水平有限，欢迎大家测试、指正不足。

友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
101条回答
summarize
2019-12-14 19:46
为了方便大家,接着把UART_TX模块的资源共享相关部分贴出来,分别是UART_RX_ISR,UART接收处理任务,UART发送处理任务和ADC转换结果上传PC任务.

1.UART_RX_ISR: 串口接收中断.
  1. INTERRUPT_HANDLER(UART1_RX_IRQHandler, 18)
  2. {
  3.   /* In order to detect unexpected events during development,
  4.      it is recommended to set a breakpoint on the following instruction.
  5.   */
  6.   static uint8_t s_u8IsrRxBuffer[UART_ISR_RX_BUF_SIZE];
  7.   static uint8_t s_u8IsrRxCounter;

  9.   s_u8IsrRxBuffer[s_u8IsrRxCounter] = UART1_ReceiveData8();

  11.   if (s_u8IsrRxBuffer[s_u8IsrRxCounter] == 0xaa) //for test
  12.   {
  13.     s_u8IsrRxCounter++;
  14.     if (SCHTaskGetQFree(&UartRxTcb) == SCH_Q_FREE)
  15.     {
  16.       SCHTaskQpost(&UartRxTcb,
  17.                    &s_u8IsrRxBuffer[0],
  18.                    s_u8IsrRxCounter);
  19.     }
  20.     else
  21.     {
  22.       //出错处理
  23.     }

  25.     s_u8IsrRxCounter = 0;
  26.   }
  27.   else
  28.   {
  29.     s_u8IsrRxCounter++;
  30.   }

  32.   if (s_u8IsrRxCounter > UART_RX_BUF_SIZE)
  33.   {
  34.     s_u8IsrRxCounter = 0;
  35.     //溢出出错处理
  36.   }

  38.   UART1_ClearFlag(UART1_FLAG_RXNE);
  39. }
复制代码2.UART接收处理任务: 将接收到的数据+0x11后交给UART_TX发送到PC.
  1. void vUartReceiveData(void)
  2. {
  3.   static uint8_t s_u8RxBuffer[UART_RX_BUF_SIZE];
  4.   static uint8_t s_u8RxCounter;

  6.   static uint8_t *pDataBuffer, u8DataSize;
  7.   SCHTaskBegin();

  9.   while (1)
  10.   {
  11.     SCHTaskQpend();           //任务等待接收中断发来消息

  13.     pDataBuffer = (uint8_t *)UartRxTcb.pData;
  14.     u8DataSize  = UartRxTcb.Size;

  16.     if (u8DataSize > UART_RX_BUF_SIZE)
  17.     {
  18.       u8DataSize = UART_RX_BUF_SIZE;
  19.       //出错处理
  20.     }

  22.     for (s_u8RxCounter = 0; s_u8RxCounter < u8DataSize; s_u8RxCounter++)
  23.     {
  24.       s_u8RxBuffer[s_u8RxCounter] = (*pDataBuffer) + 0x11; //copy to s_u8TxBuffer (add 0x11)
  25.       pDataBuffer++;
  26.     }

  28.     //使用如下类似方法便可与其它任务共享UART_TX资源,即任务要使用UART_TX前先检查其队列是否可用,不可用则等待
  29.     for (u8DataSize = 0; u8DataSize < 255; u8DataSize++)  //借用u8DataSize
  30.     {
  31.       if (SCHTaskGetQFree(&UartTxTcb) == SCH_Q_FREE)      //检查UART_TX发送任务队列是否可用
  32.       {
  33.         SCHTaskQpost(&UartTxTcb,
  34.                      &s_u8RxBuffer[0],
  35.                      s_u8RxCounter); //将接收的的数据+0x11后发回去
  36.         break;
  37.       }
  38.       else
  39.       {
  40.         SCHCurTaskDly(1 / SCH_SYS_TICKS_MS);  //delay 1ms
  41.       }
  42.     }

  44.     if (u8DataSize >= 100)
  45.     {
  46.       //出错处理
  47.     }
  48.   }

  50.   SCHTaskEnd();
  51. }
复制代码3.UART发送任务: 将其它任务发来的消息发送到PC.
  1. void vUartSendData(void)
  2. {
  3.   static uint8_t s_u8TxBuffer[UART_TX_BUF_SIZE];
  4.   static uint8_t i;
  5.   static uint8_t *pDataBuffer, u8DataSize;

  7.   SCHTaskBegin();

  9.   while (1)
  10.   {
  11.     SCHTaskQpend();           //任务等待消息

  13.     pDataBuffer = (uint8_t *)UartTxTcb.pData;
  14.     u8DataSize  = UartTxTcb.Size;

  16.     if (u8DataSize > UART_TX_BUF_SIZE)
  17.     {
  18.       u8DataSize = UART_TX_BUF_SIZE;
  19.       //出错处理
  20.     }

  22.     for (i = 0; i < u8DataSize; i++)
  23.     {
  24.       s_u8TxBuffer[i] = *pDataBuffer; //copy to s_u8TxBuffer
  25.       pDataBuffer++;
  26.     }
  27.    
  28.     for (i = 0; i < u8DataSize; i++)
  29.     {
  30.       if (UART1_GetFlagStatus(UART1_FLAG_TXE) == SET)
  31.       {
  32.         UART1_SendData8(s_u8TxBuffer[i]);
  33.         //        UART1_ITConfig(UART1_IT_TXE, ENABLE);
  34.       }

  36.       SCHCurTaskDly(1 / SCH_SYS_TICKS_MS);        //延时发送1个字节所须要的时间
  37.     }
  38.   }

  40.   SCHTaskEnd();
  41. }
复制代码4.ADC转换结果发送任务: 将ADC转换任务传来的相关ADC数据交给UART_TX发送到PC.

void vSendAdcResult(void)
{
  static uint8_t s_u8AdcBuffer[ADC_BUF_SIZE];
  static uint8_t i;
  static uint8_t *pDataBuffer, u8DataSize;

  SCHTaskBegin();

  while (1)
  {
    SCHCurTaskDly(1000 / SCH_SYS_TICKS_MS);   //delay 1000ms

    SCHTaskQpend();           //任务等待消息

    pDataBuffer = (uint8_t *)SendAdcResultTcb.pData;
    u8DataSize  = SendAdcResultTcb.Size;

    if (u8DataSize > ADC_BUF_SIZE)
    {
      u8DataSize = ADC_BUF_SIZE;
      //出错处理
    }

    for (i = 0; i < u8DataSize; i++)
    {
      s_u8AdcBuffer = *pDataBuffer; //copy to s_u8AdcBuffer
      pDataBuffer++;
    }

    //使用如下类似方法便可与其它任务共享UART_TX资源,即任务要使用UART_TX前先检查其队列是否可用,不可用则等待
    for (u8DataSize = 0; u8DataSize < 255; u8DataSize++)  //借用u8DataSize
    {
      if (SCHTaskGetQFree(&UartTxTcb) == SCH_Q_FREE)      //检查UART_TX发送任务队列是否可用
      {
        SCHTaskQpost(&UartTxTcb,
                     &s_u8AdcBuffer[0],
                     i);
        break;
      }
      else
      {
        SCHCurTaskDly(1 / SCH_SYS_TICKS_MS);  //delay 1ms
      }
    }

    if (u8DataSize >= 100)
    {
      //出错处理
    }
  }

  SCHTaskEnd();
}

一周热门 更多>