/* Application's Timer Setup Function */ static void TimerSetup( void ) { DRV_TMR_Alarm16BitRegister(flirData.handleTmrDrv, FLIR_TMR_DRV_PERIOD, FLIR_TMR_DRV_IS_PERIODIC, (uintptr_t)NULL, TimerCallback); DRV_TMR_Start(flirData.handleTmrDrv); }
void hal_tick_init(void){ ledIsOn = false; handleTmr = DRV_TMR_Open(APP_TMR_DRV_INDEX, DRV_IO_INTENT_EXCLUSIVE); if( DRV_HANDLE_INVALID == handleTmr ){ log_error("Timer init failed"); return; } DRV_TMR_Alarm16BitRegister(handleTmr, APP_TMR_ALARM_PERIOD, true, (uintptr_t)NULL, sys_tick_handler); DRV_TMR_Start(handleTmr); SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, APP_LED_PORT, APP_LED_PIN); }
void SYS_TMR_Tasks ( SYS_MODULE_OBJ object ) { SYS_TMR_OBJECT* pTmrObject = (SYS_TMR_OBJECT*)object; // sanity check we're still here if(pTmrObject != &sSysTmrObject) { // no valid handle return; } switch ( sSysTmrObject.status ) { case SYS_STATUS_BUSY: // Performing the initialization // Try to open a TMR driver sSysTmrObject.driverHandle = DRV_TMR_Open ( sSysTmrObject.drvIndex, DRV_IO_INTENT_EXCLUSIVE ); if ( sSysTmrObject.driverHandle == DRV_HANDLE_INVALID ) { // spin here until the driver is opened break; } // try to set up the pservice parameters if(!_SYS_TMR_Setup(&sSysTmrObject)) { // some parameter error occurred sSysTmrObject.status = SYS_STATUS_ERROR; break; } // success /* Set the alarm */ DRV_TMR_Alarm16BitRegister ( sSysTmrObject.driverHandle, sSysTmrObject.driverPeriod, true, (uintptr_t)&sSysTmrObject, _SYS_TMR_AlarmCallback ); /* Start the timer */ DRV_TMR_Start ( sSysTmrObject.driverHandle ); /* Status of the state machine is changed to indicate initialization complete */ sSysTmrObject.status = SYS_STATUS_READY; break; case SYS_STATUS_READY: /* If there is no activity we need not run the loop */ #if (SYS_TMR_INTERRUPT_NOTIFICATION) // block user access; we may delete clients _UserGblLock(); _SYS_TMR_ProcessIsrClients(); _UserGblUnlock(); #else if ( sSysTmrObject.alarmReceived == true ) { sSysTmrObject.alarmReceived = false; // block user access; we may delete clients _UserGblLock(); _SYS_TMR_ProcessTmrAlarm(); _UserGblUnlock(); } #endif // (SYS_TMR_INTERRUPT_NOTIFICATION) break; default: // SYS_STATUS_ERROR // do nothing break; } }
void APP_Tasks ( void ) { /* Check the application's current state. */ switch ( appData.state ) { /* Application's initial state. */ case APP_STATE_INIT: { tmrInterruptHandle = DRV_TMR_Open(DRV_TMR_INDEX_0, DRV_IO_INTENT_EXCLUSIVE); if (DRV_HANDLE_INVALID == tmrInterruptHandle) { // Unable to open the driver while(1); } // based on 80MHz Tpb and 256 PS should be 8192Hz frequency DRV_TMR_AlarmRegister(tmrInterruptHandle, 38, true, 0, TimerInterruptCallback); // change state appData.state = APP_STATE_SETUP_OC; break; } case APP_STATE_SETUP_OC: { DRV_OC0_Enable(); DRV_OC0_Start(); // setup the Timer for OC1 module PLIB_TMR_PrescaleSelect(TMR_ID_2, TMR_PRESCALE_VALUE_1); PLIB_TMR_Period16BitSet(TMR_ID_2, 9765); // start Timer DRV_TMR_Start(tmrInterruptHandle); PLIB_TMR_Start(TMR_ID_2); // change state appData.state = APP_STATE_IDLE; break; } case APP_STATE_IDLE: { break; } /* TODO: implement your application state machine.*/ /* The default state should never be executed. */ default: { /* TODO: Handle error in application's state machine. */ break; } } }
void APP_Initialize ( void ) { /* Place the App state machine in its initial state. */ appData.state = APP_STATE_INIT; // set the direction of the pins and Open the Timer MyHandleIsr = DRV_TMR_Open( DRV_TMR_INDEX_0, DRV_IO_INTENT_EXCLUSIVE ); // calculate the divider value and register the ISR uint32_t desiredFrequency = 10 ; // 10 hertz uint32_t actualFrequency = DRV_TMR_CounterFrequencyGet(MyHandleIsr) ; uint32_t divider = actualFrequency/desiredFrequency; // cacluate divider value DRV_TMR_AlarmRegister(MyHandleIsr, divider, true, 0 , MyISR); // Starting the Timer DRV_TMR_Start(MyHandleIsr); TRISAbits.TRISA0 = 0; LATAbits.LATA0 = 0; /* TRISCbits.TRISC2 = 1; ANSELCbits.ANSC2 = 1; AD1CAL1 = DEVADC1; // Writing Calibration-Data to ADC-Registers AD1CAL2 = DEVADC2; AD1CAL3 = DEVADC3; AD1CAL4 = DEVADC4; AD1CAL5 = DEVADC5; AD1CON1 = 0; // First Clear AD1CON1-Register AD1CON1bits.STRGSRC = 1; // Scan Trigger Src = Global Software Trigger (GSWTRG) AD1CON1bits.FILTRDLY = 0b11111 ; AD1CON2 = 0; // Clear AD1CON2-Register AD1CON2bits.ADCSEL = 1; // ADC Clock-Src = SYSCLK (200 MHz) AD1CON2bits.ADCDIV = 4; // Clock Divider 4 means (8*TQ) = 25 MHz AD1CON2bits.SAMC = 32; // S&H-Sample Time = 32TAD AD1CON3 = 0; // Clear AD1CON3-Register AD1CON3bits.VREFSEL = 3; AD1IMOD = 0; // All SampleAndHold-Units set to Standard-values // Single-ended Inputs with unsigned integer-Format, Standard-Inputs //AD1IMODbits.SH3ALT = 1; // Alternate Input for Sample And Hold 3 (uses normalla AN3, now AN48 - maybe this has blocked AN3??) AD1GIRQEN1 = 0; // No Interrupts used AD1GIRQEN2 = 0; // No Interrupts AD1CSS1 = 0; // First Clear all Channel-Scan-Select-Bits (Register 1) AD1CSS2 = 0; // Clear all CSS-Bits of Register 2 //AD1CSS1bits.CSS21 = 1; // Select CSS3 = AN3 for ChannelScan AD1CMPCON1 = 0; // No Comperator-Functions AD1CMPCON2 = 0; AD1CMPCON3 = 0; AD1CMPCON4 = 0; AD1CMPCON5 = 0; AD1CMPCON6 = 0; AD1FLTR1 = 0; // No Filter / Oversampling AD1FLTR2 = 0; AD1FLTR3 = 0; AD1FLTR4 = 0; AD1FLTR5 = 0; AD1FLTR6 = 0; AD1TRG1 = 0; // No Triggers AD1TRG2 = 0; // No Triggers AD1TRG3 = 0; // No Triggers AD1TRG2bits.TRGSRC7 = 1; // Trigger for AN3 = STRIG (because AN3 is a Channel1-Input!) AD1CON1bits.ADCEN = 1; // Enable ADC while (AD1CON2bits.ADCRDY == 0); // Wait for end of Calibration */ /* TODO: Initialize your application's state machine and other * parameters. */ }
void APP_Tasks ( void ) { switch ( appData.state ) { case APP_STATE_INIT: { if(appData.status.ready) { appData.state = APP_STATE_RUN; break; } if(appData.status.SPIReady==false) { appData.LED.SPIHandle = DRV_SPI_Open(DRV_SPI_INDEX_0, DRV_IO_INTENT_EXCLUSIVE | DRV_IO_INTENT_WRITE | DRV_IO_INTENT_NONBLOCKING ); appData.status.SPIReady = ( DRV_HANDLE_INVALID != appData.LED.SPIHandle ); } if(appData.status.TimerDriverReady==false) { appData.timer.driver.handle = DRV_TMR_Open( DRV_TMR_INDEX_0, DRV_IO_INTENT_READWRITE|DRV_IO_INTENT_EXCLUSIVE); appData.status.TimerDriverReady = (appData.timer.driver.handle != DRV_HANDLE_INVALID); } if(appData.status.SPIReady && appData.status.TimerDriverReady) { appData.LED.start=0; appData.state=APP_STATE_TIMER_START; } break; } case APP_STATE_TIMER_START: { if(DRV_TMR_AlarmRegister(appData.timer.driver.handle, DRV_TMR_CounterFrequencyGet(appData.timer.driver.handle)/25, true, 0, &TimerCallback) ) { if(DRV_TMR_Start(appData.timer.driver.handle)) { appData.status.ready=true; appData.state=APP_STATE_RUN; } } break; } case APP_STATE_RUN: { if(!SendingToStrip()) { APP_TASKS_ACTIVITY_SET; PopulateStrip(&appData.LED); appData.state=APP_STATE_SEND_STRIP; } break; } case APP_STATE_SEND_STRIP: { if(appData.status.readyForNext) { appData.status.readyForNext=false; SendLEDStrip(&appData.LED); /* write each pixel out to the SPI buffer */ /* give the data over to the SPI system to send to the LED strip */ appData.state=APP_STATE_WAIT; APP_TASKS_ACTIVITY_CLEAR; } break; } case APP_STATE_WAIT: { /* wait for the SPI transaction to finish. */ if(SendingToStrip()) { break; } appData.LED.start++; appData.state=APP_STATE_RUN; break; } case APP_STATE_ERROR: { break; } default: { /* shouldn't get here. */ APP_Initialize(); break; } } if(appData.activityLED.blinkCount++>appData.activityLED.interval) { mActivityLEDInvert(); appData.activityLED.blinkCount=0; } }