コード例 #1
0
ファイル: tn_dqueue.c プロジェクト: ADTL/AFGUI
//----------------------------------------------------------------------------
int tn_queue_delete(TN_DQUE * dque)
{
   TN_INTSAVE_DATA
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(dque == NULL)
      return TERR_WRONG_PARAM;
   if(dque->id_dque != TN_ID_DATAQUEUE)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   while(!is_queue_empty(&(dque->wait_send_list)))
   {
      tn_disable_interrupt();

     //--- delete from sem wait queue

      que = queue_remove_head(&(dque->wait_send_list));
      task = get_task_by_tsk_queue(que);
      if(task_wait_complete(task))
      {
         task->task_wait_rc = TERR_DLT;
         tn_enable_interrupt();
         tn_switch_context();
      }
   }

   while(!is_queue_empty(&(dque->wait_receive_list)))
   {
      tn_disable_interrupt();

     //--- delete from sem wait queue

      que = queue_remove_head(&(dque->wait_receive_list));
      task = get_task_by_tsk_queue(que);
      if(task_wait_complete(task))
      {
         task->task_wait_rc = TERR_DLT;
         tn_enable_interrupt();
         tn_switch_context();
      }
   }

   if(tn_chk_irq_disabled() == 0) // int enable
      tn_disable_interrupt();

   dque->id_dque = 0; // Data queue not exists now

   tn_enable_interrupt();

   return TERR_NO_ERR;

}
コード例 #2
0
ファイル: dq_fnc_send.c プロジェクト: Sav0966/qmlab-pic24
/**
 *
 * @param dque
 * @param data_ptr
 * @param timeout
 *
 * @return TN_RETVAL
 */
TN_RETVAL tnnc_queue_send (TN_DQUE_S *dque, void *data_ptr, TN_TIMEOUT timeout)
{
    TN_UWORD      tn_save_status_reg TN_UNUSED;     /* for SR save */
    TN_RETVAL           rc;
    CDLL_QUEUE_S *que;
    TN_TCB_S     *task;

/*
    Not check parameter error

    if (dque == TN_NULL || timeout == 0)
        return  TERR_WRONG_PARAM;
*/

    if (dque->id_dque != TN_ID_DATAQUEUE)
        return TERR_NOEXS;

    if (tn_is_non_task_context())
    {
        return TERR_WCONTEXT;
    }

    tn_disable_interrupt();

    if (!is_queue_empty(&(dque->wait_receive_list)))
    {
        que  = queue_remove_head(&(dque->wait_receive_list));
        task = get_task_by_tsk_queue(que);

        task->data_elem = data_ptr;

        if (task_wait_complete(task, TN_FALSE))
        {
            tn_enable_interrupt();
            tn_switch_context();
            return  TERR_NO_ERR;
        }
        rc = TERR_NO_ERR;
    }
    else
    {
        rc = dque_fifo_write(dque,data_ptr);

        if (rc != TERR_NO_ERR)
        {
            tn_curr_run_task->data_elem = data_ptr;
            task_curr_to_wait_action(&(dque->wait_send_list), TSK_WAIT_REASON_DQUE_WSEND, timeout);

            tn_enable_interrupt();
            tn_switch_context();
            return tn_curr_run_task->task_wait_rc;
        }
    }

    tn_enable_interrupt();
    return rc;
}
コード例 #3
0
ファイル: tn_dqueue.c プロジェクト: ADTL/AFGUI
//----------------------------------------------------------------------------
int tn_queue_send(TN_DQUE * dque, void * data_ptr, unsigned long timeout)
{
   TN_INTSAVE_DATA
   int rc;
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(dque == NULL || timeout == 0)
      return  TERR_WRONG_PARAM;
   if(dque->id_dque != TN_ID_DATAQUEUE)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

  //-- there are task(s) in the data queue's wait_receive list

   if(!is_queue_empty(&(dque->wait_receive_list)))
   {
      que  = queue_remove_head(&(dque->wait_receive_list));
      task = get_task_by_tsk_queue(que);

      task->data_elem = data_ptr;

      if(task_wait_complete(task))
      {
         tn_enable_interrupt();
         tn_switch_context();
         return  TERR_NO_ERR;
      }
      rc = TERR_NO_ERR;
   }
   else  //-- the data queue's  wait_receive list is empty
   {
      rc = dque_fifo_write(dque,data_ptr);
      if(rc != TERR_NO_ERR)  //-- No free entries in the data queue
      {
         tn_curr_run_task->data_elem = data_ptr;  //-- Store data_ptr
         task_curr_to_wait_action(&(dque->wait_send_list),
                                         TSK_WAIT_REASON_DQUE_WSEND, timeout);
         tn_enable_interrupt();
         tn_switch_context();
         return tn_curr_run_task->task_wait_rc;
      }
   }

   tn_enable_interrupt();
   return rc;
}
コード例 #4
0
ファイル: ts_fnc_slep.c プロジェクト: Sav0966/qmlab-pic24
/**
 *
 * @param timeout
 *
 * @return TN_RETVAL
 */
