task.c

一种操作系统源码核

              	UnProtect(task_ptr);
	      	return (TRUE);

           }
           UnLock();        
 	}
        
        UnProtect(task_ptr);
        return(FALSE);
}
/*
*********************************************************************************************************
*                                   强制挂起一个任务的外部调用函数
                                   

*********************************************************************************************************
*/

STATUS SuspendTask(SIGNED task_id)
{
 	TASK_TCB *task_ptr;
       	STATUS state;
       	if ( task_id >MAX_TASK_NUM)                                 /* Not allowed to Del idle task     */
            	return (ERR_INVALID_TASK);
        
       	task_ptr=TaskTable[task_id];

       	if (task_ptr == NULL)                                 /* Not allowed to Del idle task     */
	   	return (ERR_INVALID_TASK);
    	#if DEBUG
           	DebugLog(SUSPEND_TASK_ID,task_ptr->id);//在日志中记录操作，时间等信息
       	#endif
       	if (task_ptr->status & PURE_SUSPEND){
     	  	return(OK);
        }
       	state= _SuspendTask(task_ptr,PURE_SUSPEND,NULL,NULL,0);
       	if(state==TRUE)
	  	_ControlToSystem();

        return(state);

}

/*
*********************************************************************************************************
*                                   任务睡眠调用函数,挂起当前任务ticks时间
*********************************************************************************************************
*/
void TaskSleep(UNSIGNED ticks)
{
      	SIGNED state;
      	if (((TASK_TCB *)KERNAL.current_thread)->type !=TASK) {
        	return ;
      	}
    	#if DEBUG
      		DebugLog(TASK_SLEEP_ID,KERNAL.current_thread->name);//在日志中记录操作，时间等信息
    	#endif

    	

      	state= _SuspendTask(KERNAL.current_thread,PURE_SUSPEND,NULL,NULL,ticks);
      	if(state==TRUE)
	 	_ControlToSystem();

}

/*
*********************************************************************************************************
*                                   恢复一个已挂起的任务函数原型

*********************************************************************************************************
*/
STATUS ResumeTask(SIGNED task_id)
{
       	STATUS status;
       	TASK_TCB *task_ptr;
       	if ( task_id >MAX_TASK_NUM) {                                 /* Not allowed to Del idle task     */
            	return (ERR_INVALID_TASK);
        }
       	task_ptr=TaskTable[task_id];
  	#if DEBUG
       		DebugLog(RESUME_TASK_ID,task_ptr->id);//在日志中记录操作，时间等信息
    	#endif
       	DoProtect(task_ptr);
       	if (task_ptr == NULL)                                 /* Not allowed to Del idle task     */
           	return (ERR_INVALID_TASK);
        
       	if (task_ptr->status & PURE_SUSPEND==0 ){
   	  	UnProtect(task_ptr);
	  	return (ERR_INVALID_RESUME);
        }
       	UnProtect(task_ptr);
       	status=_ResumeTask(task_ptr,PURE_SUSPEND);
       	if(status==TRUE)
	 	_ControlToSystem();
       	return (status);
 }
