persistent_data.cpp

Go to the documentation of this file.

/***********************************************************************/
#include "system_configuration.h"
#include "embedded_memory.h"
#include "embedded_math.h"
#include "persistent_data.h"
#include "string.h"
 
ROM persistent_data_t PERSISTENT_DATA[]=
    {
    {SENS_TILT_ROLL,"SensTilt_Roll",    true,  0.0f, 0},    
    {SENS_TILT_PITCH,"SensTilt_Pitch",  true,  0.0f, 0},    
    {SENS_TILT_YAW, "SensTilt_Yaw",     true,  0.0f, 0},    
 
    {PITOT_OFFSET,  "Pitot_Offset",     false,  0.0f, 0},   
    {PITOT_SPAN,    "Pitot_Span",       false,  1.0f, 0},   
    {QNH_OFFSET,    "QNH-delta",        false,  0.0f, 0},   
 
    {MAG_X_OFF, "Mag_X_Off",        false,  0.0f, 0},   
    {MAG_X_SCALE,   "Mag_X_Scale",      false,  1.0f, 0},   
    {MAG_Y_OFF, "Mag_Y_Off",        false,  0.0f, 0},   
    {MAG_Y_SCALE,   "Mag_Y_Scale",      false,  1.0f, 0},   
    {MAG_Z_OFF, "Mag_Z_Off",        false,  0.0f, 0},   
    {MAG_Z_SCALE,   "Mag_Z_Scale",      false,  1.0f, 0},   
    {MAG_STD_DEVIATION, "Mag_Calib_Err",    false,  1e-2f, 0},  
    {MAG_AUTO_CALIB, "Mag_Auto_Calib",  false,  1.0f, 0},   
 
    {VARIO_TC,  "Vario_TC",     false, 2.0f, 0},    
    {VARIO_INT_TC,  "Vario_Int_TC",     false, 30.0f, 0},   
    {WIND_TC,   "Wind_TC",      false, 5.0f, 0},    
    {MEAN_WIND_TC,  "Mean_Wind_TC",     false, 30.0f, 0},   
    {HORIZON,   "Horizon_active",   false, 1.0f, 0},    
 
    {GNSS_CONFIGURATION, "GNSS_CONFIG", false, 1.0f, 0},    
    {ANT_BASELENGTH, "ANT_BASELEN",     false, 1.0f, 0},    
    {ANT_SLAVE_DOWN, "ANT_SLAVE_DOWN",  false, 0.0f, 0},    
    {ANT_SLAVE_RIGHT,"ANT_SLAVE_RIGHT", false, 0.0f, 0},    
    };
 
ROM unsigned PERSISTENT_DATA_ENTRIES = sizeof(PERSISTENT_DATA) / sizeof(persistent_data_t);
 
void ensure_EEPROM_parameter_integrity( void)
{
  bool EEPROM_has_been_unlocked = false;
  float dummy;
  const persistent_data_t * parameter = PERSISTENT_DATA;
  while( parameter < PERSISTENT_DATA + PERSISTENT_DATA_ENTRIES)
    {
      if( true == read_EEPROM_value( parameter->id, dummy)) // parameter missing
    {
      if( EEPROM_has_been_unlocked == false)
        {
          lock_EEPROM( false);
          EEPROM_has_been_unlocked = true;
        }
      (void) write_EEPROM_value( parameter->id, parameter->default_value);
    }
      ++parameter;
    }
  if( EEPROM_has_been_unlocked)
    lock_EEPROM( true);
}
 
const persistent_data_t * find_parameter_from_name( char * name)
{
  for( const persistent_data_t *parameter = PERSISTENT_DATA; parameter < (PERSISTENT_DATA+PERSISTENT_DATA_ENTRIES); ++parameter )
    if( 0 == strncmp( parameter->mnemonic, name, strlen( parameter->mnemonic)))
      return parameter;
  return 0;
}
 
const persistent_data_t * find_parameter_from_ID( EEPROM_PARAMETER_ID id)
{
  for( const persistent_data_t *parameter = PERSISTENT_DATA; parameter < (PERSISTENT_DATA+PERSISTENT_DATA_ENTRIES); ++parameter )
    if( parameter->id == id)
      return parameter;
  return 0;
}
 
#if UNIX != 1
 
#include "eeprom.h"
#include "my_assert.h"
 
#define READ true
#define WRITE false
 
