Spresense Arduino Examples & Tutorials

theAudio->setPlayerMode(device,          (1)
                        player0bufsize,  (2)
                        player1bufsize); (3)

theAudio->setBeep(enable,       (1)
                   volume,      (2)
                   frequency);  (3)

theAudio->setRenderingClockMode(mode); (1)

theAudio->setPlayerMode(device,    (1)
                         sp_drv);  (2)

theAudio->initPlayer(id,         (1)
                     codec,      (2)
                     codec_path, (3)
                     fs,         (4)
                     channel);   (5)

theAudio->writeFrames(id,       (1)
                       myFile); (2)

theAudio->startPlayer(id); (1)

theAudio->stopPlayer(id,      (1)
                      mode);  (2)

theAudio->setVolume(volume); (1)

theAudio->setRenderingClockMode(mode); (1)

theAudio->setPlayerMode(device,    (1)
                         sp_drv);  (2)

theAudio->initPlayer(id,         (1)
                     codec,      (2)
                     codec_path, (3)
                     fs,         (4)
                     channel);   (5)

theAudio->writeFrames(id,      (1)
                      myFile); (2)

theAudio->startPlayer(id); (1)

theAudio->stopPlayer(id,      (1)
                      mode);  (2)

theAudio->setVolume(volume); (1)

theAudio->setRenderingClockMode(mode); (1)

theAudio->setPlayerMode(device,    (1)
                         sp_drv);  (2)

theAudio->initPlayer(id,         (1)
                     codec,      (2)
                     codec_path, (3)
                     fs,         (4)
                     bitlen,     (5)
                     channel);   (6)

theAudio->writeFrames(id,      (1)
                      myFile); (2)

theAudio->startPlayer(id); (1)

theAudio->stopPlayer(id,      (1)
                      mode);  (2)

theAudio->setVolume(volume); (1)

theAudio->setRenderingClockMode(mode); (1)

theAudio->setPlayerMode(device,    (1)
                         sp_drv);  (2)

theAudio->initPlayer(id,         (1)
                     codec,      (2)
                     codec_path, (3)
                     fs,         (4)
                     channel);   (5)

theAudio->writeFrames(id,       (1)
                       myFile); (2)

theAudio->startPlayer(id); (1)

theAudio->stopPlayer(id,      (1)
                      mode);  (2)

theAudio->setVolume(master,   (1)
                    player0,  (2)
                    player1); (3)

theAudio->setThroughMode(input,      (1)
                         i2s_out,    (2)
                         sp_out,     (3)
                         input_gain, (4)
                         sp_drv);    (5)

theAudio->setRecorderMode(input_device, (1)
                          input_gain,   (2)
                          bufsize,      (3)
                          is_digital);  (4)

theAudio->initRecorder(codec,      (1)
                       codec_path, (2)
                       fs,         (3)
                       channel);   (4)

theAudio->readFrames(myFile); (1)

theAudio->setRecorderMode(input_device, (1)
                          input_gain,   (2)
                          bufsize,      (3)
                          is_digital);  (4)

theAudio->initRecorder(codec,      (1)
                       codec_path, (2)
                       fs,         (3)
                       channel);   (4)

theAudio->writeWavHeader(myFile); (1)

theAudio->readFrames(myFile); (1)

theAudio-> setRecorderMode(input_device); (1)

theAudio->initRecorder(codec,      (1)
                       codec_path, (2)
                       fs,         (3)
                       channel);   (4)

theAudio-> readFrames(p_buffer, (1)
                      buffer_size, (2)
                      read_size); (3)

   initMemoryPools ();
   createStaticPools (no); (1)

theMixer->setRenderingClkMode(mode); (1)

theMixer->begin();                              (1)
thePlayer->begin();                             (2)
thePlayer->create(                              (3)
                    id,                         (4)
                    attention_cb);              (5)
theMixer->create(                               (6)
                    attention_cb);              (5)
thePlayer->activate(                            (7)
                    id,                         (4)
                    mediaplayer_done_callback); (8)
