void Engine_run()
{
double timestart = glfwGetTime();
int fps = 0;
time = Timer_getTime();
while(!done)
{
Timer_update();
time = Timer_getTime();
Input_handleInput(time);
World_refresh();
Logic_update(time);
Physics_update(theworld);
Physics_detectCollisions(theworld);
Logic_handleCollisions(theworld);
Graphics_renderScene(theworld);
Graphics_refresh();
fps++;
if (glfwGetTime() - timestart >= 1.0)
{
fprintf(stderr, "Fps: %i, Objects: %u, Collision checks: %i, Script calls: %i\n", fps, World_getObjectCount(), Physics_getCheckCounter(), Script_getCallCounter());
Physics_resetCheckCounter();
Script_resetCallCounter();
fps = 0;
timestart = glfwGetTime();
}
glfwSleep(0.033);
}
WorldObject_destroy(theworld);
}
/*
** ===================================================================
** Method : SensorHandler
** Description : Checkea si hay un nuevo valor del AD,
** y si lo hay lo procesa.
** ===================================================================
*/
void SenRpm_procesar(void* _self){
struct SensorRpm *_s=(struct SensorRpm *)_self;
int filtro = _s->conf->iFiltro;
ulong valProv=0;
float val_f=0;
ulong microseg=0;
uint pulsos=0;
uint mult=0;
uchar err;
if(_s->procesar==TRUE){
_s->procesar=FALSE;
microseg=CapturadorPT2_getMicroSegundos(_s->capturador); //(_s->capturador->ultimoproceso.microsegundos);//
pulsos=CapturadorPT2_getPulsos(_s->capturador); //_s->capturador->ultimoproceso.pulsos;//
mult= 600 * pow10(_s->conf->iDecimales); //600 6000 o 60000
if(microseg!=0){
valProv=(ulong)pulsos*mult;
val_f=valProv/(((float)_s->conf->pulsosPorVuelta)*microseg/100000);
val_f=(val_f*SenRpm_getAjusteGanancia(_s))/(float)1000;
valProv = val_f;
if(valProv<65535){
valProv= filtrarL (valProv,filtro,10,200,&buffer);
Cpu_DisableInt();
_s->procVal=(long)valProv;
buffer=valProv;
_s->bufferFiltro=valProv;
_s->state=RPM_OK;
_s->ContadorUf=0;
Cpu_EnableInt();
} else{
Cpu_DisableInt();
_s->state=RPM_OF;
Cpu_EnableInt();
}
}else {
if(_s->ContadorUf<RPM_MAX_UF_COUNT){
_s->ContadorUf++;
_s->state=RPM_OK;
valProv=(ulong)100*mult/(_s->conf->pulsosPorVuelta*_s->ContadorUf*Timer_getTime(&_s->timerMuestreo)); //calculo cual seria el valor de rpm si hubiese entrado un solo pulso
//Nuevo
valProv= filtrarL (valProv,filtro,10,200,& _s->bufferFiltro);
//Fin Nuevo
if(_s->procVal>valProv)
_s->procVal=valProv; //redusco el valor de rpms
}else{
_s->procVal=filtrarL (0,filtro,10,200,& _s->bufferFiltro);
}
}
setValCalculado(valProv,0);
}
}
/**
Start a timer.
Specify if you'd like the timer to repeat and, if so, the interval at which
you'd like it to repeat. If you have set up a handler with setHandler() then your
handler function will get called at the specified interval. If the timer is already
running, this will reset it.
@param millis The number of milliseconds
@param repeat Whether or not to repeat - true by default.
*/
int Timer_start( Timer *timer, int millis, bool repeat, bool freeOnStop )
{
// debug
if (millis < 0) {
panic("Timer_start");
return CONTROLLER_ERROR_ILLEGAL_PARAMETER_VALUE;
}
//timer->started = timeval;
timer->started = Timer_tick_count();
timer->value = millis;
timer->timeCurrent = 0;
timer->timeInitial = millis * TIMER_CYCLES_PER_MS;
timer->repeat = repeat;
timer->freeOnStop = freeOnStop;
Timer *nextEntry = timer->next;
timer->next = NULL;
TRACE_TMR(">>Timer_start %x %d %d %d %d\r\n", timer, millis, repeat, freeOnStop, timer_manager.servicing);
// this could be a lot smarter - for example, modifying the current period?
if (sync && !timer_manager.servicing ) {
Task_enterCritical();
//xSemaphoreTake(timer_mutex, -1);
}
TIMER_DBG_PROCESSING(true);
if ( !timer_manager.running )
{
// Timer_SetActive( true );
Timer_setTimeTarget( timer->timeInitial );
Timer_enable();
}
/*
// Calculate how long remaining
int target = Timer_getTimeTarget();
int timeCurrent = Timer_getTime();
int remaining = target - timeCurrent;
TRACE_TMR("t %d tc %d r %d\r\n", target, timeCurrent, remaining);
*/
// Get the entry ready to roll
timer->timeCurrent = timer->timeInitial;
// Add entry
Timer* first = timer_manager.first;
timer_manager.first = timer;
timer->next = first;
// Are we actually servicing an interupt right now?
if ( !timer_manager.servicing )
{
TRACE_TMR("srv 0\r\n");
// No - so does the time requested by this new timer make the time need to come earlier?
// first, unlink the timer
Timer *te = timer;
while (te) {
if (te->next && te->next == timer) {
te->next = nextEntry;
TRACE_TMR("Unlinking from the list %x\r\n", nextEntry);
break;
}
te = te->next;
}
// Calculate how long remaining
int target = Timer_getTimeTarget();
int timeCurrent = Timer_getTime();
int remaining = target - timeCurrent;
TRACE_TMR("t %d tc %d r %d\r\n", target, timeCurrent, remaining);
TRACE_TMR("%d < %d %d\r\n", timer->timeCurrent, remaining, TIMER_MARGIN);
if ( timer->timeCurrent < ( remaining - TIMER_MARGIN ) )
{
// Damn it! Reschedule the next callback
Timer_setTimeTarget( target - ( remaining - timer->timeCurrent ));
TRACE_TMR("%x rc %d cv %d\r\n", timer, timer_manager.tc->TC_RC, timer_manager.tc->TC_CV);
// pretend that the existing time has been with us for the whole slice so that when the
// IRQ happens it credits the correct (reduced) time.
timer->timeCurrent += timeCurrent;
}
else
{
// pretend that the existing time has been with us for the whole slice so that when the
// IRQ happens it credits the correct (reduced) time.
timer->timeCurrent += timeCurrent;
TRACE_TMR("sch %d\r\n", timer->timeCurrent);
}
}
else
{
TRACE_TMR("srv 1\r\n");
// Yep... we're servicing something right now
// Make sure the previous pointer is OK. This comes up if we were servicing the first item
// and it subsequently wants to delete itself, it would need to alter the next pointer of the
// the new head... err... kind of a pain, this
if ( timer_manager.previous == NULL )
timer_manager.previous = timer;
// Need to make sure that if this new time is the lowest yet, that the IRQ routine
// knows that. Since we added this entry onto the beginning of the list, the IRQ
// won't look at it again
if ( timer_manager.nextTime == -1 || timer_manager.nextTime > timer->timeCurrent )
timer_manager.nextTime = timer->timeCurrent;
}
TIMER_DBG_PROCESSING(false);
if (sync && !timer_manager.servicing ) {
Task_exitCritical();
//xSemaphoreGive(timer_mutex);
}
TRACE_TMR("<<Timer_start %x\r\n", timer);
return CONTROLLER_OK;
}
/*
** ===================================================================
** Method : SenRpm_getTiempoMedicion
** Description : Obtiene el periodo en que se toman las muestras
** ===================================================================
*/
uint SenRpm_getTiempoMuestreo(void* _self){
struct SensorRpm *_s=(struct SensorRpm *)_self;
return Timer_getTime(&_s->timerMuestreo);
}
ulong MTimer_getTime(struct MethodTimer* t){
return Timer_getTime((t->_base));
}
