void do_counter_measurement(void)
{
extern u16 convert_acceleration_value_to_mgrav(u8 value);
u8 i;
u16 accel_data, sum1;
// Get data from sensor
bmp_as_get_data(sCounter.xyz);
for ( i = 0, sum1 = 0; i < 3; i ++ ) {
accel_data = convert_acceleration_value_to_mgrav(sCounter.xyz[i]);
// Filter acceleration
#if 0
accel_data = (u16)((accel_data * 0.2) + (sCounter.data[i] * 0.8));
#endif
accel_data = (u16)((accel_data * 0.1) + (sCounter.data[i] * 0.9));
sum1 += accel_data;
// Store average acceleration
sCounter.data[i] = accel_data;
}
if ( sCounter.sum == 0 ) {
sCounter.low = sum1;
sCounter.high = sum1;
} else {
switch ( sCounter.rise_state) { // init state
case 0:
if ( sum1 > sCounter.sum ) {
sCounter.rise_state = 1;
sCounter.low = sCounter.sum;
} else {
sCounter.rise_state = 2;
sCounter.high = sCounter.sum;
}
break;
case 1:
if ( sum1 < sCounter.sum ) { // change direction
sCounter.high = sCounter.sum;
sCounter.rise_state = 2;
}
break;
case 2:
if ( sum1 > sCounter.sum ) {
sCounter.low = sCounter.sum;
sCounter.rise_state = 1;
do_count();
}
break;
}
}
sCounter.sum = sum1;
// Set display update flag
// display.flag.update_counter = 1;
}
// *************************************************************************************************
// @fn agile_tick
// @brief Called by 1Hz clock_tick function.
// @param none
// @return none
// *************************************************************************************************
void agility_tick(void)
{
// Make sure it is something running before we do anything else
if (sAgil.state == AGIL_RUN)
{
u8 i;
for(i = 0; i < 3; i++)
{
// Get data from sensor
sAgil.xyz[i] = sAccel.xyz[i];
// Save previous data
sAgil.PreviousData[i] = sAgil.CurrentData[i];
// Calculate acceleration (result without sign information)
sAgil.CurrentData[i] = convert_acceleration_value_to_mgrav(sAgil.xyz[i]) / 10;
// If acceleraition is negative
if (acceleration_value_is_positive(sAgil.xyz[i]) == 0) { sAgil.CurrentData[i] *= (-1); }
// Accumulate (max. increment per sec is about 3 * 2000 / 10 / 10 = 60)
sAgil.AgilityIndicator += ( abs(sAgil.PreviousData[i] - sAgil.CurrentData[i]) / 10);
}
// Decrease timeout counter
if(sAgil.timeout > 1)
{
sAgil.timeout--;
// Check timeout of module acceleration.c
if(sAccel.timeout < ACCEL_TIMEOUT_PREVENTION)
{
// Set acceleration timeout counter to prevent an undesired stop
sAccel.timeout = ACCEL_TIMEOUT_PREVENTION;
}
}
// Timeout occured; Save current measurement to history; Stop measurement, if number of programmed cycles elapsed.
else // sAgil.timeout == 1
{
if(sAgil.cycles > 1)
{
sAgil.timeout = sAgil.TimeoutSetting;
sAgil.cycles--;
}
else // sAgil.cycles == 1
{
sAgil.cycles = 0;
stop_agility();
}
write_agility_history();
sAgil.AgilityIndicator = 0;
}
}
}
// *************************************************************************************************
// @fn display_acceleration
// @brief Display routine.
// @param u8 line LINE1
// u8 update DISPLAY_LINE_UPDATE_FULL, DISPLAY_LINE_CLEAR
// @return none
// *************************************************************************************************
void display_acceleration(u8 line, u8 update)
{
u8 * str;
u8 raw_data;
u16 accel_data;
// Show warning if acceleration sensor was not initialised properly
if (!as_ok)
{
display_chars(LCD_SEG_L1_2_0, (u8*)"ERR", SEG_ON);
}
else
{
// Redraw whole screen
if (update == DISPLAY_LINE_UPDATE_FULL)
{
{
// Start acceleration sensor
if (!is_acceleration_measurement())
{
// Clear previous acceleration value
sAccel.data = 0;
// Start sensor
as_start();
// Set timeout counter
sAccel.timeout = ACCEL_MEASUREMENT_TIMEOUT;
// Set mode
sAccel.mode = ACCEL_MODE_ON;
// Start with Y-axis values
sAccel.view_style = DISPLAY_ACCEL_X;
}
// Display decimal point
display_symbol(LCD_SEG_L1_DP1, SEG_ON);
}
}
else if (update == DISPLAY_LINE_UPDATE_PARTIAL)
{
// Convert X/Y/Z values to mg
switch (sAccel.view_style)
{
case DISPLAY_ACCEL_X: raw_data = sAccel.xyz[0];
display_char(LCD_SEG_L1_3, 'X', SEG_ON);
break;
case DISPLAY_ACCEL_Y: raw_data = sAccel.xyz[1];
display_char(LCD_SEG_L1_3, 'Y', SEG_ON);
break;
default: raw_data = sAccel.xyz[2];
display_char(LCD_SEG_L1_3, 'Z', SEG_ON);
break;
}
accel_data = convert_acceleration_value_to_mgrav(raw_data) / 10;
// Filter acceleration
#ifdef FIXEDPOINT
accel_data = (u16)(((accel_data * 2) + (sAccel.data * 8))/10);
#else
accel_data = (u16)((accel_data * 0.2) + (sAccel.data * 0.8));
#endif
// Store average acceleration
sAccel.data = accel_data;
// Display acceleration in x.xx format
str = itoa(accel_data, 3, 0);
display_chars(LCD_SEG_L1_2_0, str, SEG_ON);
// Display sign
if (acceleration_value_is_positive(raw_data))
{
display_symbol(LCD_SYMB_ARROW_UP, SEG_ON);
display_symbol(LCD_SYMB_ARROW_DOWN, SEG_OFF);
}
else
{
display_symbol(LCD_SYMB_ARROW_UP, SEG_OFF);
display_symbol(LCD_SYMB_ARROW_DOWN, SEG_ON);
}
}
else if (update == DISPLAY_LINE_CLEAR)
{
// Stop acceleration sensor
as_stop();
// Clear mode
sAccel.mode = ACCEL_MODE_OFF;
// Clean up display
display_symbol(LCD_SEG_L1_DP1, SEG_OFF);
display_symbol(LCD_SYMB_ARROW_UP, SEG_OFF);
display_symbol(LCD_SYMB_ARROW_DOWN, SEG_OFF);
}
}
}
