Add relay

Author: Ian Gabaraev

cf .clang-formatcf renamed to .clang-format

@@ -1,11 +1,13 @@
+# Generated from CLion C/C++ Code Style settings
 ---
 Language: Cpp
-BasedOnStyle: Google
+BasedOnStyle: LLVM
 AccessModifierOffset: -4
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
 AlignOperands: true
 AlignTrailingComments: false
+AlwaysBreakTemplateDeclarations: Yes
 BraceWrapping: 
   AfterCaseLabel: false
   AfterClass: false
@@ -29,7 +31,6 @@ BreakConstructorInitializersBeforeComma: false
 ColumnLimit: 120
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ContinuationIndentWidth: 8
-IncludeBlocks: Preserve
 IncludeCategories: 
   - Regex: '^<.*'
     Priority: 1
@@ -38,18 +39,17 @@ IncludeCategories:
   - Regex: '.*'
     Priority: 3
 IncludeIsMainRegex: '([-_](test|unittest))?$'
+IndentCaseLabels: true
 IndentWidth: 4
 InsertNewlineAtEOF: true
 MacroBlockBegin: ''
 MacroBlockEnd: ''
 MaxEmptyLinesToKeep: 2
 NamespaceIndentation: All
-PointerAlignment: Right
 SpaceAfterCStyleCast: true
 SpaceAfterTemplateKeyword: false
 SpaceBeforeRangeBasedForLoopColon: false
 SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
 SpacesInAngles: false
 SpacesInConditionalStatement: false
 SpacesInCStyleCastParentheses: false

.gitignore

@@ -62,3 +62,6 @@ dkms.conf
 *.crt
 *.csr
 *.pem
+
+# Log
+*.log

main.c

@@ -4,7 +4,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "MQTTClient.h"
 #include "src/buffer/synchronous_single_buffer.h"
 #include "src/capture/capture.h"
 #include "src/config/config.h"
@@ -16,61 +15,56 @@ AppConfig app_config;
 AvailableDevice available_devices;
 
 int input_device_id(const AvailableDevice *devices) {
-  int c;
-  printf("\u25b6 Please enter device #: \n");
-  while ((c = getchar()) != EOF && !isspace(c)) {
-    const int n = c - '0';
-    if (in_array(devices->device_ids, devices->device_count, n)) {
-      return n;
+    int c;
+    printf("\u25b6 Please enter device #: \n");
+    while ((c = getchar()) != EOF && !isspace(c)) {
+        const int n = c - '0';
+        if (in_array(devices->device_ids, devices->device_count, n)) {
+            return n;
+        }
     }
-  }
-  printf("Not found. Using default # 0\n");
-  return 0;
+    printf("Not found. Using default # 0\n");
+    return 0;
 }
 
 SynchronousSingleBuffer buffer;
+int16_t storage[SYNCHRONOUS_SINGULAR_BUFFER_SIZE] = {0};
 
 int main(const int argc, char *argv[]) {
-  if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
-    help();
-    return 0;
-  }
-  if (argc <= 1) {
-    printf("Args missing");
-    return 0;
-  }
-  const char *mqtt_topic = argv[2];
-  const char *certs_path = argv[3];
-  const char *aws_endpoint = argv[4];
-  // MQTTConfig mqtt_config;
-  // init_config(mqtt_topic, certs_path, aws_endpoint, &mqtt_config);
-  // MQTTClient client;
-  // init_client(&client, &mqtt_config);
-  // send_message(&client, &mqtt_config, "Device connected");
+    if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
+        help();
+        return 0;
+    }
+    if (argc <= 1) {
+        printf("Args missing");
+        return 0;
+    }
+    const char *mqtt_topic = argv[2];
+    const char *certs_path = argv[3];
+    const char *aws_endpoint = argv[4];
+    MQTTConfig mqtt_config;
+    init_config(mqtt_topic, certs_path, aws_endpoint, &mqtt_config);
+    init_client(&mqtt_config);
+    send_message(&mqtt_config, "Device connected");
 
-  suppress_alsa_errors();
-  int16_t *storage = calloc(SYNCHRONOUS_SINGULAR_BUFFER_SIZE, sizeof(int16_t));
-  buffer.storage = storage;
-  init_buffer(&buffer, storage);
+    suppress_alsa_errors();
+    buffer.storage = storage;
+    init_buffer(&buffer, storage);
 
-  load_ultrasonic_devices(&available_devices);
-  describe_available_ultrasonic_devices(&available_devices);
+    load_ultrasonic_devices(&available_devices);
+    describe_available_ultrasonic_devices(&available_devices);
 