TN_RETVAL tnnc_task_sleep (TN_TIMEOUT timeout)
{
    TN_UWORD tn_save_status_reg TN_UNUSED;     /* for SR save */
    TN_RETVAL rc;
/*
    Not check parameter error

    if (timeout == 0)
        return  TERR_WRONG_PARAM;
*/
    if (tn_is_non_task_context())
    {
        return TERR_WCONTEXT;
    }

    tn_disable_interrupt();

    if (tn_curr_run_task->wakeup_count > 0)
    {
        tn_curr_run_task->wakeup_count--;
        rc = TERR_NO_ERR;
    }
    else
    {
        task_curr_to_wait_action(TN_NULL, TSK_WAIT_REASON_SLEEP, timeout);
        tn_enable_interrupt();
        tn_switch_context();
        return  TERR_NO_ERR;
    }

    tn_enable_interrupt();
    return rc;
}
コード例 #5
0
ファイル: tn_tasks.c プロジェクト: KWinter291/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_task_sleep(unsigned long timeout)
{
   TN_INTSAVE_DATA
   int rc;

   if(timeout == 0)
      return  TERR_WRONG_PARAM;

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(tn_curr_run_task->wakeup_count > 0)
   {
      tn_curr_run_task->wakeup_count--;
      rc = TERR_NO_ERR;
   }
   else
   {
      task_curr_to_wait_action(NULL, TSK_WAIT_REASON_SLEEP, timeout);
      tn_enable_interrupt();
      tn_switch_context();
      return  TERR_NO_ERR;
   }

   tn_enable_interrupt();
   return rc;
}
コード例 #6
0
ファイル: sm_fce_asqu.c プロジェクト: Sav0966/qmlab-pic24
/**
 *
 * @param sem
 * @param timeout
 *
 * @return TN_RETVAL
 */