theMixer->activate(                             (9)
                    OutputMixer0,               (10)
                    HPOutputDevice,             (11)
                    outputmixer_done_callback); (12)

thePlayer->initPlayer(id,        (1)
                     codec,      (2)
                     codec_path, (3)
                     fs,         (4)
                     channel);   (5)

thePlayer->writeFrames(id,     (1)
                      myFile); (2)

thePlayer->setVolume(volume); (1)

thePlayer->startPlayer(id,   (1)
                       mediaplayer_decode_callback (2)
                      );

theMixer->sendData (OutputMixer0,
                    outmixer_send_callback,
                    pcm_param);

thePlayer->stopPlayer(id,    (1)
                      mode); (2)

thePlayer->setVolume(master,   (1)
                     player0,  (2)
                     player1); (3)

   initMemoryPools ();
   createStaticPools (no); (1)

theMixer->setRenderingClkMode(mode); (1)

theMixer->begin();                              (1)
theMixer->create(                               (2)
                    attention_cb);              (3)
theMixer->activate(                             (4)
                    OutputMixer0,               (5)
                    HPOutputDevice,             (6)
                    outputmixer_done_callback); (7)

thePlayer->setVolume(volume); (1)

theMixer->sendData(OutputMixer0,
                   outmixer_send_callback,
                   pcm_param);

