void Context::clear() { TimerStart("clear"); #ifdef _CTXH ObjectMap::Entry *entry = mVars.first(); while (entry) { if (entry->second) { if (entry->second->refCount() <= 0) { std::ostringstream oss; oss << "*** Object in context has already been deleted"; throw std::runtime_error(oss.str()); } entry->second->decRef(); } entry = mVars.next(); } #else ObjectMap::iterator it = mVars.begin(); while (it != mVars.end()) { if (it->second) { if (it->second->refCount() <= 0) { std::ostringstream oss; oss << "*** Object \"" << it->first << "\" in context has already been deleted"; throw std::runtime_error(oss.str()); } it->second->decRef(); } ++it; } #endif mVars.clear(); TimerEnd("clear"); }
void PapStart(Link l, int which) { PapInfo pap = &l->lcp.auth.pap; switch (which) { case AUTH_PEER_TO_SELF: /* Just wait for peer's request */ break; case AUTH_SELF_TO_PEER: /* Initialize retry counter and timer */ pap->next_id = 1; pap->retry = AUTH_RETRIES; TimerInit(&pap->timer, "PapTimer", l->conf.retry_timeout * SECONDS, PapTimeout, l); TimerStart(&pap->timer); /* Send first request */ PapSendRequest(l); break; default: assert(0); } }
/*! * \brief MCPS-Confirm event function * * \param [IN] mcpsConfirm - Pointer to the confirm structure, * containing confirm attributes. */ static void McpsConfirm( McpsConfirm_t *mcpsConfirm ) { if( mcpsConfirm->Status == LORAMAC_EVENT_INFO_STATUS_OK ) { switch( mcpsConfirm->McpsRequest ) { case MCPS_UNCONFIRMED: { // Check Datarate // Check TxPower break; } case MCPS_CONFIRMED: { // Check Datarate // Check TxPower // Check AckReceived // Check NbTrials break; } case MCPS_PROPRIETARY: { break; } default: break; } // Switch LED 1 ON GpioWrite( &Led1, 1 ); TimerStart( &Led1Timer ); } NextTx = true; }
/********************************************************************** * TimerTest * Description: Basic test of timer functionality * Notes: Uses 1 timer slot - cannot be unregistered, only use for * testing and debugging. ***********************************************************************/ void TimerTest( void) { uint8_t t1 = 0; t1 = RegisterTimer(); //register the timer TimerStart(t1, 1000L); //starts t1, 1 second interval LED0_ON; //turn on the LED while(TimerIsOn(t1)); //wait until timer has finished //SAME THING FOR LED OFF TimerStart(t1, 1000L); //starts t1, 1 second interval LED0_OFF; while(TimerIsOn(t1)); }
static void RicochetMenuHandleEvent (EventPtr event) { switch (event->data.menu.itemID) { case menuRicochetRestart: RicochetRestart (); break; case menuRicochetNext: RicochetNext (); break; case menuRicochetNew: RicochetNext (); break; case menuTimerStart: TimerStart (); break; case menuTimerStop: TimerStop (); break; case menuHelpControls: Help(controlForm); break; case menuHelpRules: Rules (); break; case menuHelpGetInfo: Help(infoForm); break; } }
/*----------------------------------------------------------------------------- * main */ int main(void) { uint8_t ret; int sioHdl; /* set clock prescaler to 2 (set clock to 7.3928 MHz) */ CLKPR = 1 << CLKPCE; CLKPR = 1; /* get module address from EEPROM */ sMyAddr = eeprom_read_byte((const uint8_t *)MODUL_ADDRESS); GetClientListFromEeprom(); PortInit(); TimerInit(); ButtonInit(); PwmInit(); ApplicationInit(); SioInit(); SioRandSeed(sMyAddr); /* sio for bus interface */ sioHdl = SioOpen("USART1", eSioBaud9600, eSioDataBits8, eSioParityNo, eSioStopBits1, eSioModeHalfDuplex); SioSetIdleFunc(sioHdl, IdleSio1); SioSetTransceiverPowerDownFunc(sioHdl, BusTransceiverPowerDown); BusTransceiverPowerDown(true); BusInit(sioHdl); spBusMsg = BusMsgBufGet(); /* warten for full operation voltage */ while (!POWER_GOOD); /* enable ints before RestorePwm() */ ENABLE_INT; TimerStart(); RestorePwm(); /* ext int for power fail: INT0 low level sensitive */ EICRA &= ~((1 << ISC01) | (1 << ISC00)); EIMSK |= (1 << INT0); ApplicationStart(); /* Hauptschleife */ while (1) { Idle(); ret = BusCheck(); ProcessBus(ret); CheckButton(); PwmCheck(); ApplicationCheck(); CheckEvent(); } return 0; }
/******************************************************************** Function name: TimerUpdate Input parameters: Return: Function: ********************************************************************/ void TimerUpdate(UINT32 TimerCnt) { TimerStop(T0); TimerValSet(T0, TimerCnt); TimerCpltFlagClr(T0); TimerStart(T0); TimerDoneChk(T0); }
static void TimerToggle (void) { if (game.timer_running) TimerStop (); else TimerStart (); }
virtual void Init(RobotInfo ri, NavInfo ni) { pid_trace_.Init(); if (0 < timer_) { TimerStart(timer_); } local_status_ = MISSION_START; }
/************************************************* Function: LogicInit Description: Input: Output: Return: Others: *************************************************/ void LogicInit(void) { HarewareInit(); StorageInit(); GuiInit(); SetBeepIndex(_HW_BEEP_OK_); TimerStart(); LogicSetMasterCtl(FRAME_ADDR_PC); }
/*! * \brief Function executed on ultrasonic sensor timeout event * If range and temperature readings not available in reasonable time * sends sensor data with range and temperature in error */ static void OnUltrasonicTimeout ( void ) { pc.printf("OnUltrasonicTimeout - Sensor FAULT\r\n"); SensorState = FAULT; NextTx = true; TimerSetValue( &TxNextPacketTimer, 100 ); // Schedule immediate transmission TimerStart( &TxNextPacketTimer ); }
/*! * task to blink led rtos between 1 seconds. */ void task_led_rtos( task_param_t param ) { TimerInit(&Led1Timer, "Led1Timer", 250, OnLed1TimerEvent, false); TimerInit(&Led2Timer, "Led2Timer", 250, OnLed2TimerEvent, false); TimerInit(&Led3Timer, "Led3Timer", 250, OnLed3TimerEvent, false); // Switch LED 1 ON GpioWrite(&Led1, 0); TimerStart(&Led1Timer); while (1) { if ( Led1TimerEvent == true ) { Led1TimerEvent = false; // Switch LED 1 OFF GpioWrite(&Led1, 1); // Switch LED 2 ON GpioWrite(&Led2, 0); TimerStart(&Led2Timer); } if ( Led2TimerEvent == true ) { Led2TimerEvent = false; // Switch LED 2 OFF GpioWrite(&Led2, 1); // Switch LED 3 ON GpioWrite(&Led3, 0); TimerStart(&Led3Timer); } if ( Led3TimerEvent == true ) { Led3TimerEvent = false; // Switch LED 3 OFF GpioWrite(&Led3, 1); // Switch LED 1 ON GpioWrite(&Led1, 0); TimerStart(&Led1Timer); } OSA_TimeDelay(50); } }
virtual void Init(RobotInfo ri, NavInfo ni){ pid_trace_.Init(); straight_.Init(ri); TimerStart(1000); speed_ = 70; local_status_ = P_START; dist.x = ni.pos.X; dist.y = ni.pos.Y; dist.xy = (dist.x * dist.x) + (dist.y * dist.y); }
void osTimerInterruptInitialize(void) { /* ************ BEGIN TARGET SPECIFIC SECTION **************/ TimerInterval(0); (VPint(TDATA(0))) = gBUSCLK/100; TimerStart(0); Enable_Int(TIMER0_INT); /* ************ END TARGET SPECIFIC SECTION **************/ }
/***************************************************************** * init timer1 * Init timer hardware if needed here ******************************************************************/ void InitTimers(void) { //SETUP ANY HARDWARE AS NEEDED //CHECKOUT THE TIMERS THAT WILL BE USED IN THE SYSTEM timer_pb = RegisterTimer(); //register the timer //START THE TIMERS IF THEY ARE FREE RUNNING TimerStart(timer_pb, TIME_PB0); //restart the time }
static void PapTimeout(void *ptr) { Link const l = (Link) ptr; PapInfo const pap = &l->lcp.auth.pap; if (--pap->retry > 0) { TimerStart(&pap->timer); PapSendRequest(l); } }
int TestMod11A(PDOT11_MOD_ARGS pArgs) { BB11A_TX_VECTOR TxVector; BB11ATxContextInit(&TxVector, pArgs->SampleRate); if (!Dot11ARate_KbpsValid(pArgs->nBitRate)) { printf("Data rate %d kbps is not supported by 802.11a mode\n", pArgs->nBitRate); return -1; } TxVector.ti_uiDataRate = Dot11ADataRate_Kbps2Code(pArgs->nBitRate); if (PreparePacket(pArgs->pcInFileName, &Mdl, &Packet, DataBuffer, SymbolBuffer, SYMBOLBUF_SIZE) < 0) return -1; TIMINGINFO ti; double dTimeSum = 0.0; // Cache warm-up for first 2 rounds for (int i = 0; i < 2; i++) { BB11ATxFrameMod(&TxVector, &Packet); } // Measure modulation speed for many rounds TimerStart(&ti); for (int i = 0; i < RUN_TIMES; i++) { BB11ATxFrameMod(&TxVector, &Packet); } TimerStop(&ti); dTimeSum = TimerRead(&ti) * 1000; printf("Signal data rate: %d kbps\n", Dot11ADataRate_Code2Kbps(TxVector.ti_uiDataRate)); printf("Signal packet size: %d\n", Packet.PacketSize); printf("Signal encoded size: %d\n", Packet.Reserved3); printf("Time cost average: %.3f us \n", dTimeSum / RUN_TIMES); FILE* pOut = NULL; #pragma warning (push) #pragma warning (disable:4996) pOut = fopen(pArgs->pcOutFileName, "w+b"); #pragma warning (pop) if (!pOut) { printf("Cannot create output file.\n"); return -1; } fwrite(Packet.pReserved, Packet.Reserved3, 1, pOut); fclose(pOut); return 0; }
virtual void Init(RobotInfo ri, NavInfo ni) { pid_trace_.Init(); if (0 < timer_) { TimerStart(timer_); } local_status_ = P_RUN_START; dist.x = ni.pos.X; dist.y = ni.pos.Y; dist.xy = (dist.x * dist.x) + (dist.y * dist.y); }
virtual void Init(RobotInfo ri, NavInfo ni){ tec_s_.Init(ri); tec_p_.Init(); tec_r_.Init(); speed_ = 40; local_status_ = P_REACHING; s_time_ = clock.now(); tecType_ = TEC_P; SeesawAng = ni.pos.Ang; TimerStart(15000); set_current_position(pos, ni); edge_dir = Technic::LEFT; }
void DexVirtualTracker::Initialize( void ) { TimerStart( &oscillate_timer ); manipulandumPosition[X] = 150.0; manipulandumPosition[Y] = 125.0; manipulandumPosition[Z] = 25.0; samplePeriod = 0.5; nAcqFrames = 0; }
static Boolean RicochetKeyHandleEvent (EventPtr event) { Boolean handled = true; switch (event->data.keyDown.chr) { case 'r': case 'R': RicochetRestart(); break; case 'n': case 'N': RicochetNext (); break; case 'g': case 'G': RicochetNew (); break; case 'u': case 'U': RicochetUndo (); break; case 't': case 'T': TimerStart (); break; case 's': case 'S': TimerStop (); break; case 'c': case 'C': Help (controlForm); break; case 'l': case 'L': Rules (); break; case 'i': case 'I': Help (infoForm); break; default: handled = false; break; } return handled; }
// Queue a Trap timer callback to issue a subscribe or unsubscribe // must be called with SubscribedTrapsListLock held static void QueueTrapTimer(TRAP_REFERENCE *pTrapReference, uint32 timeout_ms) { _DBG_ENTER_LVL(_DBG_LVL_FUNC_TRACE, QueueTrapTimer); if (SubscribeInitialized != 0) { // restart timer if running TimerStop(&pTrapReference->Timer); TimerStart(&pTrapReference->Timer, timeout_ms); } _DBG_LEAVE_LVL( _DBG_LVL_FUNC_TRACE ); }
void benchmark(VglImage* img_in, VglImage* img_out, float* mask, int* mask_size, int nSteps, ConvoluteType type, char* operator_name,char* prefix_path, float(*MMD_KERNEL)(float color, float mask_value, float value, ConvoluteType type, float gamma), float gamma = 0.2f) { const float gama = 0.2f; TimerStart(); CONVOLUTE(img_in, img_out, mask, mask_size, type, MMD_KERNEL, gama); if (img_in->ndim == 2) printf("First call to %s %dx%d: %s\n",operator_name,mask_size[0],mask_size[1], getTimeElapsedInSeconds()); else if (img_in->ndim == 3) printf("First call to %s %dx%dx%d: %s\n", operator_name, mask_size[0], mask_size[1], mask_size[2], getTimeElapsedInSeconds()); //Total time spent on n operations FuzzyErode 3x3 int p = 0; TimerStart(); while (p < nSteps) { p++; CONVOLUTE(img_in, img_out, mask, mask_size, type, MMD_KERNEL, gama); //vglClCopy(out,img); } if (img_in->ndim == 2) printf("Time spent on %8d %s %dx%d: %s\n", nSteps, operator_name, mask_size[0], mask_size[1], getTimeElapsedInSeconds()); else if (img_in->ndim == 3) printf("Time spent on %8d %s %dx%d%d: %s\n", nSteps, operator_name, mask_size[0], mask_size[1], mask_size[2], getTimeElapsedInSeconds()); char* outFilename = (char*)malloc(400); if (img_in->ndim == 2) { sprintf(outFilename, "%s/%s_%dx%d.%s", prefix_path, operator_name, mask_size[0], mask_size[1], "tif"); cvSaveImage(outFilename, img_out->ipl); } else if (img_in->ndim == 3) { sprintf(outFilename, "%s/%s_%dx%dx%d.%s", prefix_path, operator_name, mask_size[0], mask_size[1], mask_size[2], "dcm"); vglDcmtkSaveDicom(outFilename, img_out, 0); //vglGdcmSaveDicom(outFilename, img_out, 0); } }
static void OnRadioTxDone( void ) { TimerTime_t curTime = TimerGetCurrentTime(); LOG_TRACE("Transmitted successfully (%u ms).", (uint32_t)(curTime * portTICK_PERIOD_MS)); // Update Band Time OFF Bands[Channels[pLoRaDevice->currChannelIndex].Band].LastTxDoneTime = curTime; if ( pLoRaDevice->dbgFlags.Bits.dutyCycleCtrlOff == 0 ) { Bands[Channels[pLoRaDevice->currChannelIndex].Band].TimeOff = TxTimeOnAir * Bands[Channels[pLoRaDevice->currChannelIndex].Band].DCycle - TxTimeOnAir; } else { Bands[Channels[pLoRaDevice->currChannelIndex].Band].TimeOff = 0; } // Update Agregated Time OFF AggregatedLastTxDoneTime = curTime; AggregatedTimeOff = AggregatedTimeOff + (TxTimeOnAir * AggregatedDCycle - TxTimeOnAir); if ( phyFlags.Bits.TxType == LORAPHY_TXTYPE_ADVERTISING ) { /* Open advertising beacon reception window */ } else if ( phyFlags.Bits.TxType == LORAPHY_TXTYPE_REGULAR && pLoRaDevice->dbgFlags.Bits.rxWindowsDisabled != 1 ) { TimerSetValue(&RxWindow1Timer, pLoRaDevice->rxWindow1Delay); TimerStart(&RxWindow1Timer); TimerSetValue(&RxWindow2Timer, pLoRaDevice->rxWindow2Delay); TimerStart(&RxWindow2Timer); } else { phyFlags.Bits.TxDone = 1; } /* Uplink message repetition is only valid for unconfirmed messages */ if ( pLoRaDevice->ctrlFlags.Bits.ackPending == 0 ) { pLoRaDevice->nbRepCounter++; } }
void MainWindow::AddNewRow() { Variable * var = new Variable(client,this); VariableDialog dlg(var,Map,this); if (dlg.exec() == QDialog::Accepted) { variables.insert(var->GetName(),var); var->connectNewSample(this,SLOT(VariableModified())); RefreshTable(); if (ui->actionConnect->isChecked()) emit TimerStart(); } else { var->deleteLater(); } }
//***************************************************************************** // //! \biref The main example function //! //! \return none // //***************************************************************************** void OneSecondClock(void) { SysCtlHClockSet(SYSCTL_XTAL_12MHZ | SYSCTL_OSC_MAIN); // // Set the timer clock // SysCtlPeripheralClockSourceSet(SYSCTL_PERIPH_TMR0_S_EXT12M); // // Enable tiemr0 // SysCtlPeripheralEnable(SYSCTL_PERIPH_TMR0); // // Clear the flag first // TimerIntClear(TIMER0_BASE, TIMER_INT_MATCH); while(TimerIntStatus(TIMER0_BASE, TIMER_INT_MATCH)); // // Config as One shot mode // TimerInitConfig(TIMER0_BASE, TIMER_MODE_PERIODIC, 1000); TimerPrescaleSet(TIMER0_BASE, 91); TimerMatchSet(TIMER0_BASE, 0x1ffff); TimerIntEnable(TIMER0_BASE, TIMER_INT_MATCH); // // Start the timer // TimerStart(TIMER0_BASE); // // One shot mode test. // while(1) { // // wait until the timer data register reach equel to compare register // while(!TimerIntStatus(TIMER0_BASE, TIMER_INT_MATCH)); TimerIntClear(TIMER0_BASE, TIMER_INT_MATCH); } }
void main(void) { unsigned long Status = 0; /********************** Configure System clock *************************/ SysCtlClockSet(100000000, SYSCTL_OSC_INT | SYSCTL_XTAL_12_MHZ); SysCtlDelay(TICK_SLOW); // Enable LED PORT SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); // Configure LED(PC3) pin into output mode. xGPIOSPinTypeGPIOOutput(PC3); // Configure Timer Capture pin(PB26) GPIOPinFunCfg(GPIOB_BASE, GPIO_PIN_26, GPIO_PB26_TIMCCP0); TimerCounterCfg(TIMER0_BASE, TIMER_CFG_CNT_CAP0_BOTH); TimerReset(TIMER0_BASE); TimerStart(TIMER0_BASE); while (1) { if( (TimerValueGet(TIMER0_BASE) % 10) == 0) { if(Status) { // Turn on LED Status = 0; GPIOPinSet(GPIOC_BASE, GPIO_PIN_3); } else { // Turn off LED Status = 1; GPIOPinClr(GPIOC_BASE, GPIO_PIN_3); } } } while(1); }
int main( void ) { SystemInit(); SystemCoreClockUpdate(); TimerInit(); TimerStart(); { printf( "test_max_alc=%i \n", test_max_alc() ); printf( "test_alc_free_max=%i \n", test_alc_free_max() ); printf( "test_static_alc_free=%i \n", test_static_alc_free() ); printf( "test_static_alc_free_violation=%i \n", test_static_alc_free_violation() ); printf( "test_rndm_alc_free=%i \n", test_rndm_alc_free() ); printf( "test_max_alc_1_byte=%i \n", test_max_alc_1_byte() ); } TimerStop(); printf( "The elappsed time is %d ms\n", current_elapsed_time() ); while(1); }
int main(int argc, char *argv[]) { char **av, fname[STRLEN] ; int ac, nargs, i ; char *in_fname, *out_fname ; int msec, minutes, seconds ; struct timeb start ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: main_template.c,v 1.5 2011/03/02 00:04:40 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; TimerStart(&start) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 3) usage_exit(1) ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; fprintf(stderr, "inverse operator application took %d minutes" " and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
/*------------------------------------------- "Start" button ---------------------------------------------*/ void OnOK(HWND hDlg) { PTIMERSTRUCT pitem; char section[20]; int i, nOldTimer; /* save settings */ GetTimerFromDlg(hDlg, get_listitem(m_pTimer, m_nCurrent)); nOldTimer = GetMyRegLong(NULL, "TimerNum", 0); pitem = m_pTimer; for(i = 0; pitem; i++) { wsprintf(section, "Timer%d", i + 1); SetMyRegStr(section, "Name", pitem->name); SetMyRegLong(section, "Minute", pitem->minute); SetMyRegLong(section, "Second", pitem->second); SetMyRegStr(section, "File", pitem->fname); SetMyRegLong(section, "Repeat", pitem->bRepeat); SetMyRegLong(section, "Blink", pitem->bBlink); SetMyRegLong(section, "Disp", pitem->bDisp); SetMyRegLong(section, "DispType", pitem->nDispType); SetMyRegLong(section, "UserStr", pitem->nUserStr); pitem = pitem->next; } SetMyRegLong(NULL, "TimerNum", i); for(; i < nOldTimer; i++) { wsprintf(section, "Timer%d", i + 1); DelMyRegKey(section); } /* start a timer */ TimerStart(get_listitem(m_pTimer, m_nCurrent)); DestroyWindow(hDlg); }