//*****************************************************************************
//
// This is the handler for the ADC interrupt. Even though more than one
// sequencer is used, they are configured so that this one runs last.
// Therefore when this ADC sequencer interrupt occurs, we know all of the ADC
// data has been acquired.
//
//*****************************************************************************
void
ADC0SS0Handler(void)
{
//
// Clear the interrupts for all ADC sequencers that are used.
//
MAP_ADCIntClear(ADC0_BASE, 0);
MAP_ADCIntClear(ADC1_BASE, 0);
//
// Retrieve the data from all ADC sequencers
//
MAP_ADCSequenceDataGet(ADC0_BASE, 0, &g_pui32ADCData[0]);
MAP_ADCSequenceDataGet(ADC1_BASE, 0, &g_pui32ADCData[8]);
//
// Set the time stamp, assume it is what was set for the last match
// value. This will be close to the actual time that the samples were
// acquired, within a few microseconds.
//
g_pui32TimeStamp[0] = g_pui32NextMatch[0];
g_pui32TimeStamp[1] = g_pui32NextMatch[1];
//
// Increment the ADC interrupt count
//
g_ui32ADCCount++;
}
void ADC0_SampleHandler()
{
MAP_ADCIntClear(ADC0_BASE, 3);
MAP_ADCSequenceDataGet(ADC0_BASE, 3, adc_value);
inputData[inputIndex++] = (float) adc_value[0];
if (inputIndex > TEST_LENGTH_SAMPLES - 1)
{
inputIndex = 0;
// 'Permanently disable interrupt'
// We will only run the fft once for now
MAP_ADCIntDisable(ADC0_BASE, 3);
MAP_TimerDisable(TIMER1_BASE, TIMER_A);
runFFT();
// Delay for 1 second
MAP_SysCtlDelay(g_ui32SysClock / 3);
//Re-enable timer and ADC interrupts to run another FFT
MAP_ADCIntEnable(ADC0_BASE, 3);
MAP_TimerEnable(TIMER1_BASE, TIMER_A);
}
}
/*
* @brief Gets the ADC value of the gyro.
*
* @returns the value of the gyro
*/
int32 gyroGetValue(uint32 axis) {
uint32 adc_val = 22;
uint32 samples = 0;
MAP_ADCProcessorTrigger(ADC_BASE, GYRO_ADC_CHANNEL);
while (samples < 1) {
samples = MAP_ADCSequenceDataGet(ADC_BASE, GYRO_ADC_CHANNEL, &adc_val);
}
return adc_val;
}
//*****************************************************************************
//
// This function is called to start an acquisition running. It determines
// which channels are to be logged, enables the ADC sequencers, and computes
// the first RTC match value. This will start the acquisition running.
//
//*****************************************************************************
void
AcquireStart(tConfigState *psConfig)
{
uint32_t ui32Idx, pui32RTC[2], ui32SelectedMask;
//
// Check the parameters
//
ASSERT(psConfig);
if(!psConfig)
{
return;
}
//
// Update the config state pointer, save the selected item mask
//
g_psConfigState = psConfig;
ui32SelectedMask = psConfig->ui16SelectedMask;
//
// Get the logging period from the logger configuration. Split the
// period into seconds and subseconds pieces and save for later use in
// generating RTC match values.
//
g_pui32MatchPeriod[0] = psConfig->ui32Period >> 8;
g_pui32MatchPeriod[1] = (psConfig->ui32Period & 0xFF) << 8;
//
// Determine how many channels are to be logged
//
ui32Idx = ui32SelectedMask;
g_ui32NumItems = 0;
while(ui32Idx)
{
if(ui32Idx & 1)
{
g_ui32NumItems++;
}
ui32Idx >>= 1;
}
//
// Initialize the strip chart manager for a new run. Don't bother with
// the strip chart if we are using viewer mode, or sleep-logging.
//
if((psConfig->ui8Storage != CONFIG_STORAGE_VIEWER) &&
!psConfig->ui32SleepLogging)
{
StripChartMgrInit();
StripChartMgrConfigure(ui32SelectedMask);
}
//
// Configure USB for memory stick if USB storage is chosen
//
if(psConfig->ui8Storage == CONFIG_STORAGE_USB)
{
USBStickOpenLogFile(0);
}
else if(psConfig->ui8Storage == CONFIG_STORAGE_FLASH)
{
//
// Flash storage is to be used, prepare the flash storage module.
// If already sleep-logging, then pass in the saved flash address
// so it does not need to be searched.
//
if(psConfig->ui32SleepLogging)
{
FlashStoreOpenLogFile(psConfig->ui32FlashStore);
}
else
{
//
// Otherwise not sleep logging, so just initialize the flash store,
// this will cause it to search for the starting storage address.
//
FlashStoreOpenLogFile(0);
}
}
//
// Enable the ADC sequencers
//
MAP_ADCSequenceEnable(ADC0_BASE, 0);
MAP_ADCSequenceEnable(ADC1_BASE, 0);
//
// Flush the ADC sequencers to be sure there is no lingering data.
//
MAP_ADCSequenceDataGet(ADC0_BASE, 0, g_pui32ADCData);
MAP_ADCSequenceDataGet(ADC1_BASE, 0, g_pui32ADCData);
//
// Enable ADC interrupts
//
MAP_ADCIntClear(ADC0_BASE, 0);
MAP_ADCIntClear(ADC1_BASE, 0);
MAP_ADCIntEnable(ADC0_BASE, 0);
MAP_IntEnable(INT_ADC0SS0);
//
// If we are not already sleep-logging, then initialize the RTC match.
// If we are sleep logging then this does not need to be set up.
//
if(!psConfig->ui32SleepLogging)
{
//
// Get the current RTC value
//
do
{
pui32RTC[0] = HibernateRTCGet();
pui32RTC[1] = HibernateRTCSSGet();
}
while(pui32RTC[0] != HibernateRTCGet());
//
// Set an initial next match value. Start with the subseconds always
// 0 so the first match value will always be an even multiple of the
// subsecond match. Add 2 seconds to the current RTC just to be clear
// of an imminent rollover. This means that the first match will occur
// between 1 and 2 seconds from now.
//
g_pui32NextMatch[0] = pui32RTC[0] + 2;
g_pui32NextMatch[1] = 0;
//
// Now set the match value
//
HibernateRTCMatchSet(0, g_pui32NextMatch[0]);
HibernateRTCSSMatchSet(0, g_pui32NextMatch[1]);
}
//
// If we are configured to sleep, but not sleeping yet, then enter sleep
// logging mode if allowed.
//
if(psConfig->bSleep && !psConfig->ui32SleepLogging)
{
//
// Allow sleep logging if storing to flash at a period of 1 second
// or greater.
//
if((psConfig->ui8Storage == CONFIG_STORAGE_FLASH) &&
(psConfig->ui32Period >= 0x100))
{
psConfig->ui32SleepLogging = 1;
}
}
//
// Enable the RTC interrupts from the hibernate module
//
HibernateIntClear(HibernateIntStatus(0));
HibernateIntEnable(HIBERNATE_INT_RTC_MATCH_0 | HIBERNATE_INT_PIN_WAKE);
MAP_IntEnable(INT_HIBERNATE);
//
// Logging data should now start running
//
}
