communication.c

Go to the documentation of this file.

#include "communication.h"
 
#include <libtock/peripherals/i2c_master.h>
#include <stdlib.h>
 
static bool g_controller_mutex_lock = false;
 
static const int g_i2c_buffer_size = 32;
 
static const uint8_t g_esp32_i2c_addr = 0x20 << 1;
 
static Buffer tx = {0};
 
static Buffer rx = {0};
 
void ControllerWakeupEsp32(void);
 
ControllerStatus ControllerTransmit(void) {
  // Lock mutex
  g_controller_mutex_lock = true;
 
  // return code storage
  ControllerStatus cont_status = CONTROLLER_SUCCESS;
 
  // wakeup esp32
  ControllerWakeupEsp32();
 
  // create small buffer
  Buffer chunk = {0};
  chunk.data = malloc(g_i2c_buffer_size);
  chunk.size = g_i2c_buffer_size;
  chunk.len = 0;
 
  // shallow copy tx
  Buffer tx_idx = tx;
 
  // flag for final tx
  bool done = false;
 
  // handle data being larger than i2c buffer size
  do {
    // calculate number of bytes to cpy
    size_t num_bytes = 0;
    if (tx_idx.len > (chunk.size - 1)) {
      num_bytes = chunk.size - 1;
    } else {
      num_bytes = tx_idx.len;
      done = true;
    }
 
    // first byte is flag
    chunk.data[0] = (uint8_t)done;
    // rest of the data
    memcpy(chunk.data + 1, tx_idx.data, num_bytes);
    chunk.len = num_bytes + 1;
 
    // transmit data
    int tock_status = RETURNCODE_SUCCESS;
    tock_status =
        i2c_master_write_sync(g_esp32_i2c_addr, chunk.data, chunk.len);
    if (tock_status < 0) {
      cont_status = CONTROLLER_ERROR;
      break;
    }
 
    // increment to next block of data
    tx_idx.data += num_bytes;
    tx_idx.len -= num_bytes;
  } while (!done);
 
  // free allocated memory
  free(chunk.data);
 
  return cont_status;
}
 
ControllerStatus ControllerReceive(void) {
  int tock_status = RETURNCODE_SUCCESS;
 
  ControllerStatus cont_status = CONTROLLER_SUCCESS;
 
  // receive number of incoming bytes
  uint8_t len_bytes[2] = {};
  tock_status =
      i2c_master_read_sync(g_esp32_i2c_addr, len_bytes, sizeof(len_bytes));
  if (tock_status < 0) {
    return CONTROLLER_ERROR;
  }
 
  // convert 2 byte array to 16-bit int
  uint16_t len = (((uint16_t)len_bytes[0]) << 8) | ((uint16_t)len_bytes[1]);
 
  // set number of bytes
  rx.len = len;
 
  // create small buffer
  Buffer chunk = {};
  chunk.data = malloc(g_i2c_buffer_size);
  chunk.size = g_i2c_buffer_size;
  chunk.len = 0;
 
  // copy reference to receive
  Buffer rx_idx = rx;
 
  bool done = false;
 
  do {
    // calculate number of bytes to receive
    size_t num_bytes = 0;
    if (rx_idx.len < (chunk.size - 1)) {
      num_bytes = rx_idx.len;
      done = true;
    } else {
      num_bytes = chunk.size - 1;
    }
    // add 1 for done flag
    chunk.len = num_bytes + 1;
 
    tock_status = i2c_master_read_sync(g_esp32_i2c_addr, chunk.data, chunk.len);
    if (tock_status < 0) {
      cont_status = CONTROLLER_ERROR;
      break;
    }
 
    // check done flag
    if (done != chunk.data[0]) {
      cont_status = CONTROLLER_ERROR;
      break;
    }
 
    // copy data to rx
    memcpy(rx_idx.data, chunk.data + 1, num_bytes);
 
    // increment idx
    rx_idx.data += num_bytes;
    rx_idx.len -= num_bytes;
  } while (!done);
 
  // free buffer space
  free(chunk.data);
 
  // unlock mutex
  g_controller_mutex_lock = false;
 
  return cont_status;
}
 
ControllerStatus ControllerTransaction(void) {
  // status code
  ControllerStatus status = CONTROLLER_SUCCESS;
 
  // transmit, stop early if error
  status = ControllerTransmit();
  if (status != CONTROLLER_SUCCESS) {
    return status;
  }
 
  // Receive
  status = ControllerReceive();
  return status;
}
 
Buffer* ControllerTx(void) { return &tx; }
 
Buffer* ControllerRx(void) { return &rx; }
 
void ControllerWakeupEsp32(void) {}