/******************************************************************************
 *                                                                            *
 *                        evolving systems consulting                         *
 *                          http://www.evolvsys.cz                            *
 *                                                                            *
 *                           ALL RIGHTS RESERVED                              *
 *                                                                            *
 ******************************************************************************/
/** @file
 *  Free RTOS starter object. Launch Free RTOS in Windows separate thread.
 *  Compiler: MSVC, Borland C++ Builder, GCC, MinGW
 *
 * $HeadURL: svn://213.165.82.37/UAV_UCS_GUI_IVC/SW/src/FreeRTOSrunner.cpp  $
 * $Revision: 563 $
 * $Date: 2015-07-31 20:12:13 +0200 (pá, 31 VII 2015) $
 * $Author: escsro026 $ */
#if defined(_WIN32) || defined(_WIN64)
 #include <Windows.h>
 #include <process.h>
#else  /* ! _WIN32 */
 #define Sleep(_time_ms) usleep(1000*(_time_ms))
 #include <string.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
#endif
#include "csext.h"

/* Free RTOS Kernel includes. */
#include <FreeRTOS.h>
#include "task.h"

#include "dtp_cfg.h"
#include "FreeRTOSrunner.h"
#include "rtos2.h"


CritSectionWrapper CRIT_MESSAGE_PRINTER;
extern "C" {
extern void *pvInterruptEventMutex;
}


void LOCK_MESSAGE_PRINTER(void)
{
  CRIT_MESSAGE_PRINTER.Lock();
}

void UNLOCK_MESSAGE_PRINTER(void)
{
  CRIT_MESSAGE_PRINTER.Unlock();
}


////////////////////////////////////////////////////////////

FreeRTOSrunner::FreeRTOSrunner(void)
{  
  ThreadDoJob = false;
  WorkerHandle = 0;
#ifdef _WIN32
  Semaphore = CreateEvent(NULL, TRUE, TRUE, NULL);
#else
  pthread_mutex_init(&Semaphore, NULL);
#endif
}


FreeRTOSrunner::~FreeRTOSrunner()
{
 if(WorkerHandle!=0)
 {
   ThreadDoJob = false;			//< Schedule stop thread.
   WaitForSingleObject(WorkerHandle, 100);
   //vTaskEndScheduler();	// Should be called from RTOS threads

   if(WAIT_TIMEOUT==WaitForSingleObject(WorkerHandle, 1200))
   {
     //if(pvInterruptEventMutex!=NULL) ReleaseMutex(pvInterruptEventMutex);
     if(WAIT_TIMEOUT==WaitForSingleObject(WorkerHandle, INFINITE))
     {     
       //LogMessage(LOG_ERROR,_("Datapool receiving thread hanged - must be killed.")).Print();
       TerminateThread(WorkerHandle,-1);
     }
   }

   CloseHandle(WorkerHandle);
   WorkerHandle = 0;
   ThreadID = 0;   
 }
}


void FreeRTOSrunner::StartThread(void)
{
#ifdef _WIN32
  unsigned int ThreadID;
  if(WorkerHandle==0)
      WorkerHandle = (HANDLE)_beginthreadex(NULL, 0, FreeRTOSworker, this, 0, &ThreadID);
#else
  pthread_create(&WorkerHandle, NULL, WorkerThreadUDP, this);
#endif
}


THR_RET_TYPE FreeRTOSrunner::FreeRTOSworker(void *pObject)
{
  if(pObject!=NULL)
  {
    RTOS_STATE = RTOS_RUNNING;
    try{vTaskStartScheduler();}		/* Start the scheduler itself. */
    catch(...){}
    RTOS_STATE = RTOS_UNITIALISED;
  }
TerminateThread(GetCurrentThread(), 0);	// This ensures signalisation WaitForSingleObject(WorkerHandle, INFINITE);
return 0;
}