static bool getFrame(AsPcmDataParam * pcm) {

     if (! getFrame(& pcm_param)) {       : Read from Fifo here
       break;
     }

     / * Send PCM * /
     pcm_param.is_end = false;
     pcm_param.is_valid = true;
     if (pcm_param.size == 0) {           : If it cannot be read, the size is 0.
       pcm_param.size = READSIZE;
       pcm_param.sample = pcm_param.size / BYTEWIDTH / CHNUM;
       memset (pcm_param.mh.getPa(), 0, pcm_param.size);         : If it cannot be read, fill in 0 and output.
     }

   initMemoryPools ();
   createStaticPools (no); (1)

theRecorder->begin(                         (1)
                   attention_cb);           (2)
theRecorder->activate(                      (3)
                      dev,                  (4)
                      done_callback);       (5)

theRecorder-> setCapturingClkMode(mode); (1)

theRecorder->init(codec,      (1)
                  channel,    (2)
                  fs,         (3)
                  bits,       (4)
                  bitrate,    (5)
                  path);      (6)

theRecorder->readFrames(ptr,          (1)
                        buffer_size,  (2)
                        size);        (3)

theRecorder->stop();

   initMemoryPools ();
   createStaticPools (no); (1)

theRecorder->begin(                         (1)
                   attention_cb);           (2)
theRecorder->activate(                      (3)
                      dev,                  (4)
                      done_callback);       (5)

theRecorder-> setCapturingClkMode(mode); (1)

theRecorder->init(codec,      (1)
                  channel,    (2)
                  fs,         (3)
                  bits,       (4)
                  bitrate,    (5)
                  path);      (6)

theRecorder->readFrames(ptr,          (1)
                        buffer_size,  (2)
                        size);        (3)

theRecorder->stop();

static const int32_t channel_num  = AS_CHANNEL_4CH;                                     (1)
static const int32_t bit_length   = AS_BITLENGTH_16;                                    (2)
static const int32_t frame_sample = 384;                                                (3)
static const int32_t frame_size   = frame_sample * (bit_length / 8) * channel_num;      (4)

static CMN_SimpleFifoHandle simple_fifo_handle;                                         (5)
static const int32_t fifo_size  = frame_size * 10;                                      (6)
static uint8_t fifo_buffer[fifo_size];                                                  (7)


static const int32_t proc_size  = frame_size * 2;                                       (8)
static uint8_t proc_buffer[proc_size];                                                  (9)

   initMemoryPools ();
   createStaticPools (no); (1)

theFrontEnd = FrontEnd::getInstance();      (1)

theFrontEnd->begin(                         (2)
                   frontend_attention_cb);  (3)

theFrontEnd-> setCapturingClkMode(mode); (1)

theFrontEnd-> activate(frontend_done_callback); (1)

theFrontEnd->init(channel_num,     (1)
                  bit_length,      (2)
                  frame_sample,    (3)
                  path,            (4)
                  dst);            (5)

theFrontEnd->start();

theFrontEnd->stop();

static void frontend_pcm_callback(AsPcmDataParam pcm)
{
  if (!pcm.is_valid) {                                                                              (1)
    puts("Invalid data !");
    return;
  }

  if (CMN_SimpleFifoGetVacantSize(&simple_fifo_handle) < pcm.size) {                                (2)
    puts("Simple FIFO is full !");
    return;
  }

  if (CMN_SimpleFifoOffer(&simple_fifo_handle, (const void*)(pcm.mh.getPa()), pcm.size) == 0) {     (3)
    puts("Simple FIFO is full !");
    return;
  }

  return;
}

bool execute_aframe()
{
  size_t size = CMN_SimpleFifoGetOccupiedSize(&simple_fifo_handle);                  (1)

  if (size > 0) {
    if (size > proc_size) {
      size = (size_t)proc_size;
    }

    if (CMN_SimpleFifoPoll(&simple_fifo_handle, (void*)proc_buffer, size) == 0) {    (2)
      printf("ERROR: Fail to get data from simple FIFO.\n");
      return false;
    }

    signal_process(size);                                                            (3)

  }

// libraries
#include <LTE.h>  (1)

// initialize the library instance
LTEModem modem;  (1)

// IMEI variable
String IMEI = "";     (1)
String VERSION = "";
LTENetworkRatType RAT = LTE_NET_RAT_UNKNOWN;

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(115200);                          (1)
  while (!Serial) {
      ; /* wait for serial port to connect. Needed for native USB port only */
  }

  // start modem test (reset and check response)
  Serial.println("Starting modem test...");
  if (LTE_IDLE == modem.begin()) {               (2)
    Serial.println("modem.begin() succeeded.");
  } else {
    Serial.println("ERROR, no modem answer.");
  }
}

void loop() {

  // IMEI of the modem
  IMEI = modem.getIMEI();                 (1)
  Serial.println("IMEI: " + IMEI);

  //Firmware version of the modem.
  VERSION = modem.getFirmwareVersion();   (2)
  Serial.println("VERSION: " + VERSION);

  // Current RAT of the modem.
  RAT = modem.getRAT();                   (3)

  switch (RAT) {
    case LTE_NET_RAT_CATM:
      Serial.println("RAT: LTE-M (LTE Cat-M1)");
      break;
    case LTE_NET_RAT_NBIOT:
      Serial.println("RAT: NB-IoT");
      break;
    default:
      Serial.println("RAT: Unknown type [" + String(RAT) + "]");
      break;
  }

  sleep(1);
}

// libraries
#include <LTE.h>  (1)

#define APP_LTE_APN "apn" // replace your APN                       (1)

/* APN authentication settings
 * Ignore these parameters when setting LTE_NET_AUTHTYPE_NONE.
 */
#define APP_LTE_USER_NAME "user"     // replace with your username  (2)
#define APP_LTE_PASSWORD  "password" // replace with your password  (3)

// initialize the library instance
LTE        lteAccess;        (1)
LTEScanner scannerNetworks;  (2)

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(115200);                                                           (1)
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  Serial.println("LTE networks scanner");

  while (true) {

    /* Power on the modem and Enable the radio function. */

    if (lteAccess.begin() != LTE_SEARCHING) {                                     (2)
      Serial.println("Could not transition to LTE_SEARCHING.");
      Serial.println("Please check the status of the LTE board.");
      for (;;) {
        sleep(1);
      }
    }

    /* The connection process to the APN will start.
     * If the synchronous parameter is false,
     * the return value will be returned when the connection process is started.
     */
    if (lteAccess.attach(APP_LTE_RAT,
                         APP_LTE_APN,
                         APP_LTE_USER_NAME,
                         APP_LTE_PASSWORD,
                         APP_LTE_AUTH_TYPE,
                         APP_LTE_IP_TYPE) == LTE_READY) {                         (3)
      Serial.println("attach succeeded.");
      break;
    }

    /* If the following logs occur frequently, one of the following might be a cause:
     * - APN settings are incorrect
     * - SIM is not inserted correctly
     * - If you have specified LTE_NET_RAT_NBIOT for APP_LTE_RAT,
     *   your LTE board may not support it.
     * - Rejected from LTE network
     */
    Serial.println("An error has occurred. Shutdown and retry the network attach process after 1 second.");
    lteAccess.shutdown();                                                         (4)
    sleep(1);
  }
}

