File content as of revision 3:4355890e55b4:

/**
 ******************************************************************************
 * @file    main.cpp
 * @author  AST / EST
 * @version V0.0.1
 * @date    14-August-2015
 * @brief   Simple Example application for using the X_NUCLEO_IKS01A1 
 *          MEMS Inertial & Environmental Sensor Nucleo expansion board.
 ******************************************************************************
 * @attention
 *
 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *   1. Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright notice,
 *      this list of conditions and the following disclaimer in the documentation
 *      and/or other materials provided with the distribution.
 *   3. Neither the name of STMicroelectronics nor the names of its contributors
 *      may be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 *  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 ******************************************************************************
*/ 

/* Includes */
#include "main.h"

/* Instantiate the expansion board */
static X_NUCLEO_IKS01A1 *mems_expansion_board = X_NUCLEO_IKS01A1::Instance(D14, D15);

/* Retrieve the composing elements of the expansion board */
static GyroSensor *gyroscope = mems_expansion_board->GetGyroscope();
static MotionSensor *accelerometer = mems_expansion_board->GetAccelerometer();
static MagneticSensor *magnetometer = mems_expansion_board->magnetometer;
static HumiditySensor *humidity_sensor = mems_expansion_board->ht_sensor;
static PressureSensor *pressure_sensor = mems_expansion_board->pt_sensor;
static TempSensor *temp_sensor1 = mems_expansion_board->ht_sensor;
static TempSensor *temp_sensor2 = mems_expansion_board->pt_sensor;

/* Helper function for printing floats & doubles */
static char *printDouble(char* str, double v, int decimalDigits=2)
{
  int i = 1;
  int intPart, fractPart;
  int len;
  char *ptr;

  /* prepare decimal digits multiplicator */
  for (;decimalDigits!=0; i*=10, decimalDigits--);

  /* calculate integer & fractinal parts */
  intPart = (int)v;
  fractPart = (int)((v-(double)(int)v)*i);

  /* fill in integer part */
  sprintf(str, "%i.", intPart);

  /* prepare fill in of fractional part */
  len = strlen(str);
  ptr = &str[len];

  /* fill in leading fractional zeros */
  for (i/=10;i>1; i/=10, ptr++) {
    if(fractPart >= i) break;
    *ptr = '0';
  }

  /* fill in (rest of) fractional part */
  sprintf(ptr, "%i", fractPart);

  return str;
}

DigitalOut myled(LED1);
DigitalIn mybutton(USER_BUTTON);
Display mydisplay;
RawData myrawdata;

uint8_t fbtn=BTN_RELEASED;
uint8_t fbtn_counter=0;
uint8_t mode=MODE_NORMAL;
uint8_t func=FUNC_DATETIME;
uint8_t config_index=0;


/**
 * FUNC: wait_action
 * DESC: wait for pressing button action, update the global flag for next polling cycle
 */
void wait_action()
{
    fbtn=BTN_RELEASED;
    for(int i=0; i<5; i++)
    {
        if(fbtn==BTN_RELEASED)
        {
            if(mybutton==1 and fbtn==BTN_RELEASED)
            {
                if(fbtn_counter>0 and fbtn_counter<=10)
                {
                    fbtn=BTN_PRESSED;
                }
                else if(fbtn_counter>10 and fbtn_counter<=30)
                {
                    fbtn=BTN_PRESSED_LONG;
                }
                else if(fbtn_counter>30)
                {
                    fbtn=BTN_PRESSED_VERY_LONG;
                }
                fbtn_counter=0;
            }
            else
            {
                fbtn_counter+=1;
            }
        }
        wait(0.1);
    }
}


/* Simple main function */
int main() {
  myled=0;
  uint8_t func=0;
  uint8_t button_mem=0;
  

  
  uint8_t id;
  float value1, value2;
  char buffer0[16];
  char buffer1[32], buffer2[32];
  int32_t axes[3];
  int16_t axxx[3];
  
 /* 
  
  PersistorStorage ps=PersistorStorage();
  strcpy(ps.storage, "hello");
  ps.writeStorageToFlash();
  
  PersistorStorage ps1=PersistorStorage();
  ps1.ReadStorageFromFlash();

  printf("%s", ps1.storage);
*/
/*HAL_Init();
__HAL_FLASH_CLEAR_FLAG( FLASH_FLAG_EOP | FLASH_FLAG_OPERR |FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGSERR );
printf("hello\n");
uint64_t a=124;
uint32_t pageerr = 100;
HAL_FLASH_Unlock();
FLASH_EraseInitTypeDef es;
es.TypeErase=FLASH_TYPEERASE_MASSERASE;
es.Banks=FLASH_BANK_2;
es.Page=0;
es.NbPages=1;

if( HAL_OK != (HAL_FLASHEx_Erase_IT( &es))) {
        printf("ERROR %d\n", pageerr);
        HAL_FLASH_Lock();
}
__HAL_FLASH_CLEAR_FLAG( FLASH_FLAG_EOP | FLASH_FLAG_OPERR |FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGSERR );
HAL_FLASH_Unlock();
printf("%d\n", HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, 0x08080000, a));
printf("hello\n");
printf("%d\n", HAL_FLASH_GetError());
HAL_FLASH_Lock();

static const int StorageSize = 64;
static unsigned int storage[ StorageSize ] __attribute__((aligned(32)));
HAL_FLASH_Unlock();
memcpy( (uint32_t*)storage, (uint32_t*)(0x08080000), StorageSize);
HAL_FLASH_Lock();

for(int i=0; i<StorageSize; i++)
{
    printf("%4x ",storage[i]);
}
printf("\n");
*/







  
/*  
  printf("\r\n--- Starting new run ---\r\n");

  humidity_sensor->ReadID(&id);
  printf("HTS221  humidity & temperature    = 0x%X\r\n", id);
  pressure_sensor->ReadID(&id);
  printf("LPS25H  pressure & temperature    = 0x%X\r\n", id);
  magnetometer->ReadID(&id);
  printf("LIS3MDL magnetometer              = 0x%X\r\n", id);
  gyroscope->ReadID(&id);
  printf("LSM6DS0 accelerometer & gyroscope = 0x%X\r\n", id);
*/

while(1)
{
    // MEASURE AND DISPLAY
    if(mode==MODE_NORMAL)
    {
        myled=0;
        if(func==FUNC_DATETIME)
        {
            myrawdata.__time=time(NULL);
            myrawdata.str_date(buffer0);
            myrawdata.str_time(buffer1);
        }
        else if(func==FUNC_TEMPHUMI)
        {
            temp_sensor1->GetTemperature(&myrawdata.__temp);
            humidity_sensor->GetHumidity(&myrawdata.__humi);
            myrawdata.str_temperature(buffer0);
            myrawdata.str_humidity(buffer1);
        }
        else if(func==FUNC_PRESSURE)
        {
            pressure_sensor->GetPressure(&myrawdata.__pressure);
            myrawdata.str_pressure(buffer0);
            myrawdata.str_altitude(buffer1);
        }
        else if(func==FUNC_CPASSDIR)
        {
            magnetometer->Get_M_Axes(myrawdata.__mag);
            accelerometer->Get_X_Axes(myrawdata.__acc);
            gyroscope->Get_G_Axes(myrawdata.__gyr);
            myrawdata.str_magnetic(buffer0);
            myrawdata.str_direction(buffer1);
        }
        mydisplay.show(buffer0, buffer1);
    }
    else
    {
        myled=1;
        if(func==FUNC_DATETIME)
        {
            myrawdata.str_date(buffer0);
            myrawdata.str_time(buffer1);
        }
        mydisplay.show(buffer0, buffer1);
    }
    
    // NEXT STATE
    if(mode==MODE_NORMAL)
    {
        if(fbtn==BTN_PRESSED_LONG || fbtn==BTN_PRESSED_VERY_LONG)
        {
            mode=MODE_CONFIG;
        }
        else if(fbtn==BTN_PRESSED)
        {
            func=func+1;
            if(func>FUNC_CPASSDIR)
                func=FUNC_DATETIME;
        }
    }
    else
    {
        if(fbtn==BTN_PRESSED_VERY_LONG)
        {
            config_index=0;
            mode=MODE_NORMAL;
        }
        else if(fbtn==BTN_PRESSED_LONG)
        {
            config_index+=1;
        }
        else if(fbtn==BTN_PRESSED)
        {
            if(func==FUNC_DATETIME)
            {
                if(config_index==0)
                {
                    myrawdata.add_year_10();
                }
                else if(config_index==1)
                {
                    myrawdata.add_year_1();
                }
                else if(config_index==2)
                {
                    myrawdata.add_month();
                }
                else if(config_index==3)
                {
                    myrawdata.add_day();
                }
            }
        }
    }
    
    wait_action();
}
    
raise_error(ERROR_CONFIG);

  printf("START CALIBRATION\n");
  int32_t m_max[3]={0};
  int32_t m_min[3]={0};
  for (int i=0; i<1000; i++)
  {
       
        magnetometer->Get_M_Axes(axes);
        if(i==0)
        {
            for(int j=0; j<3; j++)
            {
                m_max[j]=axes[j];
                m_min[j]=axes[j];
            }
        }
        else
        {
            for(int j=0; j<3; j++)
            {
                if(axes[j]>m_max[j])  m_max[j]=axes[j];
                if(axes[j]<m_min[j])  m_min[j]=axes[j];
            }
        }
        wait(0.05);
  }
  
  printf("MAX : %d, %d, %d\n", m_max[0], m_max[1], m_max[2]);
  printf("MIN : %d, %d, %d\n", m_min[0], m_min[1], m_min[2]);
  
 
  while(1) {
    if((mybutton!=0) && (button_mem==0))
    {
        func++;
        if(func>=6)
            func=0;
    }
    button_mem=mybutton;
    printf("func: %d\r\n", func);
    printf("\r\n");
    
    if(func==0)
    {
        time_t seconds = time(NULL);
        printf("Time as a basic string = %s\r\n", ctime(&seconds));
    }
    else if(func==1)
    {
    temp_sensor1->GetTemperature(&value1);
    humidity_sensor->GetHumidity(&value2);
    
    if(value2 > 70)
        myled=1;
    else
        myled=0;
    printf("HTS221: [temp] %7s C,   [hum] %s%%\r\n", printDouble(buffer1, value1), printDouble(buffer2, value2));
    }
    else if(func==2)
    {
    temp_sensor2->GetFahrenheit(&value1);
    pressure_sensor->GetPressure(&value2);
    printf("LPS25H: [temp] %7s F, [press] %smbar\r\n", printDouble(buffer1, value1), printDouble(buffer2, value2));
    printf("Altitude: %s m\r\n", printDouble(buffer1, 44300-44300*pow((value2/1013.25), 0.00019)));
    }
    else if(func==3)
    {
    magnetometer->Get_M_Axes(axes);
    axxx[0]=axes[0]-((m_max[0]+m_min[0])/2);
    axxx[1]=axes[1]-((m_max[1]+m_min[1])/2);
    axxx[2]=axes[2]-((m_max[2]+m_min[2])/2);
    printf("LIS3MDL [mag/mgauss]:  %6ld, %6ld, %6ld\r\n", axxx[0], axxx[1], axxx[2]);
    printf("DIR: %s deg\r\n", printDouble(buffer1, 90-atan(float(axxx[0])/float(axxx[1])/3.1416)));
    }
    else if(func==4)
    {
    accelerometer->Get_X_Axes(axes);
    printf("LSM6DS0 [acc/mg]:      %6ld, %6ld, %6ld\r\n", axes[0], axes[1], axes[2]);
    }
    else if(func==5)
    {
    gyroscope ->Get_G_Axes(axes);
    printf("LSM6DS0 [gyro/mdps]:   %6ld, %6ld, %6ld\r\n", axes[0], axes[1], axes[2]);
    }
    wait(1.5);
  }
}