-  const int device_id = input_device_id(&available_devices);
-  (void)getchar();
-  AudioDevice audio_device = available_devices.devices[device_id];
+    const int device_id = input_device_id(&available_devices);
+    (void) getchar();
+    AudioDevice audio_device = available_devices.devices[device_id];
 
-  pthread_t r_thread;
-  ReaderContext reader_context = {&buffer, SYNCHRONOUS_SINGULAR_BUFFER_SIZE,
-                                  audio_device.default_sample_rate_hz};
-  pthread_create(&r_thread, NULL, (void *(*)(void *))reader_thread,
-                 &reader_context);
+    pthread_t r_thread;
+    ReaderContext reader_context = {&buffer, SYNCHRONOUS_SINGULAR_BUFFER_SIZE, audio_device.default_sample_rate_hz};
+    pthread_create(&r_thread, NULL, (void *(*) (void *) ) reader_thread, &reader_context);
 
-  start_stream(SYNCHRONOUS_SINGULAR_BUFFER_SIZE, &audio_device, &buffer);
-  pthread_join(r_thread, NULL);
+    start_stream(SYNCHRONOUS_SINGULAR_BUFFER_SIZE, &audio_device, &buffer);
+    pthread_join(r_thread, NULL);
 
-  free(storage);
-  // MQTTClient_disconnect(client, mqtt_config.timeout_ms);
-  // MQTTClient_destroy(&client);
-  return 0;
+    cleanup();
+    return 0;
 }

reformat.sh

@@ -0,0 +1,2 @@
+ #/bin/bash
+ clang-format -i $(find . -name "*.c" -o -name "*.h")

src/buffer/ring_buffer.c

@@ -2,43 +2,37 @@
 
 #define RING_BUFFER_SIZE 4096
 
-static size_t next_pos(const RingBuffer *rb, size_t pos) {
-  return (pos + 1) % rb->size;
-}
+static size_t next_pos(const RingBuffer *rb, size_t pos) { return (pos + 1) % rb->size; }
 
-bool ring_buffer_is_empty(const RingBuffer *rb) {
-  return rb->write_index == rb->read_index;
-}
+bool ring_buffer_is_empty(const RingBuffer *rb) { return rb->write_index == rb->read_index; }
 
-bool ring_buffer_is_full(const RingBuffer *rb) {
-  return next_pos(rb, rb->write_index) == rb->read_index;
-}
+bool ring_buffer_is_full(const RingBuffer *rb) { return next_pos(rb, rb->write_index) == rb->read_index; }
 
 void ring_buffer_init(RingBuffer *rb, float *storage, size_t size) {
-  rb->data = storage;
-  rb->size = size;
+    rb->data = storage;
+    rb->size = size;
 
-  rb->write_count = 0;
-  rb->read_index = 0;
-  rb->write_index = 0;
+    rb->write_count = 0;
+    rb->read_index = 0;
+    rb->write_index = 0;
 }
 
 bool ring_buffer_push(RingBuffer *rb, float sample) {
-  if (ring_buffer_is_full(rb)) {
-    return false;
-  }
-  rb->data[rb->write_index] = sample;
-  rb->write_count++;
-  rb->write_index = next_pos(rb, rb->write_index);
-
-  return true;
+    if (ring_buffer_is_full(rb)) {
+        return false;
+    }
+    rb->data[rb->write_index] = sample;
+    rb->write_count++;
+    rb->write_index = next_pos(rb, rb->write_index);
+
+    return true;
 }
 
 bool ring_buffer_pop(RingBuffer *rb, float *out) {
-  if (ring_buffer_is_empty(rb)) {
-    return false;
-  }
-  *out = rb->data[rb->read_index];
-  rb->read_index = next_pos(rb, rb->read_index);
-  return true;
+    if (ring_buffer_is_empty(rb)) {
+        return false;
+    }
+    *out = rb->data[rb->read_index];
+    rb->read_index = next_pos(rb, rb->read_index);
+    return true;
 }

src/buffer/ring_buffer.h

@@ -3,11 +3,11 @@
 #include <stddef.h>
 
 typedef struct {
-  float *data;
-  size_t size;
-  size_t read_index;
-  size_t write_index;
-  size_t write_count;
+    float *data;
+    size_t size;
+    size_t read_index;
+    size_t write_index;
+    size_t write_count;
 } RingBuffer;
 
 void ring_buffer_init(RingBuffer *rb, float *storage, size_t size);

src/buffer/synchronous_single_buffer.c

