/*==================[definiciones de funciones externas]=====================*/
void printError(void) 
{
   static uint8_t OSErrorGetServiceIdTxt[][25]={
      "Undefined",
      "ActivateTask",
      "TerminateTask",
      "ChainTask",
      "Schedule",
      "GetTAskID",
      "GetTaskState",
      "DisableAllInterrupts",
      "EnableAllInterrupts",
      "SuspendAllInterrupts",
      "ResumeAllInterrupts",
      "SuspendOSInterrupts",
      "ResumeOSInterrupts",
      "GetResource",
      "ReleaseResource",
      "SetEvent",
      "ClearEvent",
      "GetEvent",
      "WaitEvent",
      "GetAlarmBase",
      "GetAlarm",
      "SetRelAlarm",
      "SetAbsAlarm",
      "CancelAlarm",
      "GetACtiveApplicationMode",
      "StartOS",
      "ShutdownOS"
   };

   static uint8_t OSErrorGetRetTxt[][13]={
      "E_OK",
      "E_OS_ACCESS",
      "E_OS_CALLEVEL",
      "E_OS_ID"
      "E_OS_LIMIT",
      "E_OS_NOFUNC",
      "E_OS_RESOURCE",
      "E_OS_STATE",
      "E_OS_VALUE"
   };


   uartWriteString(UART_USB, "\n-----------------------------------\n");
   uartWriteString(UART_USB, "Service:\n");
   uartWriteByte(UART_USB, ( OSErrorGetServiceId() + 48 ) );

   uartWriteString(UART_USB, " = ");
   uartWriteString(UART_USB, ( OSErrorGetServiceIdTxt[OSErrorGetServiceId()]) );
   uartWriteString(UART_USB, " ---> ");
   uartWriteByte(UART_USB, ( OSErrorGetRet() + 48 ) );
   uartWriteString(UART_USB, " = ");
   uartWriteString(UART_USB, ( OSErrorGetRetTxt[OSErrorGetRet()] ) );

   uartWriteString(UART_USB, "\n-----------------------------------\n");
}

void
ErrorHook(StatusType Error)
{
	TaskType	tskid;
	StatusType	ercd;

#ifdef IOC_E_NO_DATA
	/* IOC_E_NO_DATAはエラーではない */
	if (Error == IOC_E_NO_DATA) {
		return;
	}
#endif /* IOC_E_NO_DATA */

	syslog(LOG_NOTICE, "## ErrorHook is called !! (%d)", Error);

	ercd = GetTaskID(&tskid);
	if (ercd == E_OK) {
		syslog(LOG_NOTICE, "GetTaskID: %d", (sintptr) tskid);
	}
	else {
		syslog(LOG_NOTICE, "GetTaskID is unavailable.");
	}
	syslog(LOG_NOTICE, "GetISRID: %d", (sintptr) GetISRID());
	syslog(LOG_NOTICE, "OSErrorGetServiceId(): %d", OSErrorGetServiceId());

	return;
}

/** \brief Error Hook function
 *
 * This fucntion is called from the os if an os interface (API) returns an
 * error. Is for debugging proposes. If called this function triggers a
 * ShutdownOs which ends in a while(1).
 *
 * The values:
 *    OSErrorGetServiceId
 *    OSErrorGetParam1
 *    OSErrorGetParam2
 *    OSErrorGetParam3
 *    OSErrorGetRet
 *
 * will provide you the interface, the input parameters and the returned value.
 * For more details see the OSEK specification:
 * http://portal.osek-vdx.org/files/pdf/specs/os223.pdf
 *
 */
void ErrorHook(void)
{
   ciaaPOSIX_printf("ErrorHook was called\n");
   ciaaPOSIX_printf("Service: %d, P1: %d, P2: %d, P3: %d, RET: %d\n",
       OSErrorGetServiceId(), OSErrorGetParam1(),
       OSErrorGetParam2(), OSErrorGetParam3(), OSErrorGetRet());
   ShutdownOS(0);
}

/**
 *
 * @param error
 */
