/*
* @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 is the handler for the RTC interrupt from the hibernate peripheral.
// It occurs on RTC match. This handler will initiate an ADC acquisition,
// which will run all of the ADC sequencers. Then it computes the next
// match value and sets it in the RTC.
//
//*****************************************************************************
void
RTCHandler(void)
{
uint32_t ui32Status, ui32Seconds;
//
// Increment RTC interrupt counter
//
g_pui32RTCInts++;
//
// Clear the RTC interrupts (this can be slow for hib module)
//
ui32Status = HibernateIntStatus(1);
HibernateIntClear(ui32Status);
//
// Read and save the current value of the seconds counter.
//
ui32Seconds = HibernateRTCGet();
//
// If we are sleep logging, then there will be no remembered value for
// the next match value, which is also used as the time stamp when
// data is collected. In this case we will just use the current
// RTC seconds. This is safe because if sleep-logging is used, it
// is only with periods of whole seconds, 1 second or longer.
//
if(g_psConfigState->ui32SleepLogging)
{
g_pui32NextMatch[0] = ui32Seconds;
g_pui32NextMatch[1] = 0;
}
//
// If we are logging data to PC and using a period greater than one
// second, then use special handling. For PC logging, if no data is
// collected, then we must send a keep-alive packet once per second.
//
if((g_psConfigState->ui8Storage == CONFIG_STORAGE_HOSTPC) &&
(g_pui32MatchPeriod[0] > 1))
{
//
// If the current seconds count is less than the match value, that
// means we got the interrupt due to one-second keep alive for the
// host PC.
//
if(ui32Seconds < g_pui32NextMatch[0])
{
//
// Set the next match for one second ahead (next keep-alive)
//
HibernateRTCMatchSet(0, ui32Seconds + 1);
//
// Set flag to indicate that a keep alive packet is needed
//
g_bNeedKeepAlive = true;
//
// Nothing else to do except wait for next keep alive or match
//
return;
}
//
// Else, this is a real match so proceed to below to do a normal
// acquisition.
//
}
//
// Kick off the next ADC acquisition. When these are done they will
// cause an ADC interrupt.
//
MAP_ADCProcessorTrigger(ADC1_BASE, 0);
MAP_ADCProcessorTrigger(ADC0_BASE, 0);
//
// Set the next RTC match. Add the match period to the previous match
// value. We are making an assumption here that there is enough time from
// when the match interrupt occurred, to this point in the code, that we
// are still setting the match time in the future. If the period is too
// long, then we could miss a match and never get another RTC interrupt.
//
g_pui32NextMatch[0] += g_pui32MatchPeriod[0];
g_pui32NextMatch[1] += g_pui32MatchPeriod[1];
if(g_pui32NextMatch[1] > 32767)
{
//
// Handle subseconds rollover
//
g_pui32NextMatch[1] &= 32767;
g_pui32NextMatch[0]++;
}
//
// If logging to host PC at greater than 1 second period, then set the
// next RTC wakeup for 1 second from now. This will cause a keep alive
// packet to be sent to the PC
//
if((g_psConfigState->ui8Storage == CONFIG_STORAGE_HOSTPC) &&
(g_pui32MatchPeriod[0] > 1))
{
HibernateRTCMatchSet(0, ui32Seconds + 1);
}
else
{
//
// Otherwise this is a normal match and the next match should also be a
// normal match, so set the next wakeup to the calculated match time.
//
HibernateRTCMatchSet(0, g_pui32NextMatch[0]);
HibernateRTCSSMatchSet(0, g_pui32NextMatch[1]);
}
//
// Toggle the LED on the board so the user can see that the acquisition
// is running.
//
MAP_GPIOPinWrite(GPIO_PORTG_BASE, GPIO_PIN_2,
~MAP_GPIOPinRead(GPIO_PORTG_BASE, GPIO_PIN_2));
//
// Now exit the int handler. The ADC will trigger an interrupt when
// it is finished, and the RTC is set up for the next match.
//
}