void loop() {
   // Assigned IP address
  IPAddress address = lteAccess.getIPAddress();         (1)
  Serial.print("IP address: ");
  Serial.println(address);

  // currently connected carrier
  Serial.print("Current carrier: ");
  Serial.println(scannerNetworks.getCurrentCarrier());  (2)

  // return signal strength
  Serial.print("Signal Strength: ");
  Serial.print(scannerNetworks.getSignalStrength());    (3)
  Serial.println(" [dBm]");
  sleep(1);
}

// libraries
#include <LTE.h>  (1)

#define APP_LTE_APN "apn" // replace your APN                       (1)

/* APN authentication settings
 * Ignore these parameters when setting LTE_NET_AUTHTYPE_NONE.
 */
#define APP_LTE_USER_NAME "user"     // replace with your username  (2)
#define APP_LTE_PASSWORD  "password" // replace with your password  (3)

// initialize the library instance
LTE lteAccess;     (1)
LTEClient client;  (2)

// URL, path & port (for example: arduino.cc)
char server[] = "arduino.cc";                      (1)
char path[] = "/asciilogo.txt";                    (2)
int port = 80; // port 80 is the default for HTTP  (3)

void setup()
{
  // initialize serial communications and wait for port to open:
  Serial.begin(115200);                                                           (1)
  while (!Serial) {
      ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("Starting web client.");

  while (true) {

    /* Power on the modem and Enable the radio function. */

    if (lteAccess.begin() != LTE_SEARCHING) {                                     (2)
      Serial.println("Could not transition to LTE_SEARCHING.");
      Serial.println("Please check the status of the LTE board.");
      for (;;) {
        sleep(1);
      }
    }

    /* The connection process to the APN will start.
     * If the synchronous parameter is false,
     * the return value will be returned when the connection process is started.
     */
    if (lteAccess.attach(APP_LTE_RAT,
                         APP_LTE_APN,
                         APP_LTE_USER_NAME,
                         APP_LTE_PASSWORD,
                         APP_LTE_AUTH_TYPE,
                         APP_LTE_IP_TYPE) == LTE_READY) {                         (3)
      Serial.println("attach succeeded.");
      break;
    }

    /* If the following logs occur frequently, one of the following might be a cause:
     * - APN settings are incorrect
     * - SIM is not inserted correctly
     * - If you have specified LTE_NET_RAT_NBIOT for APP_LTE_RAT,
     *   your LTE board may not support it.
     * - Rejected from LTE network
     */
    Serial.println("An error has occurred. Shutdown and retry the network attach process after 1 second.");
    lteAccess.shutdown();                                                         (4)
    sleep(1);
  }

  // if you get a connection, report back via serial:
  if (client.connect(server, port)) {                                             (5)
    Serial.println("connected");
    // Make a HTTP request:
    client.print("GET ");                                                         (6)
    client.print(path);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.println(server);
    client.println("Connection: close");
    client.println();
  } else {
    // if you didn't get a connection to the server:
    Serial.println("connection failed");
  }
}

void loop()
{
  // if there are incoming bytes available
  // from the server, read them and print them:
  if (int len = client.available()) {                (1)
    char buff[len + 1];
    buff[len] = '\0';
    client.read(buff, len);                          (2)
    Serial.print(buff);
  }

  // if the server's disconnected, stop the client:
  if (!client.available() && !client.connected()) {  (3)
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();                                   (4)

    // do nothing forevermore:
    for (;;)
      sleep(1);
  }
}

// libraries
#include <ArduinoHttpClient.h> (1)
#include <RTC.h>               (2)
#include <SDHCI.h>             (3)
#include <LTE.h>               (4)

#define APP_LTE_APN "apn" // replace your APN                       (1)

/* APN authentication settings
 * Ignore these parameters when setting LTE_NET_AUTHTYPE_NONE.
 */
#define APP_LTE_USER_NAME "user"     // replace with your username  (2)
#define APP_LTE_PASSWORD  "password" // replace with your password  (3)

// URL, path & port (for example: httpbin.org)
char server[] = "httpbin.org";                       (1)
char getPath[] = "/get";                             (2)
char postPath[] = "/post";                           (3)
int port = 443; // port 443 is the default for HTTPS (4)

#define ROOTCA_FILE "path/to/cafile"   // Define the path to a file containing CA           (1)
                                       // certificates that are trusted.
#define CERT_FILE   "path/to/certfile" // Define the path to a file containing certificate  (2)
                                       // for this client, if required by the server.
#define KEY_FILE    "path/to/keyfile"  // Define the path to a file containing private key  (3)
                                       // for this client, if required by the server.

// initialize the library instance
LTE lteAccess;
LTETLSClient tlsClient;
HttpClient client = HttpClient(tlsClient, server, port); (1)
SDClass theSD;

// initialize serial communications and wait for port to open:
Serial.begin(115200);
while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
}

