Spresense Arduino チュートリアル

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)
                      data,        (2)
                      write_size);

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->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->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)

theMixer->setRenderingClkMode(mode); (1)

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

theMixer->setRenderingClkMode(mode); (1)

thePlayer->setVolume(volume); (1)

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

static bool getFrame(AsPcmDataParam *pcm) {

    if (!getFrame(&pcm_param)) {    : ここでFifoから読み出す
      break;
    }

    /* Send PCM */
    pcm_param.is_end = false;
    pcm_param.is_valid = true;
    if (pcm_param.size == 0) {      :読み出しができない場合はサイズが0になっている
      pcm_param.size = READSIZE;
      pcm_param.sample = pcm_param.size / BYTEWIDTH / CHNUM;
      memset(pcm_param.mh.getPa(), 0, pcm_param.size);  : 読み出せていない場合は0を埋めて出力する
    }

  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->start();

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->start();

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;
}

// 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);
}