void ErrorHook( StatusType error ) {

	TaskType task;
	static struct LogBad LogBad[ERROR_LOG_SIZE];
	static uint8_t ErrorCount = 0;
	printf("ErrorHook: %d\r\n", error);
	GetTaskID(&task);


	OsServiceIdType service = OSErrorGetServiceId();

	/* Grab the arguments to the functions
	 * This is the standard way, see 11.2 in OSEK spec
	 */
	switch(service) {
	case OSServiceId_SetRelAlarm:
	{
		// Read the arguments to the faulty functions...
		AlarmType alarm_id = OSError_SetRelAlarm_AlarmId;
		TickType increment = OSError_SetRelAlarm_Increment;
		TickType cycle = OSError_SetRelAlarm_Cycle;
		(void)alarm_id;
		(void)increment;
		(void)cycle;

		// ... Handle this some way.
		break;
	}
	/*
	 * The same pattern as above applies for all other OS functions.
	 * See Os.h for names and definitions.
	 */

	default:
		break;
	}

	LDEBUG_PRINTF("## ErrorHook err=%u\n",Error);

	/* Log the errors in a buffer for later review */
	LogBad[ErrorCount].param1 = os_error.param1;
	LogBad[ErrorCount].param2 = os_error.param2;
	LogBad[ErrorCount].param3 = os_error.param3;
	LogBad[ErrorCount].serviceId = service;
	LogBad[ErrorCount].taskId = task;
	LogBad[ErrorCount].error = error;

	ErrorCount++;

	/* Keep compiler silent */
	(void)LogBad[ErrorCount].param1;

	// Stall if buffer is full.
	while(ErrorCount >= ERROR_LOG_SIZE)
	{

	};
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance9(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(19);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(19,OSServiceId_StartScheduleTableSynchron, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance2(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(9);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(9,OSServiceId_SetEvent , result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance7(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(16);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(16,OSServiceId_GetResource, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance1(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(4);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(4,OSServiceId_ActivateTask, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance6(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(14);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(14,OSServiceId_GetTaskState, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance15(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(32);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(32,OSServiceId_SetRelAlarm, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance3(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(8);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(8,OSServiceId_ChainTask, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance8(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(17);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(17,OSServiceId_NextScheduleTable, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance16(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(33);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT(33,OSServiceId_TerminateApplication, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance10(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(37);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(37, OSServiceId_GetScheduleTableStatus , result_inst_1);
	SCHEDULING_CHECK_AND_EQUAL_INT(37, INVALID_SCHEDULETABLE , OSError_GetScheduleTableStatus_ScheduleTableID());	
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance1(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(8);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(8, INVALID_RESTART , OSError_TerminateApplication_opt());
	SCHEDULING_CHECK_AND_EQUAL_INT(8,OSServiceId_TerminateApplication , result_inst_1);
	
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance6(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(12);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(12,OSServiceId_GetElapsedCounterValue , result_inst_1);
	SCHEDULING_CHECK_AND_EQUAL_INT(12, INVALID_COUNTER , OSError_GetElapsedCounterValue_CounterID());
	
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance6(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(18);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(18,OSServiceId_StartScheduleTableSynchron, result_inst_1);
	SCHEDULING_CHECK_AND_EQUAL_INT(18,sched_explicit, OSError_StartScheduleTableSynchron_ScheduleTableID());
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance2(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(4);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(4,OSServiceId_IncrementCounter , result_inst_1);
	SCHEDULING_CHECK_AND_EQUAL_INT(4, INVALID_COUNTER , OSError_IncrementCounter_CounterID());
	
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance12(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(26);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(26,sched_nosync, OSError_SetScheduleTableAsync_ScheduleTableID());
	SCHEDULING_CHECK_AND_EQUAL_INT(26,OSServiceId_SetScheduleTableAsync, result_inst_1);
		
}

/*test case:test the reaction of the system called with 
 an activation of a task*/
static void test_error_instance5(void)
{
	StatusType result_inst_1;
	
	SCHEDULING_CHECK_INIT(13);
	result_inst_1 = OSErrorGetServiceId();
	SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(13,OSServiceId_StopScheduleTable , result_inst_1);
	SCHEDULING_CHECK_AND_EQUAL_INT(13, INVALID_SCHEDULETABLE , OSError_StopScheduleTable_ScheduleTableID());
	
}