bool EEPROM_convert( EEPROM_PARAMETER_ID id, EEPROM_data_t & EEPROM_value, float & value , bool read )
{
  switch(id)
  {
    case BOARD_ID:
    case GNSS_CONFIGURATION:
    case MAG_AUTO_CALIB:
    case HORIZON:
      if( read)
    value = (float)(EEPROM_value.u16);
      else
    EEPROM_value.u16 = (uint16_t)round(value);
      break;
    case QNH_OFFSET:
    case PITOT_OFFSET:
      if( read)
    value = ( float)(EEPROM_value.i16);
      else
    EEPROM_value.i16 = (int16_t)value;
      break;
    case PITOT_SPAN:
    case MAG_X_SCALE:
    case MAG_Y_SCALE:
    case MAG_Z_SCALE:
      if( read)
    value = ( (float)(EEPROM_value.i16) / 32768.0f) + 1.0f;
      else
    {
      int ivalue = (int)((value - 1.0f) * 32768.0f);
      if( ivalue > 32767)
        ivalue = 32767;
      if( ivalue < -32768)
        ivalue = -32768;
      EEPROM_value.i16 = (int16_t)ivalue;
    }
      break;
    case MAG_STD_DEVIATION:
      if( read)
    value = (float)(EEPROM_value.u16) / 65536.0f * 1e-2f;
      else
    {
      if( value >= 0.009999f || value < 0.0f)
        EEPROM_value.u16 = 0xffff;
      else
        EEPROM_value.u16 = (uint16_t)(value * 1e2f * 65536.0f);
    }
      break;
    case MAG_X_OFF:
    case MAG_Y_OFF:
    case MAG_Z_OFF:
      if( read)
    value = ( (float)(EEPROM_value.i16) / 3276.8f);
      else
    EEPROM_value.i16 = (int16_t)(value * 3276.8f);
      break;
    case ANT_BASELENGTH: // max +/- 32.768 m
    case ANT_SLAVE_DOWN:
    case ANT_SLAVE_RIGHT:
      if( read)
    value = (float)(EEPROM_value.i16) * 0.001f;
      else
    EEPROM_value.i16 = (int16_t)(value * 1000.0f);
      break;
      break;
    case SENS_TILT_ROLL:
    case SENS_TILT_PITCH:
    case SENS_TILT_YAW:
      if( read)
    value = (float)(EEPROM_value.i16) / 32768.0f * M_PI_F;
      else
    {
      if( value < -M_PI_F)
        value += 2.0f * M_PI_F;
      if( value >= M_PI_F)
        value -= 2 * M_PI_F;
      int ivalue = (int) round(value * 32768.0f / M_PI_F);
      if( ivalue >= 32768)
        ivalue = 32767;
      EEPROM_value.i16 = (int16_t)ivalue;
    }
      break;
    case VARIO_TC:
    case VARIO_INT_TC:
    case WIND_TC:
    case MEAN_WIND_TC:
      if( read)
    value = (float)(EEPROM_value.u16) / 655.36f;
      else
    EEPROM_value.u16 = (uint16_t)(value * 655.36f);
      break;
    case EEPROM_PARAMETER_ID_END:
    default:
    value = 0.0f; // just to be sure ...
    return true; // error
      break;
  }
  return false; // OK
}
 
bool lock_EEPROM( bool lockit)
{
  if( lockit)
    return HAL_FLASH_Lock();
 
  HAL_FLASH_Unlock();
  return (EE_Init());
}
 
bool write_EEPROM_value( EEPROM_PARAMETER_ID id, float value)
{
  EEPROM_data_t EEPROM_value;
  if( EEPROM_convert( id, EEPROM_value, value , WRITE))
      return true; // error
 
  EEPROM_data_t read_value;
  if( (HAL_OK != EE_ReadVariable( id, &read_value.u16))
      ||
      (read_value.u16 != EEPROM_value.u16) )
    return EE_WriteVariable( id, EEPROM_value.u16);
  return HAL_OK;
}
 
bool read_EEPROM_value( EEPROM_PARAMETER_ID id, float &value)
{
  uint16_t data;
  if( HAL_OK != EE_ReadVariable( id, (uint16_t*)&data))
    return true;
  return ( EEPROM_convert( id, (EEPROM_data_t &)data, value , READ));
}
 
float configuration( EEPROM_PARAMETER_ID id)
{
  float value;
  bool result = read_EEPROM_value( id, value);
  ASSERT( result == false);
  return value;
}
 
bool EEPROM_initialize( void)
{
  unsigned status;
 
  status = HAL_FLASH_Unlock();
  ASSERT(status == HAL_OK);
 
  status = EE_Init();
  ASSERT(status == HAL_OK);
 
  return HAL_OK;
}
 
#endif