Serial.println("Starting secure HTTP client.");

/* Initialize SD */
while (!theSD.begin()) {
; /* wait until SD card is mounted. */
}

  while (true) {

    /* Power on the modem and Enable the radio function. */

    if (lteAccess.begin() != LTE_SEARCHING) {                      (1)
      Serial.println("Could not transition to LTE_SEARCHING.");
      Serial.println("Please check the status of the LTE board.");
      for (;;) {
        sleep(1);
      }
    }

    /* The connection process to the APN will start.
     * If the synchronous parameter is false,
     * the return value will be returned when the connection process is started.
     */
    if (lteAccess.attach(APP_LTE_RAT,
                         APP_LTE_APN,
                         APP_LTE_USER_NAME,
                         APP_LTE_PASSWORD,
                         APP_LTE_AUTH_TYPE,
                         APP_LTE_IP_TYPE) == LTE_READY) {          (2)
      Serial.println("attach succeeded.");
      break;
    }

    /* If the following logs occur frequently, one of the following might be a cause:
     * - APN settings are incorrect
     * - SIM is not inserted correctly
     * - If you have specified LTE_NET_RAT_NBIOT for APP_LTE_RAT,
     *   your LTE board may not support it.
     * - Rejected from LTE network
     */
    Serial.println("An error has occurred. Shutdown and retry the network attach process after 1 second.");
    lteAccess.shutdown();                                          (3)
    sleep(1);
  }

void printClock(RtcTime &rtc)                        (1)
{
  printf("%04d/%02d/%02d %02d:%02d:%02d\n",
         rtc.year(), rtc.month(), rtc.day(),
         rtc.hour(), rtc.minute(), rtc.second());
}

void setup()
{
  :
  // Set local time (not UTC) obtained from the network to RTC.
  RTC.begin();
  unsigned long currentTime;
  while(0 == (currentTime = lteAccess.getTime())) { (2)
    sleep(1);
  }
  RtcTime rtc(currentTime);                         (3)
  printClock(rtc);                                  (4)
  RTC.setTime(rtc);                                 (5)
}

// Set certifications via a file on the SD card before connecting to the server
File rootCertsFile = theSD.open(ROOTCA_FILE, FILE_READ);       (1)
tlsClient.setCACert(rootCertsFile, rootCertsFile.available()); (2)
rootCertsFile.close();

// Remove these commented out if client authentication is required.
//File certsFile = theSD.open(CERT_FILE, FILE_READ);
//tlsClient.setCertificate(certsFile, certsFile.available());  (3)
//certsFile.close();
//File priKeyFile = theSD.open(KEY_FILE, FILE_READ);
//tlsClient.setPrivateKey(priKeyFile, priKeyFile.available()); (4)
//priKeyFile.close();

// HTTP GET method
Serial.println("making GET request");
client.get(getPath);                          (1)

