static bool _SYS_TMR_Setup(SYS_TMR_OBJECT* tmrObject)
{
uint32_t drvFreq, drvPeriod, errorFreq;
uint32_t tickFreq, tickUnitCount;
// sanity check, protect against user error
if(sSysTmrObject.sysTickFreq == 0 || SYS_TMR_UNIT_RESOLUTION < 1000 || SYS_TMR_UNIT_RESOLUTION / sSysTmrObject.sysTickFreq < 1 )
{
return false;
}
drvFreq = DRV_TMR_CounterFrequencyGet ( tmrObject->driverHandle );
// sanity check that we can obtain the requested frequency
// with the underlying 16 bit timer (period = [2, 0xffff]);
drvPeriod = drvFreq / tmrObject->sysTickFreq - 1;
if(drvPeriod < 1 || drvPeriod > 0xffff)
{ // required freq not within obtainable range
return false;
}
// calculate the actual tick frequency
tickFreq = drvFreq / (drvPeriod + 1);
// check we're within requested limits
if(tickFreq >= tmrObject->sysTickFreq)
{
errorFreq = tickFreq - tmrObject->sysTickFreq;
}
else
{
errorFreq = tmrObject->sysTickFreq - tickFreq;
}
if((errorFreq * 100) / tmrObject->sysTickFreq > SYS_TMR_FREQUENCY_TOLERANCE)
{ // too great an error
return false;
}
// calculate the timer units
tickUnitCount = SYS_TMR_UNIT_RESOLUTION / tickFreq;
if(tickUnitCount < 1)
{ // not enough resolution
return false;
}
// success
tmrObject->sysTickFreq = tickFreq;
tmrObject->sysTickUnitCount = tickUnitCount;
tmrObject->driverFreq = drvFreq;
tmrObject->driverPeriod = drvPeriod;
return true;
}
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;
}
}