@@ -4,62 +4,59 @@
 #include <stdlib.h>
 
 bool init_buffer(SynchronousSingleBuffer *buffer, int16_t *storage) {
-  if (storage == NULL) {
-    fprintf(stderr, "Buffer storage is NULL\n");
-    return false;
-  }
-  buffer->write_count = 0;
-  buffer->reading_at = 0;
-  buffer->writing_at = 0;
-  buffer->skipped_samples_count = 0;
-  buffer->storage = storage;
-  buffer->producer_online = true;
-
-  return true;
+    if (storage == NULL) {
+        fprintf(stderr, "Buffer storage is NULL\n");
+        return false;
+    }
+    buffer->write_count = 0;
+    buffer->reading_at = 0;
+    buffer->writing_at = 0;
+    buffer->skipped_samples_count = 0;
+    buffer->storage = storage;
+    buffer->producer_online = true;
+
+    return true;
 };
 
-bool buffer_empty(const SynchronousSingleBuffer *buffer) {
-  return buffer->write_count == 0;
-}
+bool buffer_empty(const SynchronousSingleBuffer *buffer) { return buffer->write_count == 0; }
 
 bool rewind_buffer(SynchronousSingleBuffer *buffer) {
-  buffer->reading_at = 0;
-  buffer->writing_at = 0;
+    buffer->reading_at = 0;
+    buffer->writing_at = 0;
 
-  return true;
+    return true;
 }
 
 bool buffer_full(const SynchronousSingleBuffer *buffer) {
-  return buffer->writing_at == SYNCHRONOUS_SINGULAR_BUFFER_SIZE;
+    return buffer->writing_at == SYNCHRONOUS_SINGULAR_BUFFER_SIZE;
 };
 
 bool buffer_blocked(SynchronousSingleBuffer *buffer) {
-  return buffer_full(buffer) && buffer->reading_at != buffer->writing_at;
+    return buffer_full(buffer) && buffer->reading_at != buffer->writing_at;
 };
 
 bool buffer_overwrite(SynchronousSingleBuffer *buffer) {
-  return buffer->write_count > 0 &&
-         !(buffer->write_count % SYNCHRONOUS_SINGULAR_BUFFER_SIZE);
+    return buffer->write_count > 0 && !(buffer->write_count % SYNCHRONOUS_SINGULAR_BUFFER_SIZE);
 };
 
 bool write_to_buffer(SynchronousSingleBuffer *buffer, const int16_t value) {
-  if (buffer_full(buffer) && buffer_blocked(buffer)) {
-    buffer->skipped_samples_count++;
-    return false;
-  }
-  if (buffer_full(buffer) && !buffer_blocked(buffer)) {
-    rewind_buffer(buffer);
-  }
-  buffer->storage[buffer->writing_at] = value;
-  buffer->write_count++;
-  buffer->writing_at++;
-
-  return true;
+    if (buffer_full(buffer) && buffer_blocked(buffer)) {
+        buffer->skipped_samples_count++;
+        return false;
+    }
+    if (buffer_full(buffer) && !buffer_blocked(buffer)) {
+        rewind_buffer(buffer);
+    }
+    buffer->storage[buffer->writing_at] = value;
+    buffer->write_count++;
+    buffer->writing_at++;
+
+    return true;
 };
 
 int16_t *read_from_buffer(SynchronousSingleBuffer *buffer) {
-  int16_t *value = &buffer->storage[buffer->reading_at];
-  buffer->reading_at++;
+    int16_t *value = &buffer->storage[buffer->reading_at];
+    buffer->reading_at++;
 
-  return value;
+    return value;
 };

src/buffer/synchronous_single_buffer.h

@@ -5,20 +5,22 @@
 #define SYNCHRONOUS_SINGULAR_BUFFER_SIZE 128000
 
 typedef struct {
-  uint64_t write_count;
-  uint32_t writing_at;
-  uint32_t reading_at;
-  int16_t *storage;
-  bool producer_online;
-  uint32_t skipped_samples_count;
+    uint64_t write_count;
+    uint32_t writing_at;
+    uint32_t reading_at;
+    int16_t *storage;
+    bool producer_online;
+    uint32_t skipped_samples_count;
 } SynchronousSingleBuffer;
 
+void destroy_buffer(SynchronousSingleBuffer *buffer);
+
 bool init_buffer(SynchronousSingleBuffer *buffer, int16_t *storage);
 bool buffer_blocked(SynchronousSingleBuffer *buffer);
-void destroy_buffer(SynchronousSingleBuffer *buffer);
 bool buffer_empty(const SynchronousSingleBuffer *buffer);
 bool buffer_full(const SynchronousSingleBuffer *buffer);
 bool write_to_buffer(SynchronousSingleBuffer *buffer, int16_t value);
-int16_t *read_from_buffer(SynchronousSingleBuffer *buffer);
 bool buffer_overwrite(SynchronousSingleBuffer *buffer);
 bool rewind_buffer(SynchronousSingleBuffer *buffer);
+
+int16_t *read_from_buffer(SynchronousSingleBuffer *buffer);