// read the status code and body of the response
int statusCode = client.responseStatusCode(); (2)
String response = client.responseBody();      (3)

Serial.print("Status code: ");
Serial.println(statusCode);                   (4)
Serial.print("Response: ");
Serial.println(response);                     (5)
Serial.println("Wait five seconds");
sleep(5);

// HTTP POST method
Serial.println("making POST request");

String contentType = "application/x-www-form-urlencoded"; (1)
String postData = "name=Alice&age=12";                    (2)

client.post(postPath, contentType, postData);             (3)

// read the status code and body of the response
statusCode = client.responseStatusCode();                 (4)
response = client.responseBody();                         (5)

Serial.print("Status code: ");
Serial.println(statusCode);                               (6)
Serial.print("Response: ");
Serial.println(response);                                 (7)

// do nothing forevermore:
for (;;)
sleep(1);

// libraries
#include <NTPClient.h>  (1)
#include <LTE.h>        (2)

// APN data
#define LTE_APN       "apn"      // replace your APN            (1)
#define LTE_USER_NAME "user"     // replace with your username  (2)
#define LTE_PASSWORD  "password" // replace with your password  (3)

#define NTP_SERVER_NAME "pool.ntp.org"                                                (1)
#define TIME_OFFSET     (9 * 60 * 60) // time offset in seconds(This example is JST)  (2)
#define UPDATE_INTERVAL 60000         // update interval in milliseconds              (3)

// initialize the library instance
LTE lteAccess;                                                                (1)
LTEUDP ntpUDP;                                                                (2)

// You can specify the time server pool and the offset (in seconds, can be
// changed later with setTimeOffset() ). Additionally you can specify the
// update interval (in milliseconds, can be changed using setUpdateInterval() ).
NTPClient timeClient(ntpUDP, NTP_SERVER_NAME, TIME_OFFSET, UPDATE_INTERVAL);  (3)

void setup()
{
  // initialize serial communications and wait for port to open:
  Serial.begin(115200);                                                           (1)
  while (!Serial) {
      ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("Starting NTP client.");

  while (true) {

    /* Power on the modem and Enable the radio function. */

    if (lteAccess.begin() != LTE_SEARCHING) {                                     (2)
      Serial.println("Could not transition to LTE_SEARCHING.");
      Serial.println("Please check the status of the LTE board.");
      for (;;) {
        sleep(1);
      }
    }

    /* The connection process to the APN will start.
     * If the synchronous parameter is false,
     * the return value will be returned when the connection process is started.
     */
    if (lteAccess.attach(APP_LTE_RAT,
                         APP_LTE_APN,
                         APP_LTE_USER_NAME,
                         APP_LTE_PASSWORD,
                         APP_LTE_AUTH_TYPE,
                         APP_LTE_IP_TYPE) == LTE_READY) {                         (3)
      Serial.println("attach succeeded.");
      break;
    }

    /* If the following logs occur frequently, one of the following might be a cause:
     * - APN settings are incorrect
     * - SIM is not inserted correctly
     * - If you have specified LTE_NET_RAT_NBIOT for APP_LTE_RAT,
     *   your LTE board may not support it.
     * - Rejected from LTE network
     */
    Serial.println("An error has occurred. Shutdown and retry the network attach process after 1 second.");
    lteAccess.shutdown();                                                         (4)
    sleep(1);
  }

  timeClient.begin();                                                             (5)
}

void loop() {
  timeClient.update();  (1)

  Serial.println(timeClient.getFormattedTime());

  sleep(1);
}

// APN data
#include <RTC.h>               (1)
#include <SDHCI.h>             (2)
#include <GNSS.h>              (3)
#include <LTE.h>               (4)
#include <ArduinoMqttClient.h> (5)

#define APP_LTE_APN "apn" // replace your APN                       (1)

/* APN authentication settings
 * Ignore these parameters when setting LTE_NET_AUTHTYPE_NONE.
 */
#define APP_LTE_USER_NAME "user"     // replace with your username  (2)
#define APP_LTE_PASSWORD  "password" // replace with your password  (3)