/* MAIN LOOP */ void keyboardScript::doMainLoop() { static int lastCapsState = -1; static int lastNumState = -1; static int lastScrollState = -1; this->fireEvent("onCreate"); uint32_t lastLoopFireTime = 0; while (!this->inErrorState) { auto startTime = timeGetHighResTime(); auto nowTime = startTime; this->fireEvent("onTimer", startTime, lastLoopFireTime); lastLoopFireTime = startTime; startTime = timeGetHighResTime(); /* check for events for the next 200 MS */ do { /* check indicator states */ int capsState = ((GetKeyState(VK_CAPITAL) & 0x0001) != 0) ? INDICATOR_STATE_ON : INDICATOR_STATE_OFF; int numState = ((GetKeyState(VK_NUMLOCK) & 0x0001) != 0) ? INDICATOR_STATE_ON : INDICATOR_STATE_OFF; int scrollState = ((GetKeyState(VK_SCROLL) & 0x0001) != 0) ? INDICATOR_STATE_ON : INDICATOR_STATE_OFF; if (capsState != lastCapsState) this->fireEvent("onIndicatorStateChange", INDICATOR_CAPSLOCK, capsState); if (numState != lastNumState) this->fireEvent("onIndicatorStateChange", INDICATOR_NUMLOCK, numState); if (scrollState != lastScrollState) this->fireEvent("onIndicatorStateChange", INDICATOR_SCROLLOCK, scrollState); lastCapsState = capsState; lastNumState = numState; lastScrollState = scrollState; /* something else might go here */ /* wait a tiny bit before repeating */ Sleep(10); nowTime = timeGetHighResTime(); } while (nowTime - startTime < 100); } }
Uint32 convGetPosition() { Uint32 pos; Uint32 deltaTimeMs; Uint32 speed; Uint32 offset; pos = convObject.unNumTotalTriggerSignals * CONV_MILLIMETERS_PER_TRIGGER; // if standing, the conveyor's position is right before the next // trigger point. if ( convObject.bStanding ) { pos += CONV_MILLIMETERS_PER_TRIGGER; return pos; } // determine current delta time since last trigger signal // conveyor position is at speed * deltatime + last trigger's // position. deltaTimeMs = timeToMs( timeGetHighResTime() - convObject.unLastTicks ); speed = convGetMeasuredSpeed(); offset = ( speed * deltaTimeMs) >> DRVCONV_FRACTIONAL_BITS; //dbgLog("pos %d: deltaMs: %d, speed: %d, pos+:%d", pos, deltaTimeMs, speed, offset ); pos += offset; return pos; }
Uint32 convGetMeasuredSpeed() { Uint32 unDeltaMs; Uint32 unTempDeltaTicks; Uint32 unTempDeltaMs; Uint32 fpTriggersPerSecond; Uint32 fpLastSpeed; // Calculate the last interval in ms. unDeltaMs = timeToMs( convObject.unLastDeltaTicks ); if ( unDeltaMs == 0 ) return 0; // And convert to speed (note: speed is Q.16 format and m/s). fpTriggersPerSecond = (1 << DRVCONV_FRACTIONAL_BITS) * 1000 / unDeltaMs; fpLastSpeed = fpTriggersPerSecond * convObject.unMillimetersPerTrigger / 1000; // If standing, the speed is 0. if ( convObject.bStanding ) return 0; // Determine delta time since last trigger. unTempDeltaTicks = timeGetHighResTime() - convObject.unLastTicks; // If delta is too big, the conveyor is declared to be standing and thus its speed // is 0 as well. if ( timeToMs(unTempDeltaTicks) > convHal.unTimeout ) { //dbgLog("Set to standing because toMs(%ud)=%d > %d", unTempDeltaTicks, timeToMs(unTempDeltaTicks), convHal.unTimeout ); //dbgLog(" unLastTicks = %ud, curTime= %ud", convObject.unLastTicks, timeGetHighResTime() ); convObject.bStanding = TRUE; return 1; } /* // If speed*tempDelta is greater than the distance between two triggers, // reduce speed so that speed = distance / curDeltaTime. unTempDeltaMs = timeToMs(unTempDeltaTicks); if ( ( (unTempDeltaMs * fpLastSpeed)>> DRVCONV_FRACTIONAL_BITS ) > CONV_MILLIMETERS_PER_TRIGGER) { dbgLog("Time: %ud, deltaMs: %u", timeGetHighResTime(), unTempDeltaMs ); dbgLog("Reduced speed because %d > %d. From %f to %f", (unTempDeltaMs * fpLastSpeed) >> DRVCONV_FRACTIONAL_BITS, CONV_MILLIMETERS_PER_TRIGGER, (float)fpLastSpeed / 65536.0, (float)(((1<< DRVCONV_FRACTIONAL_BITS ) * CONV_MILLIMETERS_PER_TRIGGER) / unTempDeltaMs) / 65536.0 ); if ( unTempDeltaMs == 0 ) return 1; fpLastSpeed = ((1<< DRVCONV_FRACTIONAL_BITS ) * CONV_MILLIMETERS_PER_TRIGGER) / unTempDeltaMs; } */ return fpLastSpeed; }
void CClassification::GetStats( ClassificationStats * stats, Bool bReset ) { #ifndef _WINDOWS // ------- Don't compile on windows ----- // First, disable all SWI, so that we're not be disturbed here. There shouldn't // be any critical task running at the moment, since this function will mainly be // called from the control task. // SWI_disable(); // copy all fields if ( stats != NULL ) { stats->unElapsedTime = timeToMs( timeGetHighResTime() - m_sClassificationStats.unElapsedTime ); stats->unNumProcessed = m_sClassificationStats.unNumProcessed; stats->unNumPossible = m_sClassificationStats.unNumPossible; stats->fp16ConveyorSpeed = convGetMeasuredSpeed(); stats->unNumRejectedTotal = m_sClassificationStats.unNumRejectedTotal; stats->unNumRejectedSplit = m_sClassificationStats.unNumRejectedSplit; stats->unNumRejectedColor = m_sClassificationStats.unNumRejectedColor; stats->unNumRejectedGreen = m_sClassificationStats.unNumRejectedGreen; stats->unNumRejectedShape = m_sClassificationStats.unNumRejectedShape; } if ( bReset ) { m_sClassificationStats.unElapsedTime = timeGetHighResTime(); m_sClassificationStats.unNumProcessed = 0; m_sClassificationStats.unNumPossible = 0; m_sClassificationStats.unNumRejectedTotal = 0; m_sClassificationStats.unNumRejectedSplit = 0; m_sClassificationStats.unNumRejectedColor = 0; m_sClassificationStats.unNumRejectedGreen = 0; m_sClassificationStats.unNumRejectedShape = 0; } // SWI_enable(); #endif // ------------------------------------------------ }
void HWI_ConveyorTrigger_funct( void ) { Uint32 unCurrentTicks; // Note: We do all needed stuff directly in th HWI because: // - It's not that much (SEM_post is the most expensive operation, // needing about 182 cycles) // - Starting an SWI would result in more overhead ( SWI_post is // almost as expensive as SEM_post, using 118 cycles without // switching and even more when the switch is performed). // - The rest is neglectable. // Increment the stats gStats.unConvNumTriggers++; // First, measure the interval... unCurrentTicks = timeGetHighResTime(); convObject.unNumTotalTriggerSignals++; // If the conveyor was standing before, this is a special case. if ( convObject.bStanding == TRUE ) { // We set the delta ticks to a very high value, so that the speed will also // be nearly 0. convObject.unLastDeltaTicks = 0x3FFFFFFF; // But, the conveyor is not standing anymore. convObject.bStanding = FALSE; } else { convObject.unLastDeltaTicks = unCurrentTicks - convObject.unLastTicks; } convObject.unLastTicks = unCurrentTicks; // Finally trigger the registered semaphore, if there is one *(convObject.bTrigger) = TRUE; if ( convObject.semTrigger != NULL ) SEM_ipost( convObject.semTrigger ); }
void CClassification::ServiceGenJetCheckCommands( ) { #ifndef _WINDOWS // ------- Don't compile on windows ----- JetCommand cmd; Uint32 unTime; unTime = timeGetHighResTime() + timeFromMs( 50 ); for ( Int i=0; i<MAX_LANES; i++ ) { // clear the command for ( Int i=0; i<JetCommand::MAX_JETS; i++) cmd.aryJetState[i] = FALSE; // activate only one jet cmd.aryJetState[i] = TRUE; cmd.unCmdTime = unTime; // and add the command CJetControl::Instance()->AddCommand( &cmd ); // increase time unTime += timeFromMs( 200 ); } // send a clear all command for ( Int i=0; i<JetCommand::MAX_JETS; i++) cmd.aryJetState[i] = FALSE; cmd.unCmdTime = unTime; CJetControl::Instance()->AddCommand( &cmd ); #endif // ------------------------------------------------ }
void CVisDemoSorterClassifier::DoProcessing() { Uint32 i; m_nNumObjectsClassifier_last = 0; if ( m_pModel == NULL ) return; FastLabelObject * objLabels = (FastLabelObject*)m_iportLabelData.GetBuffer(); ColorObject * objColors = (ColorObject*)m_iportColorData.GetBuffer(); // Get extents of valid area CVisFixpoint fLeft, fRight, fTop, fBottom; m_pModel->GetValidArea( fLeft, fRight, fTop, fBottom ); for ( i=1; i<objLabels[0].unNumObjects; i++) { // Clear the object's flags. objLabels[i].unFlags = 0; // See if the object is valid (i.e. it is in a valid position and has sensibel // sizes. if ( IsObjectValid( objLabels[i] ) ) { // The object is valid. m_nNumObjectsClassified++; m_nNumObjectsClassifier_last++; m_nNumFramesWithoutObjects = 0; // Classify the object. Int nClass = ClassifiyColor( objColors[i].Color.unHue, objColors[i].Color.unSat, objColors[i].Color.unLum ); // Increment count for that class. if ( nClass != -1 ) m_aryColorClasses[nClass].nCount++; // Mark the object as due for ejection if the class is valid and scheduled for ejection. if ( (nClass != -1) && ( m_aryColorClasses[nClass].nEject != 0 ) ) objLabels[i].unFlags |= FLF_EJECT; else objLabels[i].unFlags &= ~FLF_EJECT; } // if object valid } // for all objects // Resolve critical ejections //ResolveCriticalEjections( objLabels ); // Generate ejection commands for ( i=1; i<objLabels[0].unNumObjects; i++) { if ( (objLabels[i].unFlags & FLF_EJECT) != 0 ) EjectObject( objLabels[i] ); } #ifndef _WINDOWS // See if we've seen no objects for a while and turn of the jets if that's the case Uint32 unTime = timeGetHighResTime() + timeFromMs( 10 ); if ( m_nNumFramesWithoutObjects > 25 ) { for ( int i=0; i<m_pModel->GetNumJets(); i++ ) COutputDispatcher::Instance()->Channel( i ).AddCommand( unTime , false ); } #endif }