TN_RETVAL tnec_sem_acquire (TN_SEM_S *sem, TN_TIMEOUT timeout)
{
    TN_UWORD tn_save_status_reg TN_UNUSED;     /* for SR save */
    TN_RETVAL      rc;

    if (sem == TN_NULL || timeout == 0 || sem->max_count == 0)
        return  TERR_WRONG_PARAM;

    if (sem->id_sem != TN_ID_SEMAPHORE)
        return TERR_NOEXS;

    if (tn_is_non_task_context())
    {
        return TERR_WCONTEXT;
    }

    tn_disable_interrupt();

    if (sem->count >= 1)
    {
        sem->count--;
        rc = TERR_NO_ERR;
    }
    else
    {
        task_curr_to_wait_action(&(sem->wait_queue),TSK_WAIT_REASON_SEM,timeout);
        tn_enable_interrupt();
        tn_switch_context();
        return tn_curr_run_task->task_wait_rc;
    }

    tn_enable_interrupt();
    return rc;
}
コード例 #7
0
//----------------------------------------------------------------------------
int tn_event_wait(TN_EVENT * evf,
                    unsigned int wait_pattern,
                    int wait_mode,
                    unsigned int * p_flags_pattern,
                    unsigned int timeout)
{
   TN_INTSAVE_DATA
   int rc; //-- return code
   int fCond;

   if(evf == NULL || wait_pattern == 0 ||
     p_flags_pattern == NULL || timeout == 0)
      return TERR_WRONG_PARAM;
   if(evf->id_event != TN_ID_EVENT)
      return TERR_NOEXS;

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   //-- If event attr is TN_EVENT_ATTR_SINGLE and another task already
   //-- in event wait queue - return ERROR without checking release condition
   if((evf->attr & TN_EVENT_ATTR_SINGLE) && !is_queue_empty(&(evf->wait_queue)))
   {
      rc = TERR_ILUSE;
   }
   else
   {
       //-- Check release condition
      if(wait_mode & TN_EVENT_WCOND_OR) // any setted bit is enough for release condition
         fCond = ((evf->pattern & wait_pattern) != 0);
      else // TN_EVENT_WCOND_AND is default mode
         fCond = ((evf->pattern & wait_pattern) == wait_pattern);

      if(fCond)
      {
         *p_flags_pattern = evf->pattern;
         if(evf->attr & TN_EVENT_ATTR_CLR)
            evf->pattern = 0;
          rc = TERR_NO_ERR;
      }
      else
      {
         tn_curr_run_task->ewait_mode = wait_mode;
         tn_curr_run_task->ewait_pattern = wait_pattern;
         task_curr_to_wait_action(&(evf->wait_queue),TSK_WAIT_REASON_EVENT,timeout);
         tn_enable_interrupt();
         tn_switch_context();
         if(tn_curr_run_task->task_wait_rc == TERR_NO_ERR)
            *p_flags_pattern = tn_curr_run_task->ewait_pattern;
         return tn_curr_run_task->task_wait_rc;
      }
   }
   tn_enable_interrupt();
   return rc;
}
コード例 #8
0
ファイル: tn_mutex.c プロジェクト: 0x00f/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_mutex_delete(TN_MUTEX * mutex)
{
   TN_INTSAVE_DATA

   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(mutex == NULL)
      return TERR_WRONG_PARAM;
   if(mutex->id_mutex != TN_ID_MUTEX)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   if(tn_curr_run_task != mutex->holder)
   {
      tn_enable_interrupt();
      return TERR_ILUSE;
   }

   //-- Remove all tasks(if any) from mutex's wait queue

   while(!is_queue_empty(&(mutex->wait_queue)))
   {
      tn_disable_interrupt();

      que  = queue_remove_head(&(mutex->wait_queue));
      task = get_task_by_tsk_queue(que);

    //-- If the task in system's blocked list, remove it

      if(task_wait_complete(task))
      {
         task->task_wait_rc = TERR_DLT;
         tn_enable_interrupt();
         tn_switch_context();
      }
   }

   if(tn_chk_irq_disabled() == 0)
      tn_disable_interrupt();

   if(mutex->holder != NULL)  //-- If the mutex is locked
   {
      do_unlock_mutex(mutex);
      queue_reset(&(mutex->mutex_queue));
   }
   mutex->id_mutex = 0; // Mutex not exists now

   tn_enable_interrupt();

   return TERR_NO_ERR;
}
コード例 #9
0
ファイル: tn.c プロジェクト: ADTL/AFGUI
//----------------------------------------------------------------------------
static void tn_timer_task_func(void * par)
{
   TN_INTSAVE_DATA
   volatile TN_TCB * task;
   volatile CDLL_QUEUE * curr_que;

   //-- User application init - user's objects initial (tasks etc.) creation

   tn_app_init();

   //-- Enable interrupt here ( include tick int)

   tn_cpu_int_enable();

   //-------------------------------------------------------------------------

   for(;;)
   {

     //------------ OS timer tick -------------------------------------

      tn_disable_interrupt();

      curr_que = tn_wait_timeout_list.next;
      while(curr_que != &tn_wait_timeout_list)
      {
         task = get_task_by_timer_queque((CDLL_QUEUE*)curr_que);
         if(task->tick_count != TN_WAIT_INFINITE)
         {
            if(task->tick_count > 0)
            {
               task->tick_count--;
               if(task->tick_count == 0) //-- Time out expiried
               {
                  queue_remove_entry(&(((TN_TCB*)task)->task_queue));
                  task_wait_complete((TN_TCB*)task);
                  task->task_wait_rc = TERR_TIMEOUT;
               }
            }
         }

         curr_que = curr_que->next;
      }

      task_curr_to_wait_action(NULL,
                               TSK_WAIT_REASON_SLEEP,
                               TN_WAIT_INFINITE);
      tn_enable_interrupt();

      tn_switch_context();
   }
}
コード例 #10
0
ファイル: sm_fnc_sign.c プロジェクト: Sav0966/qmlab-pic24
/**
 *
 * @param sem
 *
 * @return TN_RETVAL
 */
