three_lead_ecg/app/src/basic/ads1293/ads1293.c

/*
 * ADS1293.h
 *
 *  Created on: Jun 6, 2022
 *      Author: Hans Hüttmann
 */
#include "ads1293.h"

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

static uint8_t txcache[256];
static uint8_t rxcache[256];

void ads1293_spi_init(ads1293_t* ads, ads1293_spi_tx_rx_t spi_tx_rx) { ads->spi_tx_rx = spi_tx_rx; }

void ads1293_spi_writereg(ads1293_t* ads, uint8_t addr, uint8_t data) {
  uint8_t txcache[2];
  txcache[0] = ADS1293_WRITE_BIT & addr;
  txcache[1] = data;
  ads->spi_tx_rx(txcache, NULL, 2);
}
uint8_t ads1293_spi_readreg(ads1293_t* ads, uint8_t addr) {
  uint8_t txcache[2];
  txcache[0] = ADS1293_READ_BIT | addr;
  txcache[1] = 0;
  uint8_t rxcache[2];
  ads->spi_tx_rx(txcache, rxcache, 2);
  return rxcache[1];
}
void ads1293_spi_writereg_and_readbak(ads1293_t* ads, uint8_t addr, uint8_t data, uint8_t* readbak) {
  ads1293_spi_writereg(ads, addr, data);
  *readbak = ads1293_spi_readreg(ads, addr);
}

void ads1293_spi_autoinc_writereg(ads1293_t* ads, uint8_t addr, uint8_t* data, uint8_t len) {  //
  len             = len > 255 ? 255 : len;
  uint8_t addbyte = ADS1293_WRITE_BIT & addr;

  txcache[0] = addbyte;
  memcpy(txcache + 1, data, len);

  ads->spi_tx_rx(txcache, NULL, len + 1);
}
void ads1293_spi_autoinc_readreg(ads1293_t* ads, uint8_t addr, uint8_t* data, uint8_t len) {
  len             = len > 255 ? 255 : len;
  uint8_t addbyte = ADS1293_READ_BIT | addr;

  txcache[0] = addbyte;
  memset(txcache + 1, 0, len);

  ads->spi_tx_rx(txcache, rxcache, len + 1);

  memcpy(data, rxcache + 1, len);
}
void ads1293_spi_stream_readreg(ads1293_t* ads, uint8_t* data, uint8_t len) {
  len = len > 255 ? 255 : len;

  memset(txcache, 0, len);
  memset(rxcache, 0, len);

  uint8_t addbyte = ADS1293_READ_BIT | TI_ADS1293_DATA_LOOP_REG;

  ads->spi_tx_rx(&addbyte, rxcache, len);
  memcpy(data, rxcache, len);
}

void ads1293_read_ecg(ads1293_t* ads, uint32_t ch, uint32_t* data) {
  uint8_t add = 0;
  if (ch == 1) {
    add = TI_ADS1293_DATA_CH1_ECG_H_REG;
  } else if (ch == 2) {
    add = TI_ADS1293_DATA_CH2_ECG_H_REG;
  } else if (ch == 3) {
    add = TI_ADS1293_DATA_CH3_ECG_H_REG;
  } else {
    return;
  }

  uint8_t readbak[3] = {0};
  ads1293_spi_autoinc_readreg(ads, add, readbak, 3);

  *data = 0;
  *data = ((uint32_t)readbak[0] << 16) + ((uint32_t)readbak[1] << 8) + ((uint32_t)readbak[2] << 0);
}

void ads1293_read_ecgs(ads1293_t* ads, uint32_t* data /*3*/) {
  uint8_t add        = 0;
  add                = TI_ADS1293_DATA_CH1_ECG_H_REG;
  uint8_t readbak[9] = {0};
  ads1293_spi_autoinc_readreg(ads, add, readbak, 9);

  data[0] = ((uint32_t)readbak[0] << 16) + ((uint32_t)readbak[1] << 8) + ((uint32_t)readbak[2] << 0);
  data[1] = ((uint32_t)readbak[3] << 16) + ((uint32_t)readbak[4] << 8) + ((uint32_t)readbak[5] << 0);
  data[2] = ((uint32_t)readbak[6] << 16) + ((uint32_t)readbak[7] << 8) + ((uint32_t)readbak[8] << 0);
}

void ads1293_start_conversion(ads1293_t* ads) {
  uint8_t data = 0;
  data         = 0x01;
  ads1293_spi_writereg(ads, TI_ADS1293_CONFIG_REG, data);
}
void ads1293_stop_conversion(ads1293_t* ads) {
  uint8_t data = 0;
  data         = 0x04;
  ads1293_spi_writereg(ads, TI_ADS1293_CONFIG_REG, data);
}
void ads1293_start_power_off(ads1293_t* ads) {
  uint8_t data = 0;
  data |= 0x01 << 2;
  ads1293_spi_writereg(ads, TI_ADS1293_CONFIG_REG, data);
}

uint8_t ads1293_read_error_lod(ads1293_t* ads) { return ads1293_spi_readreg(ads, TI_ADS1293_ERROR_LOD_REG); }