簡單多工3版補強

主要是補充巨集。因為結構簡化，使用巨集就可以了。
巨集中的SKIP_CYCLE_TIME_US，請自己填入量測值，現在的4.14是Bee目前用的值，在不同應用值皆不同。
Time Constant是用在 Task_Set_Skip_Next中，可以用    Task_Set_Skip_Next(SKIP_US(25), NextFunction);    使工作延時約25us，但受限於掃描率的時間單位。只是不用自己去算次數，閱讀上也方便些。

void Sleep_Next(void (*p_func)(void));
void WakeUp(unsigned char n);
void Task_Set_Next(void (*p_func)(void));
void Task_Delay_Ms_Next(unsigned int n, void (*p_func)(void));
void Task_Set_Skip_Next(unsigned int n, void (*p_func)(void));

//  Task State
#define  TASK_RUNNING 0
#define  TASK_SKIP  1
#define  TASK_DELAY  2
#define  TASK_WAIT  3

// O.S. Macro
#define     SET_TASK(id,p_func)     {TaskFunc[id]=p_func;}
#define     SET_STATE(id,state)     {Task_State[id]=state;}
#define     SET_DELAY(id,n)         {Task_Delay_Count[id]=n;}

// Time Constant
#define     SKIP_CYCLE_TIME_US      (4.14)
#define     SKIP_TIME_CONSTANT      (1.0/SKIP_CYCLE_TIME_US)
#define     SKIP_US(x)              ((int)((x)*SKIP_TIME_CONSTANT))

32位元MCU新時代

Bee換工作後，參與了一個不錯的團隊。Bee主要工作是架設RTOS及連接硬體裝置。
或是依硬體設定產生所要的信號。

其中有一組人員是搞機器學習。Bee所設計的程式在機器上會收取資料。
機器學習就是將這些機器上的IO及Sensor資料在PC上學習。
有時PC要跑上數小時，再將學習結果轉化為簡單矩陣回存到MCU。
MCU依據現在IO及Sensor的數值，再乘上學習矩陣，很快就得到決策結果。

Bee在未接觸機器學習前，對於人工智慧是停留在遊戲等級，是以規則庫為主的系統。
但機器學習的反應速度，實在是出奇的快，規則庫絶非對手。
不過原先的機器學習是在PC上發展出來的，一但MCU進入32位元。
浮點運算力足夠應付，就開始使用這些新的演算法產生新產品。

32位元MCU直接將MCU帶入新時代。一個以數位信號處理及機器學習的新時代。

STM32 DMA應用

在Cortex-M3上所有的週邊皆有DMA，第一次接觸還覺得很怪。因為以往的單晶片並無此類裝置。

最奇怪的，是ADC不用DMA還不行。主因是ADC支援multi-channel，但卻只有一個data register。

若是啟動Scan功能，會一次多個channel掃入，就好像是有多個ADC，只是時間上是分開的。
但結果全部只在一個data register上。
所以問題來了，一但Scan一個channel結束，沒有取走資料，下一個channel會蓋過。

DMA的功能來了，它就是將資料依各channel分開將結果傳到RAM的位置上。
這個功能很方便，可以將RAM當成是ADC的結果register。還可以利用DMA的半滿旗標，做成double buffer。

其他週邊，如通信也有，若是已知的傳輸內容，可以設定DMA一次做完再通知。
然後就用在UART上看看，設定bund rate為1.5Mhz，就照計算上的速率在傳，傳輸利用率是100%。

Bee在一個24Mhz的單晶片上，利用DMA就實現了us級的信號時間控制。
在幾年前Bee遇到這樣的狀況會利用FPGA/CPLD去做。
但有DMA，FPGA就可以省下來了。
而且ADC也可以設定在訊號產生時做取樣，做到接近FPGA的時間控制，而且有12位元解析度。

重點是，單晶片本身的價格不高，已可以做到精確的時間上做取樣的工作。
所以單晶片在ARM Cortex-M系列的加持下，進入了新的應用方式。
接下來，只剩下工程師要如何發揮的問題了。

