Пример #1
0
void Testee_receiveMessage(void* self, void* ifitem, const etMessage* msg){
	ET_MSC_LOGGER_SYNC_ENTRY("Testee", "_receiveMessage")
	
	receiveEvent(self, (etPort*)ifitem, msg->evtID, (void*)(((char*)msg)+MEM_CEIL(sizeof(etMessage))));
	
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #2
0
void etMessageService_start(etMessageService* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etMessageService", "start")
	etThread_start( &(self->thread) );
	if (self->execmode==EXECMODE_POLLED || self->execmode==EXECMODE_MIXED) {
		etTimer_start(&self->timer);
	}
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #3
0
void Testee_init(Testee* self){
	ET_MSC_LOGGER_SYNC_ENTRY("Testee", "init")
	self->state = STATE_TOP;
	{
		int i;
		for (i=0; i<TESTEE_HISTORY_SIZE; ++i)
			self->history[i] = NO_STATE;
	}
	executeInitTransition(self);
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #4
0
void etThread_construct(
		etThread* self,
		etStacksize stacksize,
		etPriority priority,
		etThreadname threadName,
		etThreadFunction threadFunction,
		void* threadFunctionData)
{
	ET_MSC_LOGGER_SYNC_ENTRY("etThread", "construct")

	/* fill in data */
	self->stacksize = stacksize;
	self->priority = priority;
	self->threadName = threadName;
	self->threadFunction = threadFunction;
	self->threadFunctionData = threadFunctionData;

	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #5
0
/*
 * initialize message service with all needed data and initialize message queue and message pool
 *
 */
void etMessageService_init(
		etMessageService* self,
		etUInt8* buffer,
		etUInt16 maxBlocks,
		etUInt16 blockSize,
		etStacksize stacksize,
		etPriority priority,
		etTime interval,
		etDispatcherReceiveMessage msgDispatcher,
		etMessageService_execmode execmode){
	ET_MSC_LOGGER_SYNC_ENTRY("etMessageService", "init")

	/* copy init data to self */
	self->messageBuffer.buffer = buffer;
	self->messageBuffer.maxBlocks = maxBlocks;
	self->messageBuffer.blockSize = blockSize;
	self->msgDispatcher = msgDispatcher;
	self->execmode = execmode;

	/* init queue and pool */
	etMessageQueue_init( &(self->messagePool) ); 	/* the pool is also a queue*/
	etMessageQueue_init( &(self->messageQueue) );
	etMessageService_initMessagePool(self);

	/* init mutexes and semaphores */
	etMutex_construct( &(self->poolMutex) );
	etMutex_construct( &(self->queueMutex) );
	etSema_construct( &(self->executionSemaphore) );

	/* init thread */
	etThread_construct(&self->thread, stacksize, priority, "MessageService", (etThreadFunction) etMessageService_deliverAllMessages, self);

	if (execmode==EXECMODE_POLLED || execmode==EXECMODE_MIXED) {
		/* init timer */
		etTimer_construct(&self->timer, &interval, etMessageService_timerCallback, self);
	}

	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #6
0
void etSema_waitForWakeup(etSema* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etSema", "waitForWakeup")
	WaitForSingleObject( self->osData, INFINITE );
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #7
0
void etSema_wakeup(etSema* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etSema", "wakeup")
	SetEvent( self->osData );
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #8
0
void etSema_construct(etSema* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etSema", "construct")
	self->osData = CreateEvent( NULL, FALSE, FALSE, NULL );
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #9
0
 *
 */

#include "osal/etSema.h"
#include "etDatatypes.h"

#include "debugging/etMSCLogger.h"


void etSema_construct(etSema* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etSema", "construct")
	self->osData = CreateEvent( NULL, FALSE, FALSE, NULL );
	ET_MSC_LOGGER_SYNC_EXIT
}
void etSema_destruct(etSema* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etSema", "destruct")
	/* TODO: implement this function */
	ET_MSC_LOGGER_SYNC_EXIT
}

void etSema_wakeup(etSema* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etSema", "wakeup")
	SetEvent( self->osData );
	ET_MSC_LOGGER_SYNC_EXIT
}

void etSema_waitForWakeup(etSema* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etSema", "waitForWakeup")
	WaitForSingleObject( self->osData, INFINITE );
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #10
0
void CLass1_f(void) {
	ET_MSC_LOGGER_SYNC_ENTRY("Class1", "f")
	Class2_ff();
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #11
0
#include "debugging/etLogger.h"
#include "debugging/etMSCLogger.h"

void Class2_ff(void) {
	ET_MSC_LOGGER_SYNC_ENTRY("Class2", "ff")

	ET_MSC_LOGGER_SYNC_EXIT
}

void CLass1_f(void) {
	ET_MSC_LOGGER_SYNC_ENTRY("Class1", "f")
	Class2_ff();
	ET_MSC_LOGGER_SYNC_EXIT
}

//int main(void) {
//
//	etLogger_logInfo("***   T H E   B E G I N   ***");
//
//	ET_MSC_LOGGER_OPEN("main");
//	CLass1_f();
//	ET_MSC_LOGGER_CLOSE
//
//	etLogger_logInfo("***   T H E   E N D   ***");
//
//	return 0;
//}
Пример #12
0
void etThread_sleep(etInt32 millis){
	ET_MSC_LOGGER_SYNC_ENTRY("etThread", "sleep")
	Sleep(millis);
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #13
0
void etThread_destruct(etThread* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etThread", "destruct")
	TerminateThread(self->osData, 0);
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #14
0
void etThread_execute(etThread* self){
	ET_MSC_LOGGER_SYNC_ENTRY("etThread", "execute")
	/* etThread_execute redirects the call from the thread to the execute function in the eTrice runtime to enable correct synchronous MSC logging */
	self->threadFunction(self->threadFunctionData);
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #15
0
void etThread_start(etThread* self) {
	ET_MSC_LOGGER_SYNC_ENTRY("etThread", "start")
	self->osData = (HANDLE)_beginthread( (etThreadFunction)etThread_execute, self->stacksize, self );
	SetThreadPriority(self->osData, self->priority);
	ET_MSC_LOGGER_SYNC_EXIT
}
Пример #16
0
void PTimerPort_timeout(const PTimerPort* self) {
	ET_MSC_LOGGER_SYNC_ENTRY("PTimerPort", "timeout")
		etPort_sendMessage(self, PTimer_OUT_timeout, 0, NULL);
	ET_MSC_LOGGER_SYNC_EXIT
}