/*
*********************************************************************************************************
*                                   恢复一个已挂起的任务内部函数,该函数检查任务的状态,看是否与恢复的类型一致,若挂起时,规定有
                                    定时器,则要停止该定时器

*********************************************************************************************************
*/
STATUS _ResumeTask(TASK_TCB *task_ptr,INT8U suspend_type)
{
	UCHAR  prio_group,prio_groupbit;
	

  	DoProtect(task_ptr);
	if (task_ptr == NULL)                                  /* Not allowed to Del idle task     */
	     	return (ERR_INVALID_TASK);
	if(task_ptr->status==READY){  //任务已经恢复
	     	UnProtect(task_ptr);
	     	return (FALSE);
	}
	if(suspend_type & TIMER_SUSPEND){   //timer hisr calling
 	      	StopTimer(&(task_ptr->timer_control));
  	}
	else if ((task_ptr->status & suspend_type)==0){
	       	UnProtect(task_ptr);
	       	return (ERR_INVALID_RESUME);
	}
	task_ptr->status=READY;
	prio_group=(task_ptr->priority)/8;
	prio_groupbit=(task_ptr->priority) % 8;
	EnLock();
	Priority_Group |= 1<<prio_group;
	Sub_Priority_Groups[prio_group] |= 1<<prio_groupbit;
	AddTaskList(&(Priority_Head[task_ptr->priority]),task_ptr,0);
	if(((TASK_TCB *)KERNAL.current_thread)->type==TASK){
	     	if (task_ptr->priority < HighRdyThread->priority){
	    		HighRdyThread=task_ptr;
	    		DirectSched=TRUE;
	    		UnLock();
	        	UnProtect(task_ptr);
	        	return(TRUE);  //需要重新调度
	     	}
	}
	UnLock();
	UnProtect(task_ptr);
	return (FALSE);
}
/*
*********************************************************************************************************
                得到当前任务的标识符                  

*********************************************************************************************************
*/
SIGNED GetTaskID(void)
{
   
	if (((TASK_TCB *)KERNAL.current_thread)->type ==TASK){
            	return (((TASK_TCB *)KERNAL.current_thread)->id);
	}
	else 
	    	return(-1);
}

/*
*********************************************************************************************************
                                   得到当前任务指针函数原型
*********************************************************************************************************
*/

TASK_TCB  *_GetCurrentTask(void)
{
       	TASK_TCB  *task_ptr;
	
        task_ptr=KERNAL.current_thread;
        if (((TASK_TCB *)KERNAL.current_thread)->type ==TASK)	 {
	    	return (task_ptr);
	}
	else 
	    	return(NULL);
}


/*
*********************************************************************************************************
                                 该函数用来返回当前线程指针,在本文件以外取得当前线程指针
         

*********************************************************************************************************
*/
void *GetCurrentThread(void)
{
  	return (KERNAL.current_thread);
}
/*
*********************************************************************************************************
                  该函数列出系统当前存在任务(已创建没有被删除的任务)的运行信息,每个任务的信息保存到一个指针数组,若task_id为0,列出所有任务,
                  否则列出task_id-1标识的任务,并送到显示函数显示信息,
 
*********************************************************************************************************
*/

STATUS ListTask(SIGNED task_id,TASK_DATA **task_lst)
{
      	TASK_TCB *task_ptr;
	UNSIGNED i;
      	if (task_id+1<0 && task_id >MAX_TASK_NUM) {                                 /* Not allowed to Del idle task     */
		return (ERR_INVALID_TASK);
        }
        if(task_id>=0){
              	task_ptr=TaskTable[task_id];
      		DoProtect(task_ptr);
      		if (task_ptr == NULL)                                  /* Not allowed to Del idle task     */
	   		return (ERR_INVALID_TASK);
		(*task_lst)->status=task_ptr->status;
		(*task_lst)->scheduled=task_ptr->scheduled;
		(*task_lst)->priority=task_ptr->priority;
		(*task_lst)->preemption=task_ptr->preemption;
		(*task_lst)->timer_active=task_ptr-> timer_active;
		(*task_lst)->time_slice  =task_ptr->time_slice;
		(*task_lst)->task_timeout=task_ptr->task_timeout;
		(*task_lst)->stack_start=task_ptr->stack_start;
		(*task_lst)->stack_end=task_ptr->stack_end;
		UnProtect(task_ptr);
		return (OK);
	}else{
		for(i=0;i<MAX_TASK_NUM;i++){
			task_ptr=TaskTable[i];
			DoProtect(task_ptr);
			if (task_ptr){                                  /* Not allowed to Del idle task     */
				(*task_lst)->status=task_ptr->status;
				(*task_lst)->scheduled=task_ptr->scheduled;
				(*task_lst)->priority=task_ptr->priority;
				(*task_lst)->preemption=task_ptr->preemption;
				(*task_lst)->timer_active=task_ptr-> timer_active;
				(*task_lst)->time_slice  =task_ptr->time_slice;
				(*task_lst)->task_timeout=task_ptr->task_timeout;
				(*task_lst)->stack_start=task_ptr->stack_start;
				(*task_lst)->stack_end=task_ptr->stack_end;
				task_lst++;
      			}
      			UnProtect(task_ptr);
      		}
            	return (OK);
	}
}
/*
*********************************************************************************************************
                  任务控制函数,用于改变指定任务的某些默认设置,如时间片定时器的激活等
 
*********************************************************************************************************
*/
STATUS SysTaskCtl(SIGNED task_id,INT8U cmd,INT8U param)
{
	SIGNED ret;
	TASK_TCB *task_ptr;
        if ( task_id<0 || task_id >MAX_TASK_NUM) {                                 /* Not allowed to Del idle task     */
            	return (ERR_INVALID_TASK);
        }
        task_ptr=TaskTable[task_id];
       	#if DEBUG
        	DebugLog(SYS_TASK_CTL_ID,task_ptr->name);//在日志中记录操作，时间等信息
     	#endif
        DoProtect(task_ptr);
        if (task_ptr == NULL) {
	      	return (ERR_INVALID_TASK); /* Not allowed is idle task     */
	}
	switch(cmd){
	   	case	TIMER_ACTIVE:
	      		task_ptr->timer_active=param;
	      		ret=OK;
	      		break;
	   	case TIME_SLICE:
	      		task_ptr->time_slice=param;
	      		ret=OK;
	      		break;
		case TIME_LIMIT:
			task_ptr->task_timeout=param;
			ret=OK;
			break;
		default:
			ret=ERR_INVALID_CMD;
			break;
	}
	UnProtect(task_ptr);
	return(ret);
}
/*******************************************************************************

锁定任务,不允许强占

******************************************************************************/