MCU使用變革：ADC,DAC皆免費時，數位訊號處理(DSP)將大量使用

最近使用STM32F207，發現到MCU使用習慣改變了。

因為ADC及DAC皆為內建，而且連接DMA的設定下，CPU可以去做DSP計算。

這個改變主因是有三項條件到位：
1. ADC及DAC精度提升
2. ADC取樣率提升
3. CPU運算力提升

結果使得DSP運算力到位。

DSP功能免費，可以將原先做信號處理的硬體省下來，變成軟體去做。

意指：外部的運算放大器使用率將下降。

原先的濾波器，可以使用FIR、IIR等以運算程式取代。

 

這對於原先就玩DSP的人也許沒有什麼。

但對於使用8051的工程師來說就不同了，因為大都沒有學過數位信號處理。

使用新的32位元微控器，將使電路大幅簡化。

而且8位元及32位元MCU差價不多，會使用DSP技術會使硬體成本下降。

"數位信號處理"技術會使得控制系統設計變得不同。

且從一開始的系統設計就呈現不一樣的思維。

 

也許還以為8位元MCU可以利用價格低，來取得產品優勢的這個狀況不再。

32位元MCU是較貴，但整體系統設計的元件少，會使總成本下降。

客戶買單是看總成本，而非MCU成本。

所以Cortex-M系列的低價壓制8051這件事將會成真。

 

單晶片工程師想要在這場MCU變革中存活下來，數位訊號處理會變成新的必備技術。

使用簡單多工3版遇到的問題

主要是在使用WakeUp()在中斷程式所遇到的問題。
因為新加的功能會方便很多，所以在中斷程式中Bee用了不少，結果還是發生程序卡死的狀況。
程式碼如下：

void ADC_Start(void)
{
    void ADC_GetValue(void);

    Start_ADC();
    Sleep_Next(ADC_GetValue);
}

中斷程式中為
    WakeUp(ADC_TASK_ID);

結果Run一段時間會卡死。
去看Task_State[ADC_TASK_ID]內容為3，就是TASK_WAIT
但ADC暫存器卻顯示已產生過中斷。

後來將Start_ADC();放在最後一行，問題就沒有了。

發生這樣的問題主要是下指令到產生中斷時間太短，在進入Sleep之前就產生中斷。
然後Sleep_Next才將TASK_WAIT寫入Task_State[ADC_TASK_ID]，從此變成長睡不起。

以後要將會產生中斷的指令寫在函式最尾，以免再發生這樣的問題。

使用Cortex-M3後的事

在前公司，一直摸不到ARM。在技術上這是一個趨勢，早晚會碰到，不如早點用，但苦無機會。
現在用Cortex-M3，不只用，還要很熟。

在設計上有次算錯了效能，結果放了一個FPGA上去。FPGA廠商很高興，因為公司以往最多用到CPLD，遇到會寫的人，自然全力支援。
就有二家全力支援產品開發，都希望有機會採用。
後來Bee就發現MCU也可以做，加上開始熟STM32，結果用中斷程式不用十行就解決了。
對公司是好的，又少了一個零件。但FPGA廠商就沒這樣高興了。

去年底出了Cortex-M4，廠商送來Demo Board，趁空擋試了一下，將FreeRTOS給裝上去，看來還不錯。
不過因為案子皆已開跑，就先放著。
然後，其他也出M4的廠商也來訪，也送來一套。過完農曆年，又一家廠商來也想推。
看來Cortex-M系列真的很拼，MCU市場還真難賺。

簡單多工3版

在STM32上運行時發現，可以不使用DIS_INTR()這個巨集。
因為這個在原子操作下已無需要。
後來就將Task管理，從function pointer改為原子操作下的資料。
結果發現，還可以進一步省下記憶體。

另外Skip方式也改了，改到主程式去做。現在不會跳去Dummy()，檢查完畢就移到下一個工作去。

新增功能有
WakeUp(i)，可以從中斷程式中呼叫，所以可以設定只由中斷叫醒的Task，免去使用全域變數做溝通。
Sleep_Next(p_func)，Task沉睡，設定醒來時執行函式，只能由WakeUp(i)叫醒。

