嵌入式

設(shè)計(jì)模式

觀察者模式

主題對(duì)象提供統(tǒng)一的注冊(cè)接口，以及注冊(cè)函數(shù) 。由觀察者本身實(shí)例化observer_intf 接口，然后使用注冊(cè)函數(shù)，添加到對(duì)應(yīng)的主題列表中，主題狀態(tài)發(fā)生改變，依次通知列表中的所有對(duì)象。

 struct observer_ops
 {
     void*(handle)(uint8_t evt);  
 };
 struct observer_intf
 {
     struct observer_intf* next;
     const char* name;
     void* condition;
     const struct observer_ops *ops;
 }
intobserver_register(structtopical*top,structobserver_intf*observer);

當(dāng)主題狀態(tài)發(fā)生改變，將通知到所有觀察者，觀察者本身也可以設(shè)置條件，是否選擇接收通知。

 struct observer_intf observer_list;
     
 void XXXX_topical_evt(uint8_t evt)
{
      struct observer_intf* cur_observer = observer_list.next;
      uint8_t* condition = NULL;
      while(cur_observer != NULL)
      {
          condition = (uint8_t*）cur_observer->condition;
          if(NULL == condition || (condition && *condition)）
          {
              if(cur_observer->ops->handle){
                  cur_observer->ops->handle(evt);
              }       
          }
          cur_observer = cur_observer->next;
      }
 }

• 設(shè)備功耗分布

• 設(shè)備喚醒方式當(dāng)系統(tǒng)某個(gè)定時(shí)事件到來(lái)時(shí)，系統(tǒng)被主動(dòng)喚醒處理事件系統(tǒng)處于睡眠，被外部事件喚醒，如串口接收到一包數(shù)據(jù)，傳感器檢測(cè)到變化，通過(guò)引腳通知芯片
  • 被動(dòng)喚醒
  • 主動(dòng)喚醒
• 系統(tǒng)允許睡眠的條件
  • 外設(shè)無(wú)正在收發(fā)的數(shù)據(jù)
  • 緩存無(wú)需要處理的數(shù)據(jù)
  • 應(yīng)用層狀態(tài)處于空閑（無(wú)需要處理的事件）
• 基于觀察者模式的PM框架實(shí)現(xiàn)

PM組件提供的接口：

struct pm
{
    struct pm* next;
    const char* name;
   void(*init)(void);
    void(*deinit(void);
    void* condition;
};
static struct pm pm_list;
static uint8_t pm_num;
static uint8_t pm_status;
         
int pm_register(const struct pm* pm , const char* name)
{
     struct pm* cur_pm =  &pm_list;
     while(cur_pm->next)
     {
         cur_pm = cur_pm->next;
     }
     cur_pm->next = pm;
     pm->next = NULL;
     pm->name = name;
     pm_num++;
}
 
void pm_loop(void)
{
    uint32_t pm_condition = 0;
    struct pm* cur_pm =  pm_list.next;
    static uint8_t cnt;
    
    /*check all condition*/
    while(cur_pm)
    {
        if(cur_pm->condition){
         pm_condition |=  *((uint32_t*)(cur_pm->condition));
        }
        cur_pm = cur_pm->next;
    }
    if(pm_condition == 0)
    {
      cnt++;
        if(cnt>=5)
        {
            pm_status = READY_SLEEP;
        }
    }
    else
    {
        cnt = 0;
    }
    if( pm_status == READY_SLEEP)
    {
         cur_pm =  pm_list.next;
         while(cur_pm)
         {
             if(cur_pm->deinit){
                cur_pm->deinit();
             }
             cur_pm = cur_pm->next;
         }
        pm_status = SLEEP;
        ENTER_SLEEP_MODE();
    }   
    /*sleep--->wakeup*/
    if(pm_status == SLEEP)
    {
         pm_status = NORMAL;
         cur_pm =  pm_list.next;
         while(cur_pm)
         {
             if(cur_pm->init){
                cur_pm->init();
             }
             cur_pm = cur_pm->next;
         }
    }
}

外設(shè)使用PM接口：

struct uart_dev
{
 ...
 struct pm pm;
    uint32_t pm_condition; 
};
struct uart_dev uart1;
 
void hal_uart1_init(void);
void hal_uart1_deinit(void);
    
void uart_init(void)
{
    uart1.pm.init =  hal_uart1_init;
    uart1.pm.deinit =  hal_uart1_deinit;
    uart1.pm.condition = &uart1.pm_condition;
    pm_register(&uart1.pm , "uart1");
}
/*接下來(lái)串口驅(qū)動(dòng)檢查緩存 ， 發(fā)送 ， 接收是否空閑或者忙碌 ， 給uart1.pm_condition賦值*/

• PM 電源管理可以單獨(dú)形成模塊，當(dāng)功耗外設(shè)增加時(shí)，只需實(shí)現(xiàn)接口，注冊(cè)即可
• 通過(guò)定義段導(dǎo)出操作，可以更加簡(jiǎn)化應(yīng)用層或外設(shè)的注冊(cè)邏輯
• 方便調(diào)試，可以很方便打印出系統(tǒng)當(dāng)前為滿足睡眠條件的模塊
• 通過(guò)條件字段劃分，應(yīng)該可以實(shí)現(xiàn)系統(tǒng)部分睡眠

職責(zé)鏈模式

在存在系統(tǒng)的情況下，此類邏輯可以很容易的用阻塞延時(shí)來(lái)實(shí)現(xiàn)，實(shí)現(xiàn)如下：

void process_task(void)
{
    task1_process();
    msleep(1000);
    
    task2_process();
    mq_recv(&param , 1000);
    
    task3_process();
    while(mq_recv(¶m , 1000) != OK)
    {
        if(retry)
        {
             task3_process();
             --try;
        }
    }
}

在裸機(jī)的情況下，為了保證系統(tǒng)的實(shí)時(shí)性，無(wú)法使用阻塞延時(shí)，一般使用定時(shí)事件配合狀態(tài)機(jī)來(lái)實(shí)現(xiàn)：

void process_task(void)
{
     switch(task_state)
     {
         case task1:
             task1_process();
             set_timeout(1000);break;
         case task2:
             task1_process();
             set_timeout(1000);break;
         case task3:
             task1_process();
             set_timeout(1000)break;
         default:break;
     }
}
/*定時(shí)器超時(shí)回調(diào)*/
void timeout_cb(void)
{
    if(task_state == task1)
    {
        task_state = task2;
        process_task();
    }
    else  //task2 and task3
    {
        if(retry)
        {
            retry--;
             process_task();
        }
    }
}
/*任務(wù)的應(yīng)答回調(diào)*/
void task_ans_cb(void* param)
{
    if(task==task2)
    {
        task_state = task3;
        process_task();
    }
}

• 任務(wù)按順序執(zhí)行，只有當(dāng)前任務(wù)執(zhí)行完了(有結(jié)論，成功或者失敗)才允許執(zhí)行下一個(gè)任務(wù)
• 前一個(gè)任務(wù)的執(zhí)行結(jié)果會(huì)影響到下一個(gè)任務(wù)的執(zhí)行情況
• 任務(wù)有一些特性，如超時(shí)時(shí)間，延時(shí)時(shí)間，重試次數(shù)

node數(shù)據(jù)結(jié)構(gòu)定義：

/*shadow node api type for req_chain src*/
typedef struct shadow_resp_chain_node
{
 uint16_t timeout;
 uint16_t duration;
 uint8_t init_retry;
 uint8_t param_type;
 uint16_t retry;
 /*used in mpool*/
   struct shadow_resp_chain_node* mp_prev;
 struct shadow_resp_chain_node* mp_next;
 
    /*used resp_chain*/
 struct shadow_resp_chain_node* next;
 
 node_resp_handle_fp handle;
 void* param;
}shadow_resp_chain_node_t;

職責(zé)鏈數(shù)據(jù)結(jié)構(gòu)定義：

typedef struct resp_chain
{
   bool enable;               //enble == true 責(zé)任鏈啟動(dòng) 
 bool  is_ans;              //收到應(yīng)答，與void* param 共同組成應(yīng)答信號(hào)
 
 uint8_t state;            
 const char* name;
 void* param;
 TimerEvent_t timer;
 bool timer_is_running;
 shadow_resp_chain_node_t node;        //節(jié)點(diǎn)鏈
 void(*resp_done)(void* result);       //執(zhí)行結(jié)果回調(diào)
}resp_chain_t;

職責(zé)鏈初始化：

void resp_chain_init(resp_chain_t* chain ,  const char* name , 
                                            void(*callback)(void* result))                   
{
   RESP_ASSERT(chain);
 /*only init one time*/
 resp_chain_mpool_init();
 
   chain->enable = false;
 chain->is_ans = false;
 chain->resp_done = callback;
 chain->name = name;
 
 chain->state = RESP_STATUS_IDLE;
 chain->node.next = NULL;
 chain->param = NULL;
 
 TimerInit(&chain->timer,NULL);
}

職責(zé)鏈添加節(jié)點(diǎn):

int resp_chain_node_add(resp_chain_t* chain , 
                        node_resp_handle_fp handle , void* param)
{
   RESP_ASSERT(chain);
 BoardDisableIrq();  
 shadow_resp_chain_node_t* node = chain_node_malloc();
 if(node == NULL)
 {
    BoardEnableIrq();
    RESP_LOG("node malloc error ,no free node");
  return -2;
 }
 /*初始化節(jié)點(diǎn)，并加入責(zé)任鏈*/
 shadow_resp_chain_node_t* l = &chain->node;
 while(l->next != NULL)
 {
  l = l->next;
 }
 l->next = node;
 node->next = NULL; 
 node->handle = handle;
 node->param = param;
 node->timeout = RESP_CHIAN_NODE_DEFAULT_TIMEOUT;
 node->duration = RESP_CHIAN_NODE_DEFAULT_DURATION;
 node->init_retry = RESP_CHIAN_NODE_DEFAULT_RETRY;
 node->retry = (node->init_retry == 0)? 0 :(node->init_retry-1);
 BoardEnableIrq();
 return 0;
}

職責(zé)鏈的啟動(dòng)：

void resp_chain_start(resp_chain_t* chain)
{
   RESP_ASSERT(chain);
 chain->enable = true;
}

職責(zé)鏈的應(yīng)答:

void resp_chain_set_ans(resp_chain_t* chain , void* param)
{
 RESP_ASSERT(chain);
   if(chain->enable)
 {
  chain->is_ans = true;
  if(param != NULL)
     chain->param = param;
  else
  {
   chain->param = "NO PARAM";
  }
 }
}

職責(zé)鏈的運(yùn)行：

int resp_chain_run(resp_chain_t* chain)
{ 
 RESP_ASSERT(chain);
 if(chain->enable)
 {
    shadow_resp_chain_node_t* cur_node = chain->node.next;
    /*maybe ans occur in handle,so cannot change state direct when ans comming*/
    if(chain->is_ans)
  {
   chain->is_ans = false;
   chain->state = RESP_STATUS_ANS;
  }  
   
  switch(chain->state)
  {
   case RESP_STATUS_IDLE:
   {
    if(cur_node)
    {
       uint16_t retry = cur_node->init_retry;
     if(cur_node->handle)
     {
        cur_node->param_type = RESP_PARAM_INPUT;
      chain->state = cur_node->handle((resp_chain_node_t*)cur_node                                                               ,cur_node->param);
     }
     else
     {
         RESP_LOG("node handle is null ,goto next node");
      chain->state = RESP_STATUS_OK;
     }
     if(retry != cur_node->init_retry)
     {
      cur_node->retry = cur_node->init_retry>0?(cur_node-                                                      >init_retry-1):0;                       
     }
    }
    else
    {
       if(chain->resp_done)
     {
      chain->resp_done((void*)RESP_RESULT_OK);
     }
     chain->enable = 0;
     chain->state = RESP_STATUS_IDLE;
     TimerStop(&chain->timer);
     chain->timer_is_running  = false;
    }
    break;
   }
   case RESP_STATUS_DELAY:
   {
    if(chain->timer_is_running == false)
    {
       chain->timer_is_running  = true;
     TimerSetValueStart(&chain->timer , cur_node->duration);
    }
    if(TimerGetFlag(&chain->timer) == true)
    {
     chain->state = RESP_STATUS_OK;
     chain->timer_is_running  = false;
    }
     break; 
   }
   case RESP_STATUS_BUSY:
   {
      /*waiting for ans or timeout*/
      if(chain->timer_is_running == false)
    {
       chain->timer_is_running  = true;
     TimerSetValueStart(&chain->timer , cur_node->timeout);
    }
    if(TimerGetFlag(&chain->timer) == true)
    {
     chain->state = RESP_STATUS_TIMEOUT;
     chain->timer_is_running  = false;
    }
    break;
      }
   case RESP_STATUS_ANS:
     {
      /*already got the ans,put the param back to the request handle*/
      TimerStop(&chain->timer);
    chain->timer_is_running  = false;
    if(cur_node->handle)
    {
     cur_node->param_type = RESP_PARAM_ANS;
     chain->state = cur_node->handle((resp_chain_node_t*)cur_node ,                                                                 chain->param);
    }
    else
    {
     RESP_LOG("node handle is null ,goto next node");
     chain->state = RESP_STATUS_OK;
    }
    break;
   }
   case RESP_STATUS_TIMEOUT:
   {
    if(cur_node->retry)
    {
     cur_node->retry--; 
     /*retry to request until cnt is 0*/
     chain->state = RESP_STATUS_IDLE;
    }
    else
    {
     chain->state = RESP_STATUS_ERROR;
    }
    break;
   }
   case RESP_STATUS_ERROR:
   {
      if(chain->resp_done)
    {
       chain->resp_done((void*)RESP_RESULT_ERROR);
    }
    chain->enable = 0;
    chain->state = RESP_STATUS_IDLE;
    TimerStop(&chain->timer);
    chain->timer_is_running  = false;
    cur_node->retry = cur_node->init_retry>0?(cur_node->init_retry-1):0;
    chain_node_free_all(chain);
    break;
   }
   case RESP_STATUS_OK:
   {
      /*get the next node*/
      cur_node->retry = cur_node->init_retry>0?(cur_node->init_retry-1):0;
    chain_node_free(cur_node);
    chain->node.next = chain->node.next->next;
    chain->state = RESP_STATUS_IDLE;
    break;
   }
      default:
     break;
  }
 }
 return chain->enable;
}

測(cè)試用例:

• 定義并初始化責(zé)任鏈

void chain_test_init(void)
{
    resp_chain_init(&test_req_chain , "test request" , test_req_callback);
}

• 定義運(yùn)行函數(shù)，在主循環(huán)中調(diào)用

void chain_test_run(void)
{
    resp_chain_run(&test_req_chain);
}

• 測(cè)試節(jié)點(diǎn)添加并啟動(dòng)觸發(fā)函數(shù)

void chain_test_tigger(void)
{
    resp_chain_node_add(&test_req_chain ,  node1_req ,NULL);
    resp_chain_node_add(&test_req_chain ,  node2_req,NULL);
    resp_chain_node_add(&test_req_chain ,  node3_req,NULL);
    resp_chain_start(&test_req_chain);
}

• 分別實(shí)現(xiàn)節(jié)點(diǎn)請(qǐng)求函數(shù)

 /*延時(shí)1s 后執(zhí)行下一個(gè)節(jié)點(diǎn)*/
 int node1_req(resp_chain_node_t* cfg, void* param)
{
     cfg->duration = 1000;
     RESP_LOG("node1 send direct request: delay :%d ms" , cfg->duration);
     return RESP_STATUS_DELAY;
 }
 /*超時(shí)時(shí)間1S ， 重傳次數(shù)5次*/ 
 int node2_req(resp_chain_node_t* cfg , void* param)
{
     static uint8_t cnt;
     if(param == NULL)
     {
         cfg->init_retry = 5;
         cfg->timeout  = 1000;
         RESP_LOG("node2 send request max retry:%d , waiting for ans...");
         return RESP_STATUS_BUSY;
     }
     RESP_LOG("node2 get ans: %d",(int)param);
     return RESP_STATUS_OK;
 }
 /*非異步請(qǐng)求*/  
 int node3_req(resp_chain_node_t* cfg , void* param)
{
     RESP_LOG("node4 send direct request");
     return RESP_STATUS_OK;
 }
 
 void ans_callback(void* param)
{
     resp_chain_set_ans(&test_req_chain , param);
 }

• 實(shí)現(xiàn)了裸機(jī)處理 順序延時(shí)任務(wù)
• 較大程度的簡(jiǎn)化了應(yīng)用程的實(shí)現(xiàn)，用戶只需要實(shí)現(xiàn)響應(yīng)的處理函數(shù) ， 調(diào)用接口添加，即可按時(shí)間要求執(zhí)行
• 參數(shù)為空，表明為請(qǐng)求 ，否則為應(yīng)答。（在某些場(chǎng)合，請(qǐng)求可能也帶參數(shù)，如接下來(lái)所說(shuō)的LAP協(xié)議，此時(shí)需要通過(guò)判斷參數(shù)的類型）