STATUS  LockTask()
{
	TASK_TCB *task_ptr;
	task_ptr= KERNAL.current_thread;
	if(task_ptr->type!=TASK) 
	      return (ERR_INVALID_TASK); 
      	#if DEBUG
	    	DebugLog(CHANGE_PREEMPTION_ID,task_ptr->name);//在日志中记录操作，时间等信息
        #endif
        DoProtect(task_ptr);
     	if (task_ptr == NULL) {
	  	return (ERR_INVALID_TASK); /* Not allowed is idle task     */
	}
	if(task_ptr->preemption==FALSE)
	    	return (OK);
        task_ptr->preemption=FALSE;
        task_ptr->timer_active=FALSE;
        UnProtect(task_ptr);
         
        return (OK);  

}
/*******************************************************************************

恢复任务的锁定,允许强占

******************************************************************************/
STATUS  UnLockTask()
{
 	TASK_TCB *task_ptr;
	task_ptr= KERNAL.current_thread;
	if(task_ptr->type!=TASK) 
	     	return (ERR_INVALID_TASK);
       	#if DEBUG
	    	DebugLog(CHANGE_PREEMPTION_ID,task_ptr->name);//在日志中记录操作，时间等信息
        #endif
        DoProtect(task_ptr);
     	if (task_ptr == NULL) {
	  	return (ERR_INVALID_TASK); /* Not allowed is idle task     */
	}
	if(task_ptr->preemption==TRUE)
	    	return (OK);
        task_ptr->preemption=TRUE;
        task_ptr->timer_active=TRUE;
        UnProtect(task_ptr);
        ControlToSystem(); 
        return (OK);  

}		
/*
*********************************************************************************************************
                            改变一个任务的优先级函数原型,并返回旧的优先级
 
*********************************************************************************************************
*/


SIGNED SetPriority(SIGNED task_id, INT8U new_priority)
{
	
	UCHAR cur_priority,old_priority, prio_group,prio_groupbit;
	TASK_TCB *task_ptr;
        if ( task_id >MAX_TASK_NUM) {                                 /* Not allowed to Del idle task     */
           	return (ERR_INVALID_TASK);
       	}
        task_ptr=TaskTable[task_id];
       	#if DEBUG
	   	DebugLog(CHANGE_PRIORITY_ID,ptask->name);//在日志中记录操作，时间等信息
        #endif
	DoProtect(task_ptr);
	if (task_ptr == NULL) {
	   	return (ERR_INVALID_TASK); /* Not allowed is idle task     */