Rename ChirpConnect to ChirpSDK

Author: joextodd

CHANGELOG.md

@@ -2,7 +2,10 @@
 
 Recent changes to the [Chirp Arduino SDK](https://developers.chirp.io/docs).
 
-## v3.3.1 (beta)
+## v3.4.0 (beta)
+ - Rename ChirpConnect to ChirpSDK
+
+## v3.3.1 (22/08/2019)
  - Use high frequency oscillator in Nano 33 Sense examples
 
 ## v3.3.0 (09/08/2019)

README.md

@@ -51,7 +51,7 @@ File > Examples > ChirpSDK > Example
 and you can include the headers to use Chirp in your own code by adding:
 
 ```
-#include "chirp_connect.h"
+#include "chirp_sdk.h"
 ```
 
 ## Usage
@@ -62,37 +62,37 @@ secret and config from the [Developer Hub](https://developers.chirp.io).
 *Note* You must select the `16khz-mono-embedded` protocol from the dropdown menu, when
 selecting your chirp configuration.
 
-    chirp = new_chirp_connect(APP_KEY, APP_SECRET);
+    chirp = new_chirp_sdk(APP_KEY, APP_SECRET);
     if (chirp == NULL) {
         Serial.println("Chirp initialisation failed.");
         return;
     }
 
 Then set any required callbacks and start the SDK running.
 
-    chirp_connect_error_code_t err = chirp_connect_set_config(chirp, APP_CONFIG);
-    if (err != CHIRP_CONNECT_OK)
+    chirp_sdk_error_code_t err = chirp_sdk_set_config(chirp, APP_CONFIG);
+    if (err != CHIRP_SDK_OK)
         return;
 
-    chirp_connect_callback_set_t callbacks = {0};
+    chirp_sdk_callback_set_t callbacks = {0};
     callbacks.on_received = onReceivedCallback;
-    err = chirp_connect_set_callbacks(chirp, callbacks);
-    if (err != CHIRP_CONNECT_OK)
+    err = chirp_sdk_set_callbacks(chirp, callbacks);
+    if (err != CHIRP_SDK_OK)
         return;
 
-    err = chirp_connect_set_callback_ptr(chirp, chirp);
-    if (err != CHIRP_CONNECT_OK)
+    err = chirp_sdk_set_callback_ptr(chirp, chirp);
+    if (err != CHIRP_SDK_OK)
         return;
 
-    err = chirp_connect_set_input_sample_rate(chirp, input_sample_rate);
-    if (err != CHIRP_CONNECT_OK)
+    err = chirp_sdk_set_input_sample_rate(chirp, input_sample_rate);
+    if (err != CHIRP_SDK_OK)
         return;
-    err = chirp_connect_set_output_sample_rate(chirp, output_sample_rate);
-    if (err != CHIRP_CONNECT_OK)
+    err = chirp_sdk_set_output_sample_rate(chirp, output_sample_rate);
+    if (err != CHIRP_SDK_OK)
         return;
 
-    err = chirp_connect_start(chirp);
-    if (err != CHIRP_CONNECT_OK)
+    err = chirp_sdk_start(chirp);
+    if (err != CHIRP_SDK_OK)
         return;
 
 ## Callbacks
@@ -102,17 +102,17 @@ The received data is passed back to the `onReceivedCallback` function. If the pa
     void
     onReceivedCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
         if (payload) {
-            char *hexString = chirp_connect_as_string(chirp, payload, length);
+            char *hexString = chirp_sdk_as_string(chirp, payload, length);
             Serial.printf("Received data = %s\n", hexString);
-            chirp_connect_free(hexString);
+            chirp_sdk_free(hexString);
         } else {
             Serial.println("Decode failed.");
         }
     }
 
 A complete list of callbacks is shown below.
 
-    void onStateChangedCallback(void *ptr, chirp_connect_state_t old_state, chirp_connect_state_t new_state) {
+    void onStateChangedCallback(void *ptr, chirp_sdk_state_t old_state, chirp_sdk_state_t new_state) {
         // Put here what you want to do when the SDK's state is changing.
     }
 
@@ -133,17 +133,17 @@ A complete list of callbacks is shown below.
     }
 
     // If you don't set all the callbacks, make sure the unused callbacks are set to NULL.
-    chirp_connect_callback_set_t callbacks_set = {
+    chirp_sdk_callback_set_t callbacks_set = {
         .on_state_changed = on_state_changed_callback,
         .on_sending = on_sending_callback,
         .on_sent = on_sent_callback,
         .on_receiving = on_receiving_callback,
         .on_received = on_received_callback
     };
-    err = chirp_connect_set_callbacks(chirp, callbacks_set);
-    if (err != CHIRP_CONNECT_OK)
+    err = chirp_sdk_set_callbacks(chirp, callbacks_set);
+    if (err != CHIRP_SDK_OK)
     {
-        const char *error_string = chirp_connect_error_code_to_string(err);
+        const char *error_string = chirp_sdk_error_code_to_string(err);
         printf("%s\n", error_string);
     }
 
@@ -152,31 +152,31 @@ A complete list of callbacks is shown below.
 
 A Chirp payload is simply an array of bytes. You can send a random data payload to the speakers like so.
 
-    size_t payload_length = chirp_connect_get_max_payload_length(chirp);
-    uint8_t *payload = chirp_connect_random_payload(chirp, &payload_length);
+    size_t payload_length = chirp_sdk_get_max_payload_length(chirp);
+    uint8_t *payload = chirp_sdk_random_payload(chirp, &payload_length);
 
-    err = chirp_connect_send(chirp, payload, payload_length);
-    if (err != CHIRP_CONNECT_OK) {
-        const char *error_string = chirp_connect_error_code_to_string(err);
+    err = chirp_sdk_send(chirp, payload, payload_length);
+    if (err != CHIRP_SDK_OK) {
+        const char *error_string = chirp_sdk_error_code_to_string(err);
         printf("%s\n", error_string);
     }
 
 Or you can easily send an ASCII string
 
     char *identifier = "hello";
-    err = chirp_connect_send(chirp, (uint8_t *)identifier, strlen(identifier));
-    if (err != CHIRP_CONNECT_OK) {
-        const char *error_string = chirp_connect_error_code_to_string(err);
+    err = chirp_sdk_send(chirp, (uint8_t *)identifier, strlen(identifier));
+    if (err != CHIRP_SDK_OK) {
+        const char *error_string = chirp_sdk_error_code_to_string(err);
         printf("%s\n", error_string);
     }
 
 ## Processing
 
 To process audio data from the microphone, and fill the output buffer with audio data, call the following functions with data periodically.
 
-    err = chirp_connect_process_input(chirp, input_buffer, input_buffer_length);
+    err = chirp_sdk_process_input(chirp, input_buffer, input_buffer_length);
 
-    err = chirp_connect_process_output(chirp, output_buffer, output_buffer_length);
+    err = chirp_sdk_process_output(chirp, output_buffer, output_buffer_length);
 
 ***
 

examples/ESP32Receive/ESP32Receive.ino

@@ -21,7 +21,7 @@
   ----------------------------------------------------------------------------*/
 #include <driver/i2s.h>
 
-#include "chirp_connect.h"
+#include "chirp_sdk.h"
 #include "credentials.h"
 
 #define I2SI_DATA         12     // I2S DATA IN on GPIO32
@@ -46,14 +46,14 @@
 
 // Global variables ------------------------------------------------------------
 
-static chirp_connect_t *chirp = NULL;
-static chirp_connect_state_t currentState = CHIRP_CONNECT_STATE_NOT_CREATED;
+static chirp_sdk_t *chirp = NULL;
+static chirp_sdk_state_t currentState = CHIRP_SDK_STATE_NOT_CREATED;
 static bool startTasks = false;
 
 // Function definitions --------------------------------------------------------
 
 void setupChirp();
-void chirpErrorHandler(chirp_connect_error_code_t code);
+void chirpErrorHandler(chirp_sdk_error_code_t code);
 void setupAudioInput(int sample_rate);
 
 // Function declarations -------------------------------------------------------
@@ -72,7 +72,7 @@ void setup()
 void loop()
 {
   esp_err_t audioError;
-  chirp_connect_error_code_t chirpError;
+  chirp_sdk_error_code_t chirpError;
 
   if (startTasks)
   {
@@ -87,7 +87,7 @@ void initTask(void *parameter)
 {
   setupChirp();
 
-  chirp_connect_error_code_t chirpError = chirp_connect_set_input_sample_rate(chirp, SAMPLE_RATE);
+  chirp_sdk_error_code_t chirpError = chirp_sdk_set_input_sample_rate(chirp, SAMPLE_RATE);
   chirpErrorHandler(chirpError);
   setupAudioInput(SAMPLE_RATE);
 
@@ -99,13 +99,13 @@ void initTask(void *parameter)
 void processInputTask(void *parameter)
 {
   esp_err_t audioError;
-  chirp_connect_error_code_t chirpError;
+  chirp_sdk_error_code_t chirpError;
 
   size_t bytesLength = 0;
   float buffer[BUFFER_SIZE] = {0};
   int32_t ibuffer[BUFFER_SIZE] = {0};
 
-  while (currentState >= CHIRP_CONNECT_STATE_RUNNING)
+  while (currentState >= CHIRP_SDK_STATE_RUNNING)
   {
     audioError = i2s_read(I2S_NUM_0, ibuffer, BUFFER_SIZE * 4, &bytesLength, portMAX_DELAY);
     if (bytesLength)
@@ -115,7 +115,7 @@ void processInputTask(void *parameter)
         buffer[i] = (float) CONVERT_INPUT(ibuffer[i]);
       }
 
-      chirpError = chirp_connect_process_input(chirp, buffer, bytesLength / 4);
+      chirpError = chirp_sdk_process_input(chirp, buffer, bytesLength / 4);
       chirpErrorHandler(chirpError);
     }
   }
@@ -124,7 +124,7 @@ void processInputTask(void *parameter)
 
 // Chirp -----------------------------------------------------------------------
 
-void onStateChangedCallback(void *chirp, chirp_connect_state_t previous, chirp_connect_state_t current)
+void onStateChangedCallback(void *chirp, chirp_sdk_state_t previous, chirp_sdk_state_t current)
 {
   currentState = current;
   Serial.printf("State changed from %d to %d\n", previous, current);
@@ -154,38 +154,38 @@ void onReceivedCallback(void *chirp, uint8_t *payload, size_t length, uint8_t ch
 
 void setupChirp()
 {
-  chirp = new_chirp_connect(CHIRP_APP_KEY, CHIRP_APP_SECRET);
+  chirp = new_chirp_sdk(CHIRP_APP_KEY, CHIRP_APP_SECRET);
   if (chirp == NULL)
   {
     Serial.println("Chirp initialisation failed.");
     return;
   }
 
-  chirp_connect_error_code_t err = chirp_connect_set_config(chirp, CHIRP_APP_CONFIG);
+  chirp_sdk_error_code_t err = chirp_sdk_set_config(chirp, CHIRP_APP_CONFIG);
   chirpErrorHandler(err);
 
-  chirp_connect_callback_set_t callbacks = {0};
+  chirp_sdk_callback_set_t callbacks = {0};
   callbacks.on_state_changed = onStateChangedCallback;
   callbacks.on_receiving = onReceivingCallback;
   callbacks.on_received = onReceivedCallback;
 
-  err = chirp_connect_set_callbacks(chirp, callbacks);
+  err = chirp_sdk_set_callbacks(chirp, callbacks);
   chirpErrorHandler(err);
 
-  err = chirp_connect_set_callback_ptr(chirp, chirp);
+  err = chirp_sdk_set_callback_ptr(chirp, chirp);
   chirpErrorHandler(err);
 
-  err = chirp_connect_start(chirp);
+  err = chirp_sdk_start(chirp);
   chirpErrorHandler(err);
 
-  Serial.println("Chirp Connect initialised.");
+  Serial.println("Chirp SDK initialised.");
 }
 
-void chirpErrorHandler(chirp_connect_error_code_t code)
+void chirpErrorHandler(chirp_sdk_error_code_t code)
 {
-  if (code != CHIRP_CONNECT_OK)
+  if (code != CHIRP_SDK_OK)
   {
-    const char *error_string = chirp_connect_error_code_to_string(code);
+    const char *error_string = chirp_sdk_error_code_to_string(code);
     Serial.println(error_string);
     exit(42);
   }