新版本程式如下：
#include "mt.h"
#define TASK_NUM    4
extern void SimInit(void);
extern void Task1(void);
extern void Task2(void);
extern void Task3(void);
extern void OS_ENTER_CRITICAL(void);
extern void OS_EXIT_CRITICAL(void);

#define INIT_DEVICE()        SimInit()
#define DIS_INTR()            OS_ENTER_CRITICAL()
#define ENA_INTR()            OS_EXIT_CRITICAL()
// O.S function declaim
void Dummy(void);
unsigned char FuncID;
volatile unsigned char Task_State[TASK_NUM];
unsigned short Task_Delay_Count[TASK_NUM];
void (*TaskFunc[TASK_NUM])(void);

// O.S functions
void InitSystem(void)
{
    unsigned char i;

    FuncID = 0;
    for ( i= 0; i< TASK_NUM ; i++)
    {
        Task_State[i] = TASK_RUNNING;
        Task_Delay_Count[i] = 0;
        TaskFunc[i] = Dummy;
    }
    TaskFunc[1] = Task1;
    TaskFunc[2] = Task2;
    TaskFunc[3] = Task3;
}

void Sleep_Next(void (*p_func)(void))
{
    TaskFunc[FuncID] = p_func;
    Task_State[FuncID] = TASK_WAIT;
}

void WakeUp(unsigned char n)
{
    Task_State[n] = TASK_RUNNING;
}

void Task_Set_Next(void (*p_func)(void))
{
    TaskFunc[FuncID]=p_func;
}

void Dummy(void)
{
    Sleep_Next(Dummy);
}

void Task_Delay_Ms_Next(unsigned int n, void (*p_func)(void))
{
    if (! n ) n = 1;
    TaskFunc[FuncID] = p_func;
    Task_Delay_Count[FuncID] = n;
    Task_State[FuncID] = TASK_DELAY;
}

void Task_Set_Skip_Next(unsigned int n, void (*p_func)(void))
{
    if (! n ) n = 1;
    TaskFunc[FuncID] = p_func;
    Task_Delay_Count[FuncID] = n;
    Task_State[FuncID] = TASK_SKIP;
}

// O.S functions end

// main loop
void main(void)
{
    INIT_DEVICE();
    InitSystem();
    while (1)
    {
        switch (Task_State[FuncID])
        {
        case TASK_RUNNING :
            TaskFunc[FuncID]();
            break;
        case TASK_SKIP :
            if ( Task_Delay_Count[FuncID] )
            {
                Task_Delay_Count[FuncID]--;
                if (! Task_Delay_Count[FuncID]) WakeUp(FuncID);
            }
            break;
        default:
            break;
        }
        if ( ++FuncID >= TASK_NUM ) FuncID = 0;
    }
}

void TimeTick(void)  // This is timer interrupt
{
    unsigned char i;

    for ( i=0; i< TASK_NUM; i++)
    {
        if ( Task_State[i] == TASK_DELAY )
        {
            if ( Task_Delay_Count[i] )
            {
                Task_Delay_Count[i]--;
                if (! Task_Delay_Count[i]) WakeUp(i);
            }
        }
    }
}

// Begin User Tasks

mt.h內容為
void Sleep_Next(void (*p_func)(void));
void WakeUp(unsigned char n);
void Task_Set_Next(void (*p_func)(void));
void Task_Delay_Ms_Next(unsigned int n, void (*p_func)(void));
void Task_Set_Skip_Next(unsigned int n, void (*p_func)(void));

//  Task State
#define        TASK_RUNNING    0
#define        TASK_SKIP          1
#define        TASK_DELAY        2
#define        TASK_WAIT          3

實驗程式如下：
#include < stdio.h >
#include "mt.h"
void Task1(void)
{
    printf("G");
    Task_Delay_Ms_Next(10,Task1);
}

void Task2(void)
{
    printf("z");
    Task_Delay_Ms_Next(1,Task2);
}

void Task3(void)
{
    printf(".");
    Task_Set_Skip_Next(60000,Task3);
}

Windows模擬結果