/** @req OS383 */
StatusType GetCounterValue( CounterType counter_id , TickRefType tick_ref)
{
StatusType rv = E_OK;
OsCounterType *cPtr;
cPtr = Os_CounterGet(counter_id);
#if (OS_SC3==STD_ON) || (OS_SC4==STD_ON)
OsTaskVarType *currPcbPtr = Os_SysTaskGetCurr();
if( currPcbPtr->constPtr->applOwnerId != cPtr->applOwnerId ) {
/* @req SWS_Os_00056 */
APPL_CHECK_STATE(cPtr->applOwnerId);
APPL_CHECK_ACCESS(currPcbPtr->constPtr->applOwnerId, cPtr->accessingApplMask);
#if (OS_NUM_CORES > 1)
if (Os_ApplGetCore(cPtr->applOwnerId) != GetCoreID()) {
StatusType status = Os_NotifyCore(Os_ApplGetCore(cPtr->applOwnerId),
OSServiceId_GetCounterValue,
counter_id,
(uint32_t)tick_ref,
0);
return status;
}
#endif
}
#endif
OS_VALIDATE(IsCounterValid(counter_id),E_OS_ID); /* @req 4.1.2/SWS_Os_00376 */
/** @req OS377 */
if( cPtr->type == COUNTER_TYPE_HARD ) {
if( cPtr->driver == NULL ) {
/* It's OSINTERNAL */
*tick_ref = OS_SYS_PTR->tick;
} else {
#if 0
/* We support only GPT for now */
*tick_ref = (TickType)Gpt_GetTimeElapsed(cPtr->driver.OsGptChannelRef);
#endif
}
} else {
*tick_ref = cPtr->val;
}
COUNTER_STD_END;
}
/** @req 4.1.2/SWS_Os_00392 */
StatusType GetElapsedValue ( CounterType counter_id, TickRefType val, TickRefType elapsed_val)
{
StatusType rv = E_OK;
OsCounterType *cPtr;
TickType currTick = 0;
TickType max;
cPtr = Os_CounterGet(counter_id);
/** @req SWS_Os_00381 */
OS_VALIDATE(IsCounterValid(counter_id),E_OS_ID);
max = Os_CounterGetMaxValue(cPtr);
/** @req SWS_Os_00391 */
OS_VALIDATE( *val <= max,E_OS_VALUE );
#if (OS_APPLICATION_CNT > 1) && (OS_NUM_CORES > 1)
if (Os_ApplGetCore(cPtr->applOwnerId) != GetCoreID()) {
StatusType status = Os_NotifyCore(Os_ApplGetCore(cPtr->applOwnerId),
OSServiceId_GetElapsedValue,
counter_id,
(int32_t)val,
(int32_t)elapsed_val);
return status;
}
#endif
GetCounterValue(counter_id,&currTick);
/** @req OS382 */
*elapsed_val = Os_CounterDiff(currTick,*val,max);
/** @req OS460 */
*val = currTick;
COUNTER_STD_END;
}
/** @req OS399 */
StatusType IncrementCounter( CounterType counter_id ) {
StatusType rv = E_OK;
OsCounterType *cPtr;
uint32_t flags;
#if (OS_SC3==STD_ON) || (OS_SC4==STD_ON)
OsTaskVarType *currPcbPtr;
#endif
OS_VALIDATE( IsCounterValid(counter_id), E_OS_ID );
cPtr = Os_CounterGet(counter_id);
OS_VALIDATE( !( ( cPtr->type != COUNTER_TYPE_SOFT ) ||
( counter_id >= OS_COUNTER_CNT )), E_OS_ID );
#if (OS_SC3==STD_ON) || (OS_SC4==STD_ON)
currPcbPtr = Os_SysTaskGetCurr();
if( currPcbPtr->constPtr->applOwnerId != cPtr->applOwnerId ) {
/* @req SWS_Os_00056 */
APPL_CHECK_STATE(cPtr->applOwnerId);
APPL_CHECK_ACCESS(currPcbPtr->constPtr->applOwnerId, cPtr->accessingApplMask);
#if (OS_CORE_CNT > 1)
OS_EXT_VALIDATE( Os_ApplGetCore(cPtr->applOwnerId) != GetCoreID(), E_OS_ACCESS );
#endif
}
#endif
Irq_Save(flags);
/** @req OS286 */
cPtr->val = Os_CounterAdd( cPtr->val, Os_CounterGetMaxValue(cPtr), 1 );
#if OS_ALARM_CNT!=0
Os_AlarmCheck(cPtr);
#endif
#if OS_SCHTBL_CNT!=0
Os_SchTblCheck(cPtr);
#endif
Irq_Restore(flags);
/** @req OS321 */
COUNTER_STD_END;
}
}
#endif
//extern TaskType Os_AddTask( OsTaskVarType *pcb );
//static uint8 stackTop = 0x42;
#if OS_ISR_CNT != 0
static void Os_IsrAddWithId( const OsIsrConstType * restrict isrPtr, int id ) {
Os_IsrVarList[id].constPtr = isrPtr;
Os_IsrVarList[id].id = id;
#if defined(CFG_OS_ISR_HOOKS)
Os_IsrVarList[id].preemtedId = INVALID_ISR;
#endif
Os_VectorToIsr[isrPtr->vector + IRQ_INTERRUPT_OFFSET ] = id;
Irq_EnableVector( isrPtr->vector, isrPtr->priority, Os_ApplGetCore(isrPtr->appOwner ) );
}
#endif
void Os_IsrInit( void ) {
Irq_Init();
Os_Sys.isrCnt = OS_ISR_CNT;
/* Probably something smarter, but I cant figure out what */
memset(Os_VectorToIsr,ILL_VECTOR,NUMBER_OF_INTERRUPTS_AND_EXCEPTIONS);
#if OS_ISR_CNT != 0
/* Attach the interrupts */
for (int i = 0; i < Os_Sys.isrCnt; i++) {
Os_IsrAddWithId(&Os_IsrConstList[i],i);
StatusType SetEvent( TaskType TaskID, EventMaskType Mask ) {
StatusType rv = E_OK;
OsTaskVarType *destPcbPtr;
OsTaskVarType *currPcbPtr;
uint32_t flags;
OS_DEBUG(D_EVENT,"# SetEvent %s\n",Os_SysTaskGetCurr()->constPtr->name);
TASK_CHECK_ID(TaskID);
destPcbPtr = Os_TaskGet(TaskID);
currPcbPtr = Os_SysTaskGetCurr();
#if (OS_SC3==STD_ON) || (OS_SC4==STD_ON)
if( destPcbPtr->constPtr->applOwnerId != OS_SYS_PTR->currApplId ) {
ApplicationType appId;
APPL_CHECK_STATE(destPcbPtr->constPtr->applOwnerId);
/* Do we have access to the task we are activating */
if(OS_SYS_PTR->intNestCnt == 0 ) {
appId = currPcbPtr->constPtr->applOwnerId;
} else {
appId = Os_SysIsrGetCurr()->constPtr->appOwner;
}
APPL_CHECK_ACCESS( appId , destPcbPtr->constPtr->accessingApplMask);
#if (OS_NUM_CORES > 1)
if (Os_ApplGetCore(destPcbPtr->constPtr->applOwnerId) != GetCoreID()) {
StatusType status = Os_NotifyCore(Os_ApplGetCore(destPcbPtr->constPtr->applOwnerId),
OSServiceId_SetEvent,
TaskID,
Mask,
0);
return status;
#endif
}
#endif
OS_VALIDATE( destPcbPtr->constPtr->proc_type == PROC_EXTENDED, E_OS_ACCESS );
OS_VALIDATE( !(destPcbPtr->state & ST_SUSPENDED ), E_OS_STATE);
Irq_Save(flags);
/* Calling SetEvent causes the task <TaskID> to be transferred
* to the ready state, if it was waiting for at least one of the
* events specified in <Mask>.
*
* OSEK/VDX 4.6.1, rescheduling is performed in all of the following cases:
* ..
* Setting an event to a waiting task at task level (e.g. system service SetEvent,
* see chapter 13.5.3.1, message notification mechanism, alarm expiration, if event setting
* defined, see chapter 9.2)
* ... */
destPcbPtr->ev_set |= Mask;
if( (Mask & destPcbPtr->ev_wait) ) {
/* We have an event match */
if( destPcbPtr->state & ST_WAITING) {
Os_TaskMakeReady(destPcbPtr);
currPcbPtr = Os_SysTaskGetCurr();
/* Checking "4.6.2 Non preemptive scheduling" it does not dispatch if NON */
if( (OS_SYS_PTR->intNestCnt == 0) &&
(currPcbPtr->constPtr->scheduling == FULL) &&
(destPcbPtr->activePriority > currPcbPtr->activePriority) &&
(Os_SchedulerResourceIsFree()) )
{
Os_Dispatch(OP_SET_EVENT);
}
} else if(destPcbPtr->state & (ST_READY|ST_RUNNING|ST_SLEEPING) ) {
/* Hmm, we do nothing */
} else {
assert( 0 );
}
}
Irq_Restore(flags);
OS_STD_END_2(OSServiceId_SetEvent,TaskID, Mask);
}
/**
* This service returns the current state of all event bits of the task
* <TaskID>, not the events that the task is waiting for.
* The service may be called from interrupt service routines, task
* level and some hook routines (see Figure 12-1).
* The current status of the event mask of task <TaskID> is copied
* to <Event>.
*
* @param TaskId Task whose event mask is to be returned.
* @param Mask Reference to the memory of the return data.
* @return
*/
StatusType GetEvent( TaskType TaskId, EventMaskRefType Mask) {
OsTaskVarType *destPcbPtr;
StatusType rv = E_OK;
TASK_CHECK_ID(TaskId);
destPcbPtr = Os_TaskGet(TaskId);
OS_VALIDATE( (destPcbPtr->constPtr->proc_type == PROC_EXTENDED) ,E_OS_ACCESS);
OS_VALIDATE( !(destPcbPtr->state & ST_SUSPENDED),E_OS_STATE);
*Mask = destPcbPtr->ev_set;
if (0) goto err;
OS_STD_END_2(OSServiceId_GetEvent,TaskId, Mask);
}