TN_RETVAL tnnc_sem_signal (TN_SEM_S *sem)
{
    TN_UWORD     tn_save_status_reg TN_UNUSED;     /* for SR save */
    TN_RETVAL    rc;
    CDLL_QUEUE_S *que;
    TN_TCB_S     *task;
/*
    Not check parameter error

    if (sem == TN_NULL || sem->max_count == 0)
        return  TERR_WRONG_PARAM;
*/

    if (sem->id_sem != TN_ID_SEMAPHORE)
        return TERR_NOEXS;

    if (tn_is_non_task_context())
    {
        return TERR_WCONTEXT;
    }

    tn_disable_interrupt();

    if (!(is_queue_empty(&(sem->wait_queue))))
    {
        que  = queue_remove_head(&(sem->wait_queue));
        task = get_task_by_tsk_queue(que);

        if (task_wait_complete(task, TN_FALSE))
        {
            tn_enable_interrupt();
            tn_switch_context();
            return TERR_NO_ERR;
        }
        rc = TERR_NO_ERR;
    }
    else
    {
        if (sem->count < sem->max_count)
        {
            sem->count++;
            rc = TERR_NO_ERR;
        }
        else
        {
            rc = TERR_OVERFLOW;
        }
    }

    tn_enable_interrupt();
    return rc;
}
コード例 #11
0
ファイル: tn_sem.c プロジェクト: 0x00f/TNKernel-PIC32
//----------------------------------------------------------------------------
//  Release Semaphore Resource
//----------------------------------------------------------------------------
int tn_sem_signal(TN_SEM * sem)
{
   TN_INTSAVE_DATA
   int rc; //-- return code
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(sem == NULL)
      return  TERR_WRONG_PARAM;
   if(sem->max_count == 0)
      return  TERR_WRONG_PARAM;
   if(sem->id_sem != TN_ID_SEMAPHORE)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(!(is_queue_empty(&(sem->wait_queue))))
   {
      //--- delete from the sem wait queue

      que = queue_remove_head(&(sem->wait_queue));
      task = get_task_by_tsk_queue(que);

      if(task_wait_complete(task))
      {
         tn_enable_interrupt();
         tn_switch_context();

         return TERR_NO_ERR;
      }
      rc = TERR_NO_ERR;
   }
   else
   {
      if(sem->count < sem->max_count)
      {
         sem->count++;
         rc = TERR_NO_ERR;
      }
      else
         rc = TERR_OVERFLOW;
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #12
0
ファイル: tn_tasks.c プロジェクト: KWinter291/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_task_wakeup(TN_TCB * task)
{
   TN_INTSAVE_DATA
   int rc;

#if TN_CHECK_PARAM
   if(task == NULL)
      return  TERR_WRONG_PARAM;
   if(task->id_task != TN_ID_TASK)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(task->task_state == TSK_STATE_DORMANT)
   {
      rc = TERR_WCONTEXT;
   }
   else
   {
      if((task->task_state & TSK_STATE_WAIT) &&
                 task->task_wait_reason == TSK_WAIT_REASON_SLEEP)
      {
         if(task_wait_complete(task))
         {
            tn_enable_interrupt();
            tn_switch_context();
            return TERR_NO_ERR;
         }
         rc = TERR_NO_ERR;
      }
      else
      {      // v.2.7 - Thanks to Eugene Scopal
         //-- Check for 0 - case max wakeup_count value is 1  
         if(task->wakeup_count == 0) //-- if here - the task is
         {                           //-- not in the SLEEP mode
            task->wakeup_count++;
            rc = TERR_NO_ERR;
         }
         else
            rc = TERR_OVERFLOW;
      }
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #13
0
ファイル: ts_fce_wakp.c プロジェクト: Sav0966/qmlab-pic24
/**
 *
 * @param task
 *
 * @return TN_RETVAL
 */
TN_RETVAL tnec_task_wakeup (TN_TCB_S *task)
{
    TN_UWORD tn_save_status_reg TN_UNUSED;     /* for SR save */
    TN_RETVAL     rc;

    if (task == TN_NULL)
        return  TERR_WRONG_PARAM;

    if (task->id_task != TN_ID_TASK)
        return TERR_NOEXS;

    if (tn_is_non_task_context())
    {
        return TERR_WCONTEXT;
    }

    tn_disable_interrupt();

    if (task->task_state == TSK_STATE_DORMANT)
    {
        rc = TERR_WCONTEXT;
    }
    else
    {
        if ((task->task_state & TSK_STATE_WAIT) && (task->task_wait_reason == TSK_WAIT_REASON_SLEEP))
        {
            if (task_wait_complete(task, TN_FALSE))
            {
                tn_enable_interrupt();
                tn_switch_context();
                return TERR_NO_ERR;
            }
            rc = TERR_NO_ERR;
        }
        else
        {
            if (tn_curr_run_task->wakeup_count == 0)
            {
                tn_curr_run_task->wakeup_count++;
                rc = TERR_NO_ERR;
            }
            else
                rc = TERR_OVERFLOW;
        }
    }
    tn_enable_interrupt();
    return rc;
}
コード例 #14
0
ファイル: tn_tasks.c プロジェクト: KWinter291/TNKernel-PIC32
//----------------------------------------------------------------------------
//  If the task is runnable, it is moved to the SUSPENDED state. If the task
//  is in the WAITING state, it is moved to the WAITING­SUSPENDED state.
//----------------------------------------------------------------------------
int tn_task_suspend(TN_TCB * task)
{
   TN_INTSAVE_DATA
   int rc;

#if TN_CHECK_PARAM
   if(task == NULL)
      return  TERR_WRONG_PARAM;
   if(task->id_task != TN_ID_TASK)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(task->task_state & TSK_STATE_SUSPEND)
      rc = TERR_OVERFLOW;
   else
   {
      if(task->task_state == TSK_STATE_DORMANT)
         rc = TERR_WSTATE;
      else
      {
         if(task->task_state == TSK_STATE_RUNNABLE)
         {
            task->task_state = TSK_STATE_SUSPEND;
            task_to_non_runnable(task);
            tn_enable_interrupt();
            tn_switch_context();

            return TERR_NO_ERR;
         }
         else
         {
            task->task_state |= TSK_STATE_SUSPEND;
            rc = TERR_NO_ERR;
         }
      }
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #15
0
ファイル: tn_dqueue.c プロジェクト: ADTL/AFGUI
//----------------------------------------------------------------------------
int tn_queue_send_polling(TN_DQUE * dque, void * data_ptr)
{
   TN_INTSAVE_DATA
   int rc;
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(dque == NULL)
      return  TERR_WRONG_PARAM;
   if(dque->id_dque != TN_ID_DATAQUEUE)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

  //-- there are task(s) in the data queue's  wait_receive list

   if(!is_queue_empty(&(dque->wait_receive_list)))
   {
      que  = queue_remove_head(&(dque->wait_receive_list));
      task = get_task_by_tsk_queue(que);

      task->data_elem = data_ptr;

      if(task_wait_complete(task))
      {
         tn_enable_interrupt();
         tn_switch_context();
         return  TERR_NO_ERR;
      }
      rc = TERR_NO_ERR;
   }
   else //-- the data queue's  wait_receive list is empty
   {
      rc = dque_fifo_write(dque,data_ptr);
      if(rc != TERR_NO_ERR)  //-- No free entries in data queue
         rc = TERR_TIMEOUT;  //-- Just convert errorcode
   }
   tn_enable_interrupt();
   return rc;
}
コード例 #16
0
ファイル: tn_tasks.c プロジェクト: KWinter291/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_task_change_priority(TN_TCB * task, int new_priority)
{
   TN_INTSAVE_DATA
   int rc;

#if TN_CHECK_PARAM
   if(task == NULL)
      return  TERR_WRONG_PARAM;
   if(task->id_task != TN_ID_TASK)
      return TERR_NOEXS;
   if(new_priority < 0 || new_priority > TN_NUM_PRIORITY - 2) //-- try to set pri
      return TERR_WRONG_PARAM;                                // reserved by sys
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(new_priority == 0)
      new_priority = task->base_priority;

   rc = TERR_NO_ERR;

   if(task->task_state == TSK_STATE_DORMANT)
      rc = TERR_WCONTEXT;
   else if(task->task_state == TSK_STATE_RUNNABLE)
   {
      if(change_running_task_priority(task,new_priority))
      {
         tn_enable_interrupt();
         tn_switch_context();
         return TERR_NO_ERR;
      }
   }
   else
   {
      task->priority = new_priority;
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #17
0
ファイル: mp_fnc_mget.c プロジェクト: Sav0966/qmlab-pic24
/**
 *
 * @param fmp
 * @param p_data
 * @param timeout
 *
 * @return TN_RETVAL
 */
TN_RETVAL tnnc_fmem_get (TN_FMP_S *fmp, void ** p_data, TN_TIMEOUT timeout)
{
    TN_UWORD  tn_save_status_reg TN_UNUSED;     /* for SR save */
    TN_RETVAL       rc;
    void     *ptr;

/*
    Not check parameter error

    if (fmp == TN_NULL || p_data == TN_NULL || timeout == 0)
        return  TERR_WRONG_PARAM;
*/
    if (fmp->id_fmp != TN_ID_FSMEMORYPOOL)
        return TERR_NOEXS;

    if (tn_is_non_task_context())
    {
        return TERR_WCONTEXT;
    }

    tn_disable_interrupt();

    ptr = fm_get(fmp);
    if (ptr != TN_NULL)
    {
        *p_data = ptr;
        rc = TERR_NO_ERR;
    }
    else
    {
        task_curr_to_wait_action(&(fmp->wait_queue), TSK_WAIT_REASON_WFIXMEM,timeout);
        tn_enable_interrupt();
        tn_switch_context();

        /* When return to this point,in data_elem have to be  valid value */
        *p_data = tn_curr_run_task->data_elem;
        return tn_curr_run_task->task_wait_rc;
    }

    tn_enable_interrupt();
    return rc;
}
コード例 #18
0
ファイル: tn_mem.c プロジェクト: 0x00f/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_fmem_get(TN_FMP * fmp, void ** p_data, unsigned long timeout)
{
   TN_INTSAVE_DATA
   int rc;
   void * ptr;

#if TN_CHECK_PARAM
   if(fmp == NULL || p_data == NULL || timeout == 0)
      return  TERR_WRONG_PARAM;
   if(fmp->id_fmp != TN_ID_FSMEMORYPOOL)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   ptr = fm_get(fmp);
   if(ptr != NULL) //-- Get memory
   {
      *p_data = ptr;
      rc = TERR_NO_ERR;
   }
   else
   {
      task_curr_to_wait_action(&(fmp->wait_queue),
                                     TSK_WAIT_REASON_WFIXMEM, timeout);
      tn_enable_interrupt();
      tn_switch_context();

      //-- When returns to this point, in the 'data_elem' have to be valid value

      *p_data = tn_curr_run_task->data_elem; //-- Return to caller

      return tn_curr_run_task->task_wait_rc;
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #19
0
ファイル: tn_sem.c プロジェクト: 0x00f/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_sem_delete(TN_SEM * sem)
{
   TN_INTSAVE_DATA
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(sem == NULL)
      return TERR_WRONG_PARAM;
   if(sem->id_sem != TN_ID_SEMAPHORE)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   while(!is_queue_empty(&(sem->wait_queue)))
   {
      tn_disable_interrupt();

     //--- delete from the sem wait queue

      que = queue_remove_head(&(sem->wait_queue));
      task = get_task_by_tsk_queue(que);
      if(task_wait_complete(task))
      {
         task->task_wait_rc = TERR_DLT;
         tn_enable_interrupt();
         tn_switch_context();
      }
   }

   if(tn_chk_irq_disabled() == 0) // int enable
      tn_disable_interrupt();

   sem->id_sem = 0; // Semaphore not exists now

   tn_enable_interrupt();

   return TERR_NO_ERR;
}
コード例 #20
0
ファイル: tn_mem.c プロジェクト: 0x00f/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_fmem_delete(TN_FMP * fmp)
{
   TN_INTSAVE_DATA
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(fmp == NULL)
      return TERR_WRONG_PARAM;
   if(fmp->id_fmp != TN_ID_FSMEMORYPOOL)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   while(!is_queue_empty(&(fmp->wait_queue)))
   {
      tn_disable_interrupt();

     //--- delete from sem wait queue

      que = queue_remove_head(&(fmp->wait_queue));
      task = get_task_by_tsk_queue(que);
      if(task_wait_complete(task))
      {
         task->task_wait_rc = TERR_DLT;
         tn_enable_interrupt();
         tn_switch_context();
      }
   }

   if(tn_chk_irq_disabled() == 0)
      tn_disable_interrupt();

   fmp->id_fmp = 0;   //-- Fixed-size memory pool not exists now

   tn_enable_interrupt();

   return TERR_NO_ERR;
}
コード例 #21
0
ファイル: tn_mem.c プロジェクト: 0x00f/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_fmem_release(TN_FMP * fmp,void * p_data)
{
   TN_INTSAVE_DATA

   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(fmp == NULL || p_data == NULL)
      return  TERR_WRONG_PARAM;
   if(fmp->id_fmp != TN_ID_FSMEMORYPOOL)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(!is_queue_empty(&(fmp->wait_queue)))
   {
      que = queue_remove_head(&(fmp->wait_queue));
      task = get_task_by_tsk_queue(que);

      task->data_elem = p_data;

      if(task_wait_complete(task))
      {
         tn_enable_interrupt();
         tn_switch_context();

         return TERR_NO_ERR;
      }
   }
   else
      fm_put(fmp,p_data);

   tn_enable_interrupt();

   return  TERR_NO_ERR;
}
コード例 #22
0
ファイル: tn_tasks.c プロジェクト: KWinter291/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_task_activate(TN_TCB * task)
{
   TN_INTSAVE_DATA
   int rc;

#if TN_CHECK_PARAM
   if(task == NULL)
      return  TERR_WRONG_PARAM;
   if(task->id_task != TN_ID_TASK)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(task->task_state == TSK_STATE_DORMANT)
   {
      task_to_runnable(task);
      tn_enable_interrupt();
      tn_switch_context();

      return TERR_NO_ERR;
   }
   else
   {
      if(task->activate_count == 0)
      {
         task->activate_count++;
         rc = TERR_NO_ERR;
      }
      else
         rc = TERR_OVERFLOW;
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #23
0
ファイル: tn_tasks.c プロジェクト: KWinter291/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_task_resume(TN_TCB * task)
{
   TN_INTSAVE_DATA
   int rc;

#if TN_CHECK_PARAM
   if(task == NULL)
      return  TERR_WRONG_PARAM;
   if(task->id_task != TN_ID_TASK)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(!(task->task_state & TSK_STATE_SUSPEND))
      rc = TERR_WSTATE;
   else
   {
      if(!(task->task_state & TSK_STATE_WAIT)) //- The task is not in the WAIT-SUSPEND state
      {
         task_to_runnable(task);
         tn_enable_interrupt();
         tn_switch_context();

         return TERR_NO_ERR;
      }
      else  //-- Just remove TSK_STATE_SUSPEND from the task state
      {
         task->task_state &= ~TSK_STATE_SUSPEND;
         rc = TERR_NO_ERR;
      }
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #24
0
ファイル: tn_event.c プロジェクト: KWinter291/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_event_delete(TN_EVENT * evf)
{
   TN_INTSAVE_DATA
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(evf == NULL)
      return TERR_WRONG_PARAM;
   if(evf->id_event != TN_ID_EVENT)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();    // v.2.7 - thanks to Eugene Scopal

   while(!is_queue_empty(&(evf->wait_queue)))
   {
     //--- delete from sem wait queue

      que = queue_remove_head(&(evf->wait_queue));
      task = get_task_by_tsk_queue(que);
      if(task_wait_complete(task))
      {
         task->task_wait_rc = TERR_DLT;
         tn_enable_interrupt();
         tn_switch_context();
         tn_disable_interrupt();    // v.2.7
      }
   }

   evf->id_event = 0; // Event not exists now

   tn_enable_interrupt();

   return TERR_NO_ERR;
}
コード例 #25
0
//----------------------------------------------------------------------------
int tn_event_delete(TN_EVENT * evf)
{
   TN_INTSAVE_DATA
   CDLL_QUEUE * que;
   TN_TCB * task;
   if(evf == NULL)
      return TERR_WRONG_PARAM;
   if(evf->id_event != TN_ID_EVENT)
      return TERR_NOEXS;

   TN_CHECK_NON_INT_CONTEXT

   while(!is_queue_empty(&(evf->wait_queue)))
   {
      if(tn_chk_irq_disabled() == 0) // int enable
         tn_disable_interrupt();

     //--- delete from sem wait queue
      que = queue_remove_head(&(evf->wait_queue));
      task = get_task_by_tsk_queue(que);
      if(task_wait_complete(task,FALSE))
      {
         task->task_wait_rc = TERR_DLT;
         tn_enable_interrupt();
         tn_switch_context();
      }
   }

   if(tn_chk_irq_disabled() == 0) // int enable
      tn_disable_interrupt();

   evf->id_event = 0; // Event not exists now

   tn_enable_interrupt();

   return TERR_NO_ERR;
}
コード例 #26
0
ファイル: tn_sem.c プロジェクト: 0x00f/TNKernel-PIC32
//----------------------------------------------------------------------------
//   Acquire Semaphore Resource
//----------------------------------------------------------------------------
int tn_sem_acquire(TN_SEM * sem, unsigned long timeout)
{
   TN_INTSAVE_DATA
   int rc; //-- return code

#if TN_CHECK_PARAM
   if(sem == NULL || timeout == 0)
      return  TERR_WRONG_PARAM;
   if(sem->max_count == 0)
      return  TERR_WRONG_PARAM;
   if(sem->id_sem != TN_ID_SEMAPHORE)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if(sem->count >= 1)
   {
      sem->count--;
      rc = TERR_NO_ERR;
   }
   else
   {
      task_curr_to_wait_action(&(sem->wait_queue), TSK_WAIT_REASON_SEM, timeout);
      tn_enable_interrupt();
      tn_switch_context();

      return tn_curr_run_task->task_wait_rc;
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #27
0
ファイル: tn_tasks.c プロジェクト: KWinter291/TNKernel-PIC32
//----------------------------------------------------------------------------
int tn_task_release_wait(TN_TCB * task)
{
   TN_INTSAVE_DATA
   int rc;

#if TN_CHECK_PARAM
   if(task == NULL)
      return  TERR_WRONG_PARAM;
   if(task->id_task != TN_ID_TASK)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   if((task->task_state & TSK_STATE_WAIT) == 0)
   {
      rc = TERR_WCONTEXT;
   }
   else
   {
      queue_remove_entry(&(task->task_queue));
      if(task_wait_complete(task))
      {
         tn_enable_interrupt();
         tn_switch_context();
         return TERR_NO_ERR;
      }
      rc = TERR_NO_ERR;
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #28
0
ファイル: ts_fce_supd.c プロジェクト: Sav0966/qmlab-pic24
/**
 *
 * @param task
 *
 * @return TN_RETVAL
 */
TN_RETVAL tnec_task_suspend (TN_TCB_S *task)
{
    TN_UWORD tn_save_status_reg TN_UNUSED;     /* for SR save */
    TN_RETVAL      rc;

    if (task == TN_NULL)
        return  TERR_WRONG_PARAM;

    if (task->id_task != TN_ID_TASK)
        return TERR_NOEXS;

    if (tn_is_non_task_context())
    {
        return TERR_WCONTEXT;
    }

    tn_disable_interrupt();

    if (task->task_state & TSK_STATE_SUSPEND)
    {
        rc = TERR_OVERFLOW;
    }
    else
    {
        if (task->task_state == TSK_STATE_DORMANT)
        {
            rc = TERR_WSTATE;
        }
        else
        {
            if (task == tn_curr_run_task &&
                !(tn_enable_switch_context)
               )
            {
                rc = TERR_WCONTEXT;
            }
            else
            {
                if (task->task_state == TSK_STATE_RUNNABLE)
                {
                    task->task_state = TSK_STATE_SUSPEND;
                    task_to_non_runnable(task);

                    tn_enable_interrupt();
                    if ((tn_next_task_to_run != tn_curr_run_task) && (tn_enable_switch_context != TN_FALSE))
                    {
                        tn_switch_context();
                    }
                    return  TERR_NO_ERR;
                }
                else
                {
                    task->task_state |= TSK_STATE_SUSPEND;
                    rc = TERR_NO_ERR;
                }
            }
        }
    }

    tn_enable_interrupt();
    return rc;
}
コード例 #29
0
ファイル: tn_dqueue.c プロジェクト: ADTL/AFGUI
//----------------------------------------------------------------------------
int tn_queue_receive_polling(TN_DQUE * dque,void ** data_ptr)
{
   TN_INTSAVE_DATA
   int rc;
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(dque == NULL || data_ptr == NULL)
      return  TERR_WRONG_PARAM;
   if(dque->id_dque != TN_ID_DATAQUEUE)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   rc = dque_fifo_read(dque,data_ptr);
   if(rc == TERR_NO_ERR)  //-- There was entry(s) in data queue
   {
      if(!is_queue_empty(&(dque->wait_send_list)))
      {
         que  = queue_remove_head(&(dque->wait_send_list));
         task = get_task_by_tsk_queue(que);

         dque_fifo_write(dque,task->data_elem); //-- Put to data FIFO

         if(task_wait_complete(task))
         {
            tn_enable_interrupt();
            tn_switch_context();
            return TERR_NO_ERR;
         }
      }
   }
   else //-- data FIFO is empty
   {
      if(!is_queue_empty(&(dque->wait_send_list)))
      {
         que  = queue_remove_head(&(dque->wait_send_list));
         task = get_task_by_tsk_queue(que);

         *data_ptr = task->data_elem; //-- Return to caller

         if(task_wait_complete(task))
         {
            tn_enable_interrupt();
            tn_switch_context();
            return TERR_NO_ERR;
         }
         rc = TERR_NO_ERR;
      }
      else //--   wait_send_list is empty
         rc = TERR_TIMEOUT;
   }

   tn_enable_interrupt();

   return rc;
}
コード例 #30
0
ファイル: tn_dqueue.c プロジェクト: ADTL/AFGUI
//----------------------------------------------------------------------------
int tn_queue_receive(TN_DQUE * dque,void ** data_ptr,unsigned long timeout)
{
   TN_INTSAVE_DATA
   int rc; //-- return code
   CDLL_QUEUE * que;
   TN_TCB * task;

#if TN_CHECK_PARAM
   if(dque == NULL || timeout == 0 || data_ptr == NULL)
      return  TERR_WRONG_PARAM;
   if(dque->id_dque != TN_ID_DATAQUEUE)
      return TERR_NOEXS;
#endif

   TN_CHECK_NON_INT_CONTEXT

   tn_disable_interrupt();

   rc = dque_fifo_read(dque,data_ptr);
   if(rc == TERR_NO_ERR)  //-- There was entry(s) in data queue
   {
      if(!is_queue_empty(&(dque->wait_send_list)))
      {
         que  = queue_remove_head(&(dque->wait_send_list));
         task = get_task_by_tsk_queue(que);

         dque_fifo_write(dque,task->data_elem); //-- Put to data FIFO

         if(task_wait_complete(task))
         {
            tn_enable_interrupt();
            tn_switch_context();
            return TERR_NO_ERR;
         }
      }
   }
   else //-- data FIFO is empty
   {
      if(!is_queue_empty(&(dque->wait_send_list)))
      {
         que  = queue_remove_head(&(dque->wait_send_list));
         task = get_task_by_tsk_queue(que);

         *data_ptr = task->data_elem; //-- Return to caller

         if(task_wait_complete(task))
         {
            tn_enable_interrupt();
            tn_switch_context();
            return TERR_NO_ERR;
         }
         rc = TERR_NO_ERR;
      }
      else //-- wait_send_list is empty
      {
         task_curr_to_wait_action(&(dque->wait_receive_list),
                                     TSK_WAIT_REASON_DQUE_WRECEIVE,timeout);
         tn_enable_interrupt();
         tn_switch_context();

         //-- When returns to this point, in the data_elem have to be valid value

         *data_ptr = tn_curr_run_task->data_elem; //-- Return to caller

         return tn_curr_run_task->task_wait_rc;
      }
   }

   tn_enable_interrupt();

   return rc;
}