Spresense Arduino チュートリアル

#include <LowPower.h> (1)

void setup()
{
  :
  LowPower.begin();                     (2)
  LowPower.clockMode(CLOCK_MODE_32MHz); (3)
  :
}

#include <LowPower.h> (1)
#include <Flash.h>    (2)

void setup()
{
  LowPower.begin();                      (1)
  bootcause_e bc = LowPower.bootCause(); (2)

  if ((bc == POR_SUPPLY) || (bc == POR_NORMAL)) {
    /* Remove backup file if power-on-reset */
    Flash.remove("gnss_backup.bin");     (3)
  }

static void SleepIn(void)
{
  /* Turn off the LED. */
  APP_PRINT("Sleep ");
  ledOff(PIN_LED0);
  /* Save backup data to flash */
  Gnss.saveEphemeris(); (1)
  Gnss.stop();
  Gnss.end();

void loop() {
    :
  /* Check state. */
  if (State == eStateSleep)
  {
    /* Deep sleep */
    Serial.print("Go to Deep sleep...");
    LowPower.deepSleep(Parameter.SleepSec); (1)

#include <GNSS.h>
#include <gpsutils/cxd56_gnss_nmea.h>

SpGnss Gnss;
GnssPositionData PositionData;

/* NMEA buffer */
static char nmea_buf[NMEA_SENTENCE_MAX_LEN];

/* NMEA callback functions */
static char *reqbuf(uint16_t size)
{
  /* Get the pointer to NMEA buffer */
  if (size > sizeof(nmea_buf)) {
    return NULL;
  }
  return nmea_buf;
}

static void freebuf(char *buf)
{
  /* do nothing */
}

static int outbin(char *buf, uint32_t len)
{
  /* unused dummy function */
  return len;
}

static int outnmea(char *buf)
{
  /* Output NMEA to serial monitor */
  return Serial.print(buf);
}

void setup()
{
  /* Initialize Serial */
  Serial.begin(115200);

  /* Initialize GNSS */
  if (Gnss.begin()) {
    Serial.println("begin error!");
  }

  /* select satellite system */
  Gnss.select(GPS);
  Gnss.select(GLONASS);
  Gnss.select(QZ_L1CA);
  Gnss.select(QZ_L1S);

  /* Set interval */
  Gnss.setInterval(1);

  /* Start GNSS */
  if (Gnss.start()) {
    Serial.println("start error!");
  }

  /* Initialize NMEA library */
  NMEA_InitMask();

  /* Select NMEA sentence */
  NMEA_SetMask(NMEA_GGA_ON | (1)
               NMEA_GLL_ON |
               NMEA_GSA_ON |
               NMEA_GSV_ON |
               NMEA_GNS_ON |
               NMEA_RMC_ON |
               NMEA_VTG_ON |
               NMEA_ZDA_ON);

  /* Register callbacks to output NMEA */
  NMEA_OUTPUT_CB  funcs;
  funcs.bufReq  = reqbuf;
  funcs.out     = outnmea;
  funcs.outBin  = outbin;
  funcs.bufFree = freebuf;
  NMEA_RegistOutputFunc(&funcs);
}

void loop()
{
  /* Wait for GNSS data to be updated */
  if (Gnss.waitUpdate(-1)) {
    /* Get the GNSS data */
    Gnss.getPositionData(&PositionData);
    /* Convert to NMEA */
    NMEA_Output(&PositionData.Data);
  }
}

#include <GNSS.h>
#include <gpsutils/cxd56_gnss_nmea.h>

SpGnss Gnss;
GnssPositionData PositionData;

/* NMEA buffer */
static char nmea_buf[NMEA_SENTENCE_MAX_LEN];

/* NMEA callback functions */
static char *reqbuf(uint16_t size)
{
  /* Get the pointer to NMEA buffer */
  if (size > sizeof(nmea_buf)) {
    return NULL;
  }
  return nmea_buf;
}

static void freebuf(char *buf)
{
  /* do nothing */
}

static int outbin(char *buf, uint32_t len)
{
  /* unused dummy function */
  return len;
}

static int outnmea(char *buf)
{
  /* Output NMEA to serial monitor */
  return Serial.print(buf);
}

void setup()
{
  /* Initialize Serial */
  Serial.begin(115200);

  /* Initialize GNSS */
  if (Gnss.begin()) {
    Serial.println("begin error!");
  }

  /* select satellite system */
  Gnss.select(GPS);
  //Gnss.select(GLONASS);
  Gnss.select(QZ_L1CA);
  Gnss.select(QZ_L1S);
  //Gnss.select(SBAS);

  /* Set interval */
  Gnss.setInterval(1);

  /* Start GNSS */
  if (Gnss.start()) {
    Serial.println("start error!");
  }

  /* Initialize NMEA library */
  NMEA_InitMask();

  /* Select NMEA sentence */
  NMEA_SetMask(NMEA_QZQSM_ON); // only QZQSM

  /* Register callbacks to output NMEA */
  NMEA_OUTPUT_CB  funcs;
  funcs.bufReq  = reqbuf;
  funcs.out     = outnmea;
  funcs.outBin  = outbin;
  funcs.bufFree = freebuf;
  NMEA_RegistOutputFunc(&funcs);
}

void loop()
{
  /* Wait for GNSS data to be updated */
  if (Gnss.waitUpdate(-1)) {
    /* Get the GNSS data */
    Gnss.getPositionData(&PositionData);
    /* Convert to NMEA */
    NMEA_Output(&PositionData.Data);

    /* Output QZQSM */
    void *handle = Gnss.getDCReport();
    if (handle) {
      NMEA_DcReport_Output((struct cxd56_gnss_dcreport_data_s*)handle);
    }
  }
}

#include <RTC.h>
#include <GNSS.h>

SpGnss Gnss;

#define MY_TIMEZONE_IN_SECONDS (9 * 60 * 60) // JST (1)

  /* Start 1PSS output to PIN_D02 */
  Gnss.start1PPS(); (1)

class MyCounterClass : public SensorClient

bool begin(int id,
           uint32_t subscriptions,
           int      rate,
           int      sample_watermark_num,
           int      size_per_sample));

int publish(FAR void* data,
            uint32_t  size_per_sample,
            uint32_t  freq,
            uint32_t  sample_watermark_num,
            uint32_t  timestamp);

int subscribe(sensor_command_data_mh_t& data);

/*--------------------------------------------------------------------------*/
/**
 * @struct StepCounterStepInfo
 * @brief the structure of STEP_COUNTER results.
 */
typedef struct {

  float    tempo;     /**< Indicates tempo of walking / jogging calculated
                       *   from the input acceleration data.
                       *   The unit is [Hz].
                       */
  float    stride;    /**< Indicates stride calculated
                       *   from input acceleration data.
                       *   The unit is [cm].
                       */
  float    speed;     /**< Indicates speed of walking / jogging calculated
                       *   from the input acceleration data.
                       *   The unit is [m/s].
                       */
  float    distance;  /**< Indicates cumulative travel distance calculated
                       *   from the input acceleration data.
                       *   The unit is [m].
                       */
  uint32_t step;      /**< Indicates the number of steps calculated
                       *   from the input acceleration data.
                       * The unit is [step].
                       */
  StepCounterMovementType  movement_type; /**<
                                    * Indicates the walking type calculated
                                    * from the input acceleration data.
                                    */
  uint64_t          time_stamp;    /**< Indicates latest timestamp of the
                                    *   acceleration sensor data used.
                                    */
} StepCounterStepInfo;

/*--------------------------------------------------------------------------*/
/**
 * @struct SensorResultStepCounter
 * @brief the structure of sensor result on step counter commands.
 */
typedef struct
{
  SensorExecResult exec_result; /**< Execute resule.  */

  union
    {
      StepCounterStepInfo steps;        /**< Step count.         */
      SensorAssertionInfo assert_info;  /**< Assert information. */
    };
} SensorResultStepCounter;

int MyCounterClass::subscribe(sensor_command_data_mh_t& data)
{
  ..(省略)..

  MyStepCounterResult output;

  publish(&output,
          sizeof(MyStepCounterResult),
          1, /* 1Hz */
          1, /* 1sample */
          timestamp);
}

subscribe()
{
  MyStepCounterResult* steps = reinterpret_cast<MyStepCounterResult*>(ApplicationSensorClass.subscribe(data));
}

enum
{
  SEN_selfID        = SensorClientID00, /*  0 */
  SEN_accelID       = SensorClientID01, /*  1 */
  SEN_accel1ID      = SensorClientID02, /*  2 */
  SEN_magID         = SensorClientID03, /*  3 */
  SEN_pressureID    = SensorClientID04, /*  4 */
  SEN_lightID       = SensorClientID05, /*  5 */
  SEN_pulseID       = SensorClientID06, /*  6 */
  SEN_tempID        = SensorClientID07, /*  7 */
  SEN_gyroID        = SensorClientID08, /*  8 */
  SEN_gnssID        = SensorClientID09, /*  9 */
  SEN_stepcounterID = SensorClientID10, /* 10 */
  SEN_tramID        = SensorClientID11, /* 11 */
  SEN_gestureID     = SensorClientID12, /* 12 */
  SEN_compassID     = SensorClientID13, /* 13 */
  SEN_barometerID   = SensorClientID14, /* 14 */
  SEN_tramliteID    = SensorClientID15, /* 15 */
  SEN_vadID         = SensorClientID16, /* 16 */
  SEN_wuwsrID       = SensorClientID17, /* 17 */
  SEN_adcID         = SensorClientID18, /* 18 */
  SEN_reserve19ID   = SensorClientID19, /* 19 */
  SEN_app0ID        = SensorClientID20, /* 20 */
  SEN_app1ID        = SensorClientID21, /* 21 */
  SEN_app2ID        = SensorClientID22, /* 22 */
  SEN_app3ID        = SensorClientID23, /* 23 */
  SEN_ID_MAX        = NumOfGeneralSensorClientID,
};

#define SensorClientID06 GasSensorID

class GasSensorClass : public SensorClient
{
public:
  bool begin(int      id,
             int      rate,
             int      sample_watermark_num,
             int      size_per_sample = sizeof(struct bsec_virtual_sensor_t));

  /**
   * @brief 1 Sample data write.
   */

  int write_data(float temp, float humi, float pres, float gas);

private:
  bool begin(int      id,
             uint32_t subscriptions        = 0,
             int      rate                 = 0,
             int      size_per_sample      = 0);

  struct gas_sensor_s
    {
      float temp;
      float humi;
      float pres;
      float gas;
    };

  int                   m_cnt;                   /* private counter */
  unsigned long         m_previous_time;
  MemMgrLite::MemHandle m_mh;

};

  struct gas_sensor_s
    {
      float temp;
      float humi;
      float pres;
      float gas;
    };

  int write_data(float temp, float humi, float pres, float gas);

#include <GasSensor.h>
#include "Arduino.h"

#define GAS_INTERVAL_THRESHOLD  10000  /* [10s] */

bool GasSensorClass::begin(int      id,
                             uint32_t subscriptions,
                             int      rate, /* Interval time */
                             int      sample_watermark_num,
                             int      size_per_sample)
{

  m_cnt           = 0;
  m_previous_time = millis();

  if (ERR_OK != m_mh.allocSeg(
                         SENSOR_DATA_BUF_POOL,
                         size_per_sample * sample_watermark_num))
    {
      /* Fatal error occured. */

      printf("Fail to allocate segment of memory handle.\n");
      return false;
    }
  return true;
}

bool GasSensorClass::begin(int id,
                             int rate,
                             int size_per_sample)
{
  return begin(id, 0, rate, 1, size_per_sample);
}

int write_data(float temp, float humi, float pres, float gas);
{
  /* Check reading cycle */

  long  now           = millis();
  int   read_duration = m_rate * 1000;  /* 3s */
  int   diff          = now - m_previous_time;

  if (diff <= read_duration)
    {
      /* Do not get data. Because the interval of the cycle is short.
       * Return as a normal end
       */

      return SENSORCLIENT_ECODE_OK;
    }

  if (diff >= GAS_INTERVAL_THRESHOLD)
    {
       /* Input interval exceeded threshold. Clear the buffer. */

       m_previous_time = now;
       printf("Input interval exceeded threshold!\n");
    }
  else
    {
      /* Update previous time */

       m_previous_time += read_duration;
    }

  /* Read raw accelerometer measurements from BME680 */

  FAR struct gas_sensor_s *p_src =
    reinterpret_cast<struct gas_sensor_s *>(m_mh.getPa());

  p_src.temp = temp;
  p_src.humi = humi;
  p_src.pres = pres;
  p_src.gas  = gas;

  /* Check if the sample for one process has accumulated */

  publish(m_mh,
          sizeof(struct gas_sensor_s),
          m_rate,
          m_sample_watermark_num,
          now);

      /* Create new memory buffer. */


  if (ERR_OK != m_mh.allocSeg(
                  SENSOR_DATA_BUF_POOL,
                  sizeof(struct gas_sensor_s))
        {
          /* Fatal error occured. */
          printf("Fail to allocate segment of memory handle.\n");
          assert(0);
        }
    }

  return SENSORCLIENT_ECODE_OK;
}

GasSensorClass GasSensor;

  FAR struct gas_sensor_s *p_src =
    reinterpret_cast<struct gas_sensor_s *>(m_mh.getPa());

  p_src.temp = temp;
  p_src.humi = humi;
  p_src.pres = pres;
  p_src.gas  = gas;

  publish(m_mh,
          sizeof(struct gas_sensor_s),
          m_rate,
          m_sample_watermark_num,
          now);

  if (ERR_OK != m_mh.allocSeg(
                  SENSOR_DATA_BUF_POOL,
                  sizeof(struct gas_sensor_s))
        {
          /* Fatal error occured. */
          printf("Fail to allocate segment of memory handle.\n");
          assert(0);
        }
    }

#include <MemoryUtil.h>
#include <SensorManager.h>
#include <GasSensor.h>

#define SensorClientID06 GasSensorID

void setup(void)
{
  GasSensor.begin(GasSensorID,3,sizeof(struct gas_sensor_s));

void loop(void)
{

　（略）

    output += ", " + String(iaqSensor.breathVocEquivalent);
    output += ", " + String(iaqSensor.rawTemperature);
    output += ", " + String(iaqSensor.rawHumidity);
    output += ", " + String(iaqSensor.gasResistance);
    Serial.println(output);

    );

    GasSensor.write_data(iaqSensor.temperature,iaqSensor.humidity,iaqSensor.pressure,iaqSensor.staticIaq);