ESPHome/configs
ESPHome/configs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
d0f97b46a6
configs/components/ads131m08/ads131m08.cpp

2044 lines
66 KiB
C++
Raw Blame History

#include "ads131m08.h"
//#include <chrono>
//#include <thread>
//#include "esphome/components/spi/spi.h"
#include "esphome/core/log.h"
#include <string>
#include <charconv>
#include <format>
#include "esp_system.h"
#include "spi_flash_mmap.h"
//using namespace esphome::spi;
namespace esphome {
namespace ads131m08 {
static const char *const TAG = "ads131m08";
ADS131M08Hub::ADS131M08Hub()
: base_frame(40, 0)
{
}
void ADS131M08Hub::setup()
{
for(int i = 0; i < ADC_CHANNELS; i++) {
//last_publish_time_[i] = 0;
num_samples_[i] = 0;
sample_sum_[i] = 0;
sample_squared_sum_[i] = 0;
}
// 1. Create a binary semaphore
this->data_ready_semhandle = xSemaphoreCreateBinary();
sync_reset_pin_->setup();
sync_reset_pin_->pin_mode(esphome::gpio::FLAG_OUTPUT); // Set SYNC/RESET pin as output
sync_reset_pin_->digital_write(true);
// setup DRDY pin interrupt
this->drdy_pin_->setup();
this->drdy_pin_->pin_mode(esphome::gpio::FLAG_INPUT | esphome::gpio::FLAG_PULLUP); // external pull-up
this->spi_setup();
// Check if setup failed
if (this->is_failed()) {
ESP_LOGE(TAG, "SPI setup failed!");
this->mark_failed(LOG_STR("SPI setup failed." ));
return;
}
// Send RESET command
bool reset_ok = adc_reset_retry();
//ESP_LOGW(TAG, "adc word length: %d", adc_word_length_);
if(!reset_ok) {
ESP_LOGE(TAG, "ADC reset failed!");
this->mark_failed(LOG_STR("Reset failed." ));
this->adc_init_ = 0;
return;
}
if(!this->adc_initialize(32)) {
ESP_LOGE(TAG, "ADC reset failed!");
this->mark_failed(LOG_STR("Initialisation failed." ));
this->adc_init_ = 0;
return;
}
set_reg_osr();
if(!adc_lock(true)) {
ESP_LOGE(TAG, "ADC lock failed!");
this->mark_failed(LOG_STR("ADC lock failed." ));
this->adc_init_ = 0;
return;
}
if(!adc_lock(false)) {
ESP_LOGE(TAG, "ADC unlock failed!");
this->mark_failed(LOG_STR("ADC unlock failed." ));
this->adc_init_ = 0;
return;
}
this->drdy_pin_->attach_interrupt(&ADS131M08Hub::isr_handler, this, gpio::INTERRUPT_FALLING_EDGE);
//cs_ctr_=1000;
//SPIDevice::enable(); // leave CS low
}
void ADS131M08Hub::dump_config()
{
ESP_LOGCONFIG(TAG, "ADS131M08:");
LOG_PIN(" CS Pin: ", this->cs_);
LOG_PIN(" DRDY Pin: ", this->drdy_pin_);
if(this->sync_reset_pin_ != nullptr) {
LOG_PIN(" SYNC/RESET Pin: ", this->sync_reset_pin_);
}
if (this->data_rate_ < 1000000) {
ESP_LOGCONFIG(TAG, " Data rate: %" PRId32 "kHz", this->data_rate_ / 1000);
} else {
ESP_LOGCONFIG(TAG, " Data rate: %" PRId32 "MHz", this->data_rate_ / 1000000);
}
if (this->clock_frequency_ < 1000000) {
ESP_LOGCONFIG(TAG, " Clock frequency: %.3fkHz", this->clock_frequency_ / 1000);
} else {
ESP_LOGCONFIG(TAG, " Clock frequency: %.3fMHz", this->clock_frequency_ / 1000000);
}
uint16_t osr = 1 << (7 + this->osr_);
if (osr == 16384) {
osr = 16256;
}
ESP_LOGCONFIG(TAG, " Oversampling ratio: %" PRId32, osr);
ESP_LOGCONFIG(TAG, " Reference Voltage: %.2fV", this->reference_voltage_);
ESP_LOGCONFIG(TAG, " SPI Mode: %d", this->mode_);
ESP_LOGCONFIG(TAG, " Bit Order: %s", this->bit_order_ == 1 ? "msb_first" : this->bit_order_ == 0 ? "lsb_first" : "unknown");
}
void ADS131M08Hub::set_channel_gain(uint8_t channel, ADS131M08_PGA_GAIN gain)
{
if(channel < ADC_CHANNELS) {
set_channel_pga(channel, gain);
}
}
uint8_t ADS131M08Hub::update_adc_word_length()
{
int word_nbytes = this->adc_word_length_ >> 3;
spiframe frame(2 * word_nbytes, 0); // prepare with CMD_NULL; always cater for crc
write_array(frame); // write CMD_NULL to ADC to retrieve status
read_array(frame);
uint16_t status = frame[0] << 8 | frame[1];
//print_command_response_to_string(CMD_NULL, frame).c_str();
switch(status & MASK_STATUS_WLENGTH) {
case WLENGTH_16_BITS:
this->adc_word_length_ = 16;
this->conversion_factor_ = this->reference_voltage_/32768.0; // TODO: must double check this with a test
break;
case WLENGTH_24_BITS:
this->adc_word_length_ = 24;
this->conversion_factor_ = this->reference_voltage_/8388608.0;
break;
default:
this->adc_word_length_ = 32;
this->conversion_factor_ = this->reference_voltage_/8388608.0;
break;
}
return this->adc_word_length_;
}
bool ADS131M08Hub::adc_initialize(uint8_t word_length)
{
this->adc_init_++;
update_adc_word_length();
if (!adc_register_write(REG_CLOCK, reg_clock_allch_off)) {
ESP_LOGE(TAG, "CLOCK register write / read to turn off all channels failed");
return false;
}
ESP_LOGV(TAG, "Turned off all channels so short frames can be written during config");
if(!adc_register_write(REG_MODE, MODE_MASK_RESET_HAPPENED & reg_mode_cfg24)) {
ESP_LOGE(TAG, "MODE register write / read to set word size to 24bits failed");
return false;
}
//update_adc_word_length();
ESP_LOGV(TAG, "Written MODE register; Cleared the RESET flag, made DRDY active low pulse");
if(!adc_register_write(REG_THRSHLD_LSB, 0x09)) {
ESP_LOGE(TAG, "THRSHLD_LSB register write / read to set DBLOCK filter failed");
return false;
}
ESP_LOGV(TAG, "Written THRSHLD_LSB register; Set DCBLOCK filter to have a corner frequency of 622 mHz");
if(!adc_set_word_length(word_length))
return false;
// we leave should channels off, as the individual sensors should turn it on
if(!adc_register_write(REG_CLOCK, reg_clock_allch_off)) {
ESP_LOGE(TAG, "CLOCK register write / read to turn-off all channels failed");
return false;
}
//ESP_LOGV(TAG, "Turned on all ADC channels; Re-wrote defaults for other bits in CLOCK register");
if(!drdy_pin_->digital_read()) {
ESP_LOGE(TAG, "DRDY pin is low after initialization!");
return false;
}
this->adc_init_--;
return true;
}
bool ADS131M08Hub::adc_set_word_length(uint8_t word_length)
{
uint16_t setting;
switch(word_length) {
case 32:
setting = reg_mode_cfg32;
break;
case 16:
setting = reg_mode_cfg16;
break;
default:
setting = reg_mode_cfg24;
break;
}
if(!adc_register_write_masked(REG_MODE, setting, reg_mode_cfg_mask, __LINE__)) {
ESP_LOGE(TAG, "MODE register write / read to set word size to %ubits failed", word_length);
return false;
}
ESP_LOGV(TAG, "Written MODE register; Made ADC word size %u bits. Re-wrote other set bits in MODE register", word_length);
//update_adc_word_length();
return true;
}
// Implementing nested CS enable/disable handling in ADS131M08Hub to allow multiple transfers in a row without toggling CS between them, which is required for proper communication with the ADC according to the datasheet recommendations.
void ADS131M08Hub::enable(const char *txt)
{
cs_ctr_++; // Increment counter on each enable call
//esph_log_i(TAG, "cs_ctr_e: %s %d", txt, cs_ctr_.load());
if(cs_ctr_ == 1) { // Only set CS low on the first enable call
SPIDevice::enable(); // Call the base class enable to set CS low
if(txt != nullptr)
esph_log_i(TAG, "enable: %s", txt);
}
}
void ADS131M08Hub::disable(const char *txt)
{
//esph_log_i(TAG, "cs_ctr_d: %s %d", txt, cs_ctr.load());
cs_ctr_--; // Decrement counter on each disable call
if(cs_ctr_ == 0) { // Only set CS high when counter returns to 0
SPIDevice::disable(); // Call the base class disable to set CS high
if(txt != nullptr)
esph_log_i(TAG, "disable: %s", txt);
}
else if (cs_ctr_ < 0) { // Sanity check to prevent counter from going negative
cs_ctr_ = 0;
}
}
// ISR function to handle interrupt from drdy pin
// MUST be fast and non-blocking
void ADS131M08Hub::isr_handler(ADS131M08Hub *arg)
{
{
InterruptLock lock;
if(arg != nullptr) {
arg->isr_ctr_++;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
xSemaphoreGiveFromISR(arg->data_ready_semhandle, &xHigherPriorityTaskWoken);
if (xHigherPriorityTaskWoken == pdTRUE) {
portYIELD_FROM_ISR(); // Switch to the waiting task immediately
}
}
}
}
void ADS131M08Hub::loop()
{
// Check the semaphore (0 timeout means non-blocking)
if (xSemaphoreTake(data_ready_semhandle, 0) == pdTRUE) {
if(this->adc_init_ == 0) {
uint32_t num_samples = 0;
uint32_t crc_errors = 0;
{
CHIP_SELECTx
// Perform the read here safely outside of ISR
uint64_t start = micros();
//this->txf_init(); // implementing datasheet recommended TXF init in ISR
this->adc_sync();
if(rms_calc_req_) {
std::pair<uint32_t, uint32_t> result = read_multi();
num_samples = result.first;
crc_errors = result.second;
uint64_t end = micros();
if(this->sensors_ac[SAMPLE_TIME_SENSOR] != nullptr)
this->sensors_ac[SAMPLE_TIME_SENSOR]->publish_state(static_cast<float>(end - start)/1000.0);
if(this->sensors_ac[MAX_SAMPLES_SENSOR] != nullptr)
this->sensors_ac[MAX_SAMPLES_SENSOR]->publish_state(static_cast<float>(num_samples));
if(this->sensors_ac[CRC_ERRORS_SENSOR] != nullptr)
this->sensors_ac[CRC_ERRORS_SENSOR]->publish_state(static_cast<float>(crc_errors));
uint16_t ctr = isr_ctr_;
ESP_LOGI(TAG, "WL: %u isr_ctr_: %u", this->adc_word_length_, ctr); }
else {
read_single();
}
isr_ctr_ = 0;
}
if (crc_errors > 30) {
ESP_LOGW(TAG, "High CRC error rate.");
adc_set_word_length(this->adc_word_length_); // for some reason the adc occasionally reverts to 24bits; this will reset the word length to what it should be
//update_adc_word_length();
spiframe recoverframe(40, 0);
read_array(recoverframe);
ESP_LOGI(TAG, "WL: %u Frame: %s", this->adc_word_length_, frame_to_string(recoverframe).c_str());
}
//ESP_LOGW(TAG, "%llu ms (%llu us), max samples: %u", (end - start)/1000, (end - start), num_samples);
}
}
}
/// @brief Set 16 bit frameword
/// @param frame
/// @param w_index
/// @param data uint16_t denotes command or CRC
/// @return
bool ADS131M08Hub::set_frame_word(spiframe& frame, int w_index, uint16_t data)
{
size_t word_nbytes = adc_word_length_ >> 3;
size_t frame_words = frame.size() / word_nbytes;
int b_index = w_index * word_nbytes;
//ESP_LOGD(TAG, "b_index: %d, word_nbytes: %d, frame words: %d, w_index: %d, frame size: %d", b_index, word_nbytes, frame_words, w_index, frame.size());
if(w_index >= frame_words) {
if(w_index > MAX_FRAME_SIZE) {
ESP_LOGE(TAG, "Word index of %d out of bounds", w_index);
//esp_crosscore_int_send_print_backtrace(xPortGetCoreID());
return false; // invalid - something has gone wrong
}
//int oldsize = frame.size();
frame.resize(b_index + word_nbytes);
//ESP_LOGD(TAG, "Resized frame from %d, to %d.", oldsize, frame.size());
}
switch(adc_word_length_) {
// deliberate no breaks after first two cases
case 32:
frame[b_index + 3] = 0;
case 24:
frame[b_index + 2] = 0;
case 16:
frame[b_index + 1] = data & 0xFF;
frame[b_index] = (data >> 8) & 0xFF;
break;
default:
ESP_LOGW(TAG, "Invalid adc word length of %d", adc_word_length_);
break;
}
return true;
}
bool ADS131M08Hub::set_frame_word(spiframe& frame, int w_index, uint32_t data)
{
size_t word_nbytes = adc_word_length_ >> 3;
size_t frame_words = frame.size() / word_nbytes;
int b_index = w_index * word_nbytes;
if(w_index >= frame_words) {
if(w_index > MAX_FRAME_SIZE) {
ESP_LOGE(TAG, "Word index of %d out of bounds", w_index);
//esp_crosscore_int_send_print_backtrace(xPortGetCoreID());
return false; // invalid - something has gone wrong
}
frame.resize(b_index + word_nbytes);
}
switch(adc_word_length_) {
// deliberate no breaks after first two cases
case 32:
frame[b_index++] = (data >> 24) & 0xFF;
case 24:
frame[b_index++] = (data >> 16) & 0xFF;
case 16:
frame[b_index++] = (data >> 8) & 0xFF;
frame[b_index] = data & 0xFF;
break;
default:
ESP_LOGW(TAG, "Invalid adc word length of %d", adc_word_length_);
break;
}
return true;
}
// index(i) = zero-reference, returns i'th word, LSB aligned
uint32_t ADS131M08Hub::get_unsigned_frame_word(const spiframe& frame, int w_index, bool force_16bits)
{
uint32_t result = 0;
size_t word_nbytes = adc_word_length_ >> 3;
int b_index = w_index * word_nbytes;
if(b_index > (frame.size() - word_nbytes)) {
//ESP_LOGE(TAG, "Word index of %d out of bounds. b_index: %d, frame_size: %d, Caller: %s Line: %d", w_index, b_index, frame.size(), caller.c_str(), line);
//esp_crosscore_int_send_print_backtrace(xPortGetCoreID());
return result; // illegal
}
switch(force_16bits ? 16 : adc_word_length_) {
// deliberate no breaks after first two cases
case 32:
result += frame[b_index++] << 24;
case 24:
result += frame[b_index++] << 16;
case 16:
result += frame[b_index++] << 8;
result += frame[b_index];
break;
default:
ESP_LOGW(TAG, "Invalid adc word length of %d", adc_word_length_);
break;
}
return result;
}
int32_t ADS131M08Hub::get_sign_ext_frame_word(const spiframe& frame, int w_index)
{
int32_t result = 0;
size_t word_nbytes = adc_word_length_ >> 3;
int b_index = w_index * word_nbytes;
if(b_index > (frame.size() - word_nbytes)) {
ESP_LOGW(TAG, "Word index of %d out of bounds", w_index);
return result; // invalid
}
uint32_t raw = 0;
switch(adc_word_length_) {
case 32:
raw = (frame[b_index] << 24) | (frame[b_index + 1] << 16) | (frame[b_index + 2]) << 8 | frame[b_index + 3];
result = static_cast<int32_t>(raw);
break;
case 24:
raw = (frame[b_index] << 16) | (frame[b_index + 1] << 8) | frame[b_index + 2];
if (raw & 0x800000)
result = static_cast<int32_t>(raw | 0xFF000000); // Sign extend
else
result = static_cast<int32_t>(raw);
break;
case 16:
raw = ((frame[b_index] << 8) | frame[b_index + 1]);
result = static_cast<int16_t>(raw);
break;
default:
ESP_LOGW(TAG, "Invalid adc word length of %d", adc_word_length_);
break;
}
return result;
}
//{
// // Read STATUS register to check if data is ready for the specified channel
// // STATUS register is the first word in the SPI frame, so we can read it directly
// uint16_t status;
// this->enable();
// this->transfer_byte(0x00); // Send dummy byte to read STATUS register
// status = this->transfer_byte(0x00); // Read upper byte of STATUS
// status <<= 8;
// status |= this->transfer_byte(0x00); // Read lower byte of STATUS
// this->disable();
// // Check the corresponding bit in the STATUS register for the specified channel
// // Assuming each channel corresponds to a specific bit in the STATUS register, e.g. bit 0 for channel 0, bit 1 for channel 1, etc.
// return (status & (1 << channel)) != 0; // Return true if data is ready for the specified channel
//}
void ADS131M08Hub::adc_hard_reset()
{
float one_cycle = 1000000 / this->clock_frequency_; // one cycle duration in micro seconds
uint32_t reset_pulse_duration = static_cast<uint32_t>(1.05 * 2048 * one_cycle); // 2048 clock cycles converted to microseconds, multiplied by 1.05 to ensure we meet the minimum pulse duration requirement
if(reset_pulse_duration < 1) {
reset_pulse_duration = 1; // set it to 1 microsecond
}
sync_reset_pin_->digital_write(false); // Pull SYNC/RESET pin low to reset the ADC
delay_microseconds_safe(reset_pulse_duration); // Hold reset for the calculated duration
sync_reset_pin_->digital_write(true); // Set SYNC/RESET pin high to allow normal operation
}
void ADS131M08Hub::adc_sync()
{
float one_cycle = 1000000 / this->clock_frequency_; // one cycle duration in micro seconds
uint32_t sync_pulse_duration = static_cast<uint32_t>(std::round(50 * one_cycle)); // minimum is 1/clock freq, max = 2047/clock freq
if(sync_pulse_duration < 1) {
sync_pulse_duration = 1; // set it to 1 microsecond
}
sync_reset_pin_->digital_write(false); // Pull SYNC/RESET pin low to sync the ADC
delay_microseconds_safe(sync_pulse_duration); // Hold sync for the calculated duration
sync_reset_pin_->digital_write(true); // Set SYNC/RESET pin high to allow normal operation
}
// ********************** from datasheet ************************
void ADS131M08Hub::txf_init()
{
CHIP_SELECT
if (firstRead) {
// Clear the ADC's 2-deep FIFO on the first read
for(int i = 0; i < numFrameWords * adc_word_length_; i++) {
this->write_byte(0);
}
for(int i = 0; i < numFrameWords; i++) {
this->read_byte(); // should perhaps read dwords instead of bytes, but we just want to clear the FIFO so it doesn't matter much?
}
firstRead = false; // Clear the flag
// we will do this later, after sorting out basic communication
// DMA.enable(); // Let the DMA start sending ADC data to memory
}
// Send the dummy data to the ADC to get the ADC data
for(int i = 0; i < numFrameWords * adc_word_length_; i++) {
this->write_byte(0);
}
}
bool ADS131M08Hub::adc_reset_retry()
{
adc_word_length_ = 24;
bool reset_ok = adc_soft_reset();
uint8_t retry_wordlengths[] = { 32, 32, 24, 24, 16, 16 } ;
int i = 0;
while( i < sizeof(retry_wordlengths) && !reset_ok) {
adc_word_length_ = retry_wordlengths[i];
//ESP_LOGW(TAG, "ADC word length: %d", adc_word_length_);
reset_ok = adc_soft_reset();
i++;
}
return reset_ok;
}
//int ADS131M08Hub::build_frame()
bool ADS131M08Hub::adc_soft_reset()
{
int index = 0;
uint16_t reset_response;
uint16_t cmd = 0;
// we assume 24 bit wordlength if adc_word_length_is illegal
//if(adc_word_length_ != 32 && adc_word_length_ != 24 && adc_word_length_ != 16) {
// adc_word_length_ = 24;
//}
update_adc_word_length();
size_t word_nbytes = adc_word_length_ >> 3;
int framelength = numFrameWords * word_nbytes;
spiframe frame(framelength, 0);
size_t frame_len;
// curly braces confine chip select scope
{
CHIP_SELECTx
cmd = CMD_RESET;
set_frame_word(frame, 0, cmd);
index += 2;
for(; index < framelength; index++) {
frame[index] = 0;
}
frame_len = add_crc(frame, crc_pos::crc_after_firstword);
write_array(frame);
ESP_LOGVV(TAG, "Sent Frame: %s", frame_to_string(frame).c_str());
}
delay_microseconds_safe(T_REGACQ);
{
CHIP_SELECTx
read_array(frame);
reset_response = get_unsigned_frame_word(frame, 0, true);
ESP_LOGVV(TAG, "Read Frame: %s", frame_to_string(frame).c_str());
}
ESP_LOGVV(TAG, "reset_response: 0x%04X", reset_response);
if (reset_response == RSP_RESET_OK) {
return true;
}
return false;
}
// overwrites last (or second) frameword with CRC, therefore frame should be large enough for payload and crc
size_t ADS131M08Hub::add_crc(spiframe& frame, crc_pos crcpos)
{
size_t effective_frame_length;
size_t frame_length = frame.size();
if (frame_length == 0 || adc_word_length_ == 0)
return 0;
size_t word_nbytes = adc_word_length_ >> 3;
if (crcpos == crc_pos::crc_after_firstword) {
effective_frame_length = word_nbytes * 2;
}
else {
effective_frame_length = frame_length;
}
if (effective_frame_length > frame_length) {
if (frame.capacity() >= effective_frame_length)
{
frame.resize(effective_frame_length);
if (frame.size() < effective_frame_length) {
return 0;
}
frame_length = effective_frame_length;
}
else {
return 0;
}
}
size_t frame_words = effective_frame_length / word_nbytes; // integer division, we discard remainder if any
size_t payload_len = word_nbytes * (frame_words - 1);
if (payload_len < word_nbytes)
return false;
uint16_t crc = get_crc(frame);
set_frame_word(frame, frame_words - 1, crc);
return frame_words * word_nbytes;
}
// CRC should be 16bits, MSB aligned in last word of frame
bool ADS131M08Hub::check_crc(const spiframe& frame)
{
if (adc_word_length_ == 0)
return false;
size_t word_nbytes = adc_word_length_ >> 3;
int frame_length = frame.size();
size_t frame_words = frame_length / word_nbytes; // integer division, we discard remainder if any
size_t payload_len = word_nbytes * (frame_words - 1);
if (payload_len < word_nbytes)
return false;
uint16_t frame_crc = (frame[payload_len] << 8) + frame[payload_len + 1]; // Frames are MSB aligned, so is CRC
auto crc = get_crc(frame);
bool crc_ok = crc == frame_crc;
return crc_ok;
}
uint16_t ADS131M08Hub::read_frame_crc(const spiframe& frame)
{
if (adc_word_length_ == 0)
return 0;
size_t word_nbytes = adc_word_length_ >> 3;
int frame_length = frame.size();
size_t frame_words = frame_length / word_nbytes; // integer division, we discard remainder if any
size_t payload_len = word_nbytes * (frame_words - 1);
if (payload_len < word_nbytes)
return 0;
return (frame[payload_len] << 8) + frame[payload_len + 1]; // Frames are MSB aligned, so is CRC
}
/*
CRC Parameters for ADS131M08
Polynomial: 0x1021 (x^16 + x^12 + x^5 + 1).
Initial Value (Seed): 0xFFFF.
Input Data: The calculation is performed over all bits in the SPI frame preceding the CRC word.
Output Format: The resulting 16-bit CRC is placed in the most significant 16 bits of the final 24-bit (or 32-bit) SPI word; the remaining bits are typically padded with zeros.
*/
uint16_t ADS131M08Hub::get_crc(const spiframe& frame)
{
size_t word_nbytes = adc_word_length_ >> 3;
size_t frame_words = frame.size() / word_nbytes; // integer division, we discard remainder if any
size_t payload_len = word_nbytes * (frame_words - 1);
uint16_t crc_result = crc(0xFFFF, frame[0]);
for (int j = 1; j < payload_len; j++) {
crc_result = crc(crc_result, frame[j]);
}
return crc_result;
}
uint16_t ADS131M08Hub::crc(uint16_t crc_register, uint8_t data)
{
uint16_t xor_result, input_bit, crc_result;
crc_result = crc_register;
for (int i = 7; i >= 0; i--) {
input_bit = (data >> i) & 0x01;
xor_result = input_bit ^ (crc_result & 0x8000) >> 15;
crc_result = crc_result << 1;
if(xor_result)
crc_result = crc_result ^ 0x1021;
}
return crc_result;
}
void ADS131M08Hub::write_byte(uint8_t byte)
{
CHIP_SELECT
this->transfer_byte(byte);
}
uint8_t ADS131M08Hub::read_byte()
{
CHIP_SELECT
uint8_t result = this->transfer_byte(0x00); // Send dummy byte to read data
return result;
}
void ADS131M08Hub::read_array(spiframe& frame)
{
CHIP_SELECT
for (size_t i = 0; i < frame.size(); i++) {
frame[i] = this->transfer_byte(0x00); // Send dummy byte to read data
}
}
void ADS131M08Hub::write_array(const spiframe& frame)
{
CHIP_SELECT
for (size_t i = 0; i < frame.size(); i++) {
this->transfer_byte(frame[i]);
}
}
void ADS131M08Hub::transfer_array(const spiframe& tx_frame, spiframe& rx_frame)
{
CHIP_SELECT
auto frame_length = tx_frame.size();
if(rx_frame.size() < frame_length)
rx_frame.resize(frame_length);
for (size_t i = 0; i < frame_length; i++) {
rx_frame[i] = this->transfer_byte(tx_frame[i]);
}
}
// ********************** end of from datasheet ************************
void ADS131M08Hub::set_measure_rms(uint8_t channel, bool enable)
{
if(channel < ADC_CHANNELS) {
ESP_LOGW(TAG, "set_measure_rms[%d] = %s", channel, enable ? "enabled" : "disabled");
this->rms_enabled_[channel] = enable;
this->rms_calc_req_ = true;
}
}
void ADS131M08Hub::read_single()
{
int word_nbytes = adc_word_length_ >> 3;
int frame_length = numFrameWords * word_nbytes;
spiframe frame(frame_length, 0);
this->read_array(frame);
bool crc_ok = check_crc(frame);
uint16_t drdy_status = get_unsigned_frame_word(frame, 0, true) & MASK_STATUS_DRDY;
//data_ready = crc_ok && (drdy_status != 0);
if(crc_ok) {
// sample channels
for (int i = 0; i < ADC_CHANNELS; i++) {
bool channel_ready = drdy_status & 1;
drdy_status = drdy_status >> 1;
bool ac_sensor_exist = this->sensors_ac[i] != nullptr;
bool dc_sensor_exist = this->sensors_dc[i] != nullptr;
if (channel_ready && (ac_sensor_exist || dc_sensor_exist)) {
int32_t raw = get_sign_ext_frame_word(frame, i + 1);
this->sampled_values_[i] = this->conversion_factor_ * raw;
float value = this->conversion_factor_ * raw;
if(ac_sensor_exist)
this->sensors_ac[i]->publish_state(value);
if(dc_sensor_exist)
this->sensors_dc[i]->publish_state(value);
}
}
}
}
std::pair<uint32_t, uint32_t> ADS131M08Hub::read_multi()
{
int32_t raw;
float value;
std::pair<uint32_t, uint32_t> result;
result.first = 0;
result.second = 0;
bool crc_ok, data_ready, ac_sensor_exist, dc_sensor_exist;
uint16_t drdy_status, status;
int i, max_iters = 250; // going above 255 will result in overflows
uint32_t elapsed_time = 0;
uint32_t loop_start_time = micros();
int word_nbytes = adc_word_length_ >> 3;
int frame_length = numFrameWords * word_nbytes;
spiframe frame(frame_length, 0);
// integrate for rms values over #iterations or sample_time depending on what comes first
for(int i = 0; i < ADC_CHANNELS; i++) {
//last_publish_time_[i] = 0;
num_samples_[i] = 0;
sample_sum_[i] = 0;
sample_squared_sum_[i] = 0;
}
while (elapsed_time < this->sample_time_ && max_iters-- > 0) {
this->read_array(frame);
//ESP_LOGD(TAG, "max_iters: %d, frame: %s", max_iters, frame_to_string(frame).c_str());
crc_ok = check_crc(frame);
if (crc_ok) {
status = get_unsigned_frame_word(frame, 0, true);
// skip frame immediately afte resync
if ((status & MASK_STATUS_RESYNC) == 0) {
drdy_status = status & MASK_STATUS_DRDY;
// sample channels
for (i = 0; i < ADC_CHANNELS && drdy_status != 0; i++) {
data_ready = drdy_status & 1;
drdy_status = drdy_status >> 1;
ac_sensor_exist = this->sensors_ac[i] != nullptr;
dc_sensor_exist = this->sensors_dc[i] != nullptr;
if (data_ready && (ac_sensor_exist || dc_sensor_exist)) {
raw = get_sign_ext_frame_word(frame, i + 1);
value = this->conversion_factor_ * raw;
this->sampled_values_[i] = value;
if (this->rms_enabled_[i]) {
(this->num_samples_[i])++;
(this->sample_sum_[i]) += static_cast<int64_t>(raw);
(this->sample_squared_sum_[i]) += value * value;
}
else {
if(ac_sensor_exist)
this->sensors_ac[i]->publish_state(value);
if(dc_sensor_exist)
this->sensors_dc[i]->publish_state(value);
}
}
}
}
}
else {
result.second++;
//ESP_LOGW(TAG, "max_iters: %d, frame: %s CRC error", max_iters, frame_to_string(frame).c_str());
}
elapsed_time = micros() - loop_start_time;
}
// publish integrated values
for (i = 0; i < ADC_CHANNELS; i++) {
if (this->rms_enabled_[i]) {
ac_sensor_exist = this->sensors_ac[i] != nullptr;
dc_sensor_exist = this->sensors_dc[i] != nullptr;
auto num_samples = this->num_samples_[i];
if(num_samples > result.first) {
result.first = num_samples;
}
if (num_samples == 0) {
// should never happen, but let's play safe and avoid dividing by zero
if(ac_sensor_exist)
this->sensors_ac[i]->publish_state(NAN);
if(dc_sensor_exist)
this->sensors_dc[i]->publish_state(NAN);
}
else {
int64_t sample_sum = sample_sum_[i];
float rms_dc = this->conversion_factor_ * static_cast<float>(sample_sum) / num_samples;
float rms_ac_squared = sample_squared_sum_[i] / num_samples - rms_dc * rms_dc;
float rms_ac = 0;
if (rms_ac_squared > 0) {
rms_ac = std::sqrtf(rms_ac_squared);
}
this->sps_ = (1e6 * (float)num_samples) / elapsed_time;
if(ac_sensor_exist)
this->sensors_ac[i]->publish_state(rms_ac);
if(dc_sensor_exist)
this->sensors_dc[i]->publish_state(rms_dc);
}
this->num_samples_[i] = 0;
this->sample_sum_[i] = 0.0f;
this->sample_squared_sum_[i] = 0.0f;
}
}
return result;
}
bool ADS131M08Hub::adc_lock(bool enable)
{
int word_nbytes = adc_word_length_ >> 3;
spiframe frame(word_nbytes * 2, 0);
uint16_t command = CMD_UNLOCK;
if (enable) {
command = CMD_LOCK;
}
set_frame_word(frame, 0, command);
add_crc(frame, crc_after_frame);
write_array(frame);
delay_microseconds_safe(T_REGACQ);
read_array(frame);
auto ack = get_unsigned_frame_word(frame, 0, true);
return ack == command;
}
/// @brief
/// @param address - register address
/// @param value - mask is used to remove unwanted bits before adding to value read from register
/// @param mask - register contents read from adc is masked with inverse of this
/// @param line - temporary / for debugging
/// @return success flag
bool ADS131M08Hub::adc_register_write_masked(uint8_t address, uint16_t value, uint16_t mask, int line)
{
uint16_str reg_contents = adc_register_read(address, 1);
if(reg_contents.empty()) {
return false;
}
ESP_LOGW(TAG, "1: reg contents: 0x%04X, address: 0x%02X, value: 0x%04X, mask: 0x%04X, caller: %d", reg_contents[0],address, value,mask, line );
reg_contents[0] = (reg_contents[0] & ~mask) | (value & mask);
ESP_LOGW(TAG, "After applying mask - reg contents: 0x%04X, caller: %d", reg_contents[0], line );
return adc_register_write(address, reg_contents);
}
/// @brief
/// @param start_address - first register address
/// @param values - mask is used to remove unwanted bits before adding to value read from register
/// @param masks - register contents read from adc is masked with inverse of this
/// @param line - temporary / for debugging
/// @return success flag
bool ADS131M08Hub::adc_register_write_masked(uint8_t start_address, const uint16_str& values, const uint16_str& masks, int line)
{
uint8_t nregs = values.size();
uint8_t nmasks = masks.size();
if(nregs != nmasks) {
ESP_LOGW(TAG, "Number register values to write (%d) are different than the corresponding number of masks (%d). Register write aborted.", nregs, nmasks);
return false;
}
uint16_str reg_contents = adc_register_read(start_address, nregs);
if(reg_contents.empty()) {
ESP_LOGW(TAG, "No contents read from adc. Expected %d values. Register write aborted.", nregs);
return false;
}
for (int i = 0; i < nregs; i++) {
//ESP_LOGW(TAG, "Before change %d: reg contents: 0x%04X, address: 0x%02X, value: 0x%04X, mask: 0x%04X, caller: %d", i, reg_contents[i], start_address + i, values[i], masks[i], line);
reg_contents[i] = (reg_contents[i] & ~masks[i]) | (values[i] & masks[i]);
//ESP_LOGW(TAG, "After applying mask - reg contents: 0x%04X, caller: %d", reg_contents[i], line);
}
return adc_register_write(start_address, reg_contents);
}
bool ADS131M08Hub::adc_register_write(uint16_t address, uint16_t data)
{
uint16_str arg;
arg += data;
return adc_register_write(address, arg);
}
bool ADS131M08Hub::adc_register_write(uint16_t start_address, const uint16_str& data)
{
int nregs = data.size();
if(nregs == 0) {
return false; // invalid
}
int word_nbytes = adc_word_length_ >> 3;
int wreg_framelength = word_nbytes * (2 + nregs); // ensure room for crc
int rreg_resp_framelength = word_nbytes * (2 + (nregs == 1 ? -1 :nregs)); // add room for CRC if nregs > 1
spiframe frame(wreg_framelength, 0);
spiframe rxframe(wreg_framelength, 0);
uint16_t addr_regcnt_mask = (start_address << 7) | ((nregs - 1 ) & MASK_CMD_RW_REG_COUNT);
uint16_t wreg_addr_opcode = CMD_WREG | addr_regcnt_mask; // Combine WREG command, start_address and register count
uint16_t rreg_addr_opcode = CMD_RREG | addr_regcnt_mask; // Combine RREG command, start_address and register count
bool has_mode_reg = (start_address == REG_MODE) || ((start_address < REG_MODE) && ((start_address + nregs) > REG_MODE));
{
CHIP_SELECT
set_frame_word(frame, 0, wreg_addr_opcode);
for(int i = 0; i < nregs; i++) {
set_frame_word(frame, i + 1, data[i]);
}
add_crc(frame, crc_after_frame);
ESP_LOGVV(TAG, "%s\n", rwreg_command_frame_to_string(frame).c_str());
transfer_array(frame, rxframe); // WREG
}
ESP_LOGVV(TAG, "Sent Frame: %s", frame_to_string(frame).c_str());
if (has_mode_reg) {
update_adc_word_length();
}
delay_microseconds_safe(T_REGACQ);
auto rxdata = adc_register_read(start_address, nregs);
bool verified = !rxdata.empty();
for(int i = 0; i < rxdata.size() && verified; i++) {
verified = rxdata[i] == data[i];
if(!verified) {
ESP_LOGE(TAG, "Write register failed: tx data= 0x%04X, rx data= 0x%04X", data[i] ,rxdata[i]);
}
}
delay_microseconds_safe(T_REGACQ);
return verified;
}
// recommended not to read more than 20 registers at a time
uint16_str ADS131M08Hub::adc_register_read(uint8_t address, uint8_t nregs)
{
uint16_str result;
if(nregs == 0) {
return result; // invalid
}
if(nregs > 31) {
// We are limited to 31 registers, otherwise we will ran into DMA / SPI buffer problems
ESP_LOGE(TAG, "Trying to read %d registers. This exceeds maximum register read count of 31!", nregs);
return result; // invalid
}
int word_nbytes = adc_word_length_ >> 3;
int request_framelength = 2 * word_nbytes; // ensure room for crc
int response_framelength = word_nbytes * (2 + (nregs == 1 ? -1 : nregs)); // add room for CRC if nregs > 1
spiframe frame(response_framelength, 0);
uint16_t rreg_addr_opcode = CMD_RREG | (address << 7) | ((nregs - 1) & MASK_CMD_RW_REG_COUNT); // Combine RREG command, address and register count
{
CHIP_SELECT
frame.resize(request_framelength);
set_frame_word(frame, 0, rreg_addr_opcode);
add_crc(frame, crc_after_frame);
write_array(frame); // send RREG
}
ESP_LOGVV(TAG, "%s\n", rwreg_command_frame_to_string(frame).c_str());
ESP_LOGVV(TAG, "Sent Frame: %s", frame_to_string(frame).c_str());
delay_microseconds_safe(T_REGACQ);
{
CHIP_SELECT
frame.resize(response_framelength);
read_array(frame);
}
ESP_LOGVV(TAG, "Recv Frame: %s", frame_to_string(frame).c_str());
if(nregs > 1) {
//auto crc = get_crc(frame);
//auto frame_crc = read_frame_crc(frame);
//ESP_LOGW(TAG, "CRC calc: 0x%04X, CRC recv: 0x%04X", crc, frame_crc);
bool crc_ok = check_crc(frame);
if(!crc_ok) {
ESP_LOGW(TAG, "CRC failed reading ADC registers!");
result.clear();
return result; // invalid
}
}
result.resize(nregs);
int offset = 0;
uint16_t rreg_ack = rreg_addr_opcode; // not really and ack, but since we don't get an ack when reading 1 register we pretend this is the ack
if(nregs > 1) {
offset = 1;
rreg_ack = get_unsigned_frame_word(frame, 0, true);;
}
//uint16_t rreg_ack = (nregs == 1) ? rreg_addr_opcode : get_unsigned_frame_word(frame, 0, true);
nregs = (rreg_ack & MASK_CMD_RW_REG_COUNT) + 1;
uint16_t start_addr = (rreg_ack & MASK_CMD_RW_REG_ADDRESS) >> 7;
for(int i = 0; i < nregs; i++) {
result[i] = get_unsigned_frame_word(frame, i + offset, true);
}
print_command_response_to_string(rreg_addr_opcode, frame);
delay_microseconds_safe(1);
return result;
}
int8_t ADS131M08Hub::is_data_ready_soft(uint8_t channel)
{
switch (channel) {
case 0:
return (readRegister(REG_STATUS) & MASK_STATUS_DRDY0);
case 1:
return (readRegister(REG_STATUS) & MASK_STATUS_DRDY1);
case 2:
return (readRegister(REG_STATUS) & MASK_STATUS_DRDY2);
case 3:
return (readRegister(REG_STATUS) & MASK_STATUS_DRDY3);
case 4:
return (readRegister(REG_STATUS) & MASK_STATUS_DRDY4);
case 5:
return (readRegister(REG_STATUS) & MASK_STATUS_DRDY5);
case 6:
return (readRegister(REG_STATUS) & MASK_STATUS_DRDY6);
case 7:
return (readRegister(REG_STATUS) & MASK_STATUS_DRDY7);
default:
return -1; // Invalid channel
}
}
bool ADS131M08Hub::is_reset_status()
{
return (readRegister(REG_STATUS) & MASK_STATUS_RESET);
}
bool ADS131M08Hub::is_lock_spi()
{
return (readRegister(REG_STATUS) & MASK_STATUS_LOCK);
}
bool ADS131M08Hub::set_drdy_format(uint8_t drdy_format)
{
if (drdy_format > 1)
{
return false;
}
return adc_register_write_masked(REG_MODE, drdy_format, MASK_MODE_DRDY_FMT, __LINE__);
}
bool ADS131M08Hub::set_drdy_idle_state(uint8_t drdy_state)
{
if (drdy_state > 1)
{
return false;
}
return adc_register_write_masked(REG_MODE, drdy_state < 1, MASK_MODE_DRDY_HiZ, __LINE__);
}
bool ADS131M08Hub::set_power_mode(uint8_t power_mode)
{
if (power_mode > 3)
{
return false;
}
return adc_register_write_masked(REG_CLOCK, power_mode, MASK_CLOCK_PWR, __LINE__);
}
bool ADS131M08Hub::set_reg_osr()
{
uint16_t osr = 3; // default
if (this->osr_ <= 16256 && this->osr_ >= 128) {
if (this->osr_ == 16256)
osr = 7;
else {
osr = 0;
auto tmp = this->osr_/128;
while (tmp >>= 1)
osr++;
}
}
return adc_register_write_masked(REG_CLOCK, osr << 2, MASK_CLOCK_OSR, __LINE__);
}
//void ADS131M08Hub::set_full_scale(uint8_t channel, float scale)
//{
// if (channel > 7) {
// return;
// }
//
// this->full_scale.ch[channel].f = scale;
//
//}
//
//float ADS131M08Hub::get_full_scale(uint8_t channel)
//{
// if (channel > 7) {
// return 0.0;
// }
//
// return this->full_scale.ch[channel].f;
//
//}
bool ADS131M08Hub::set_channel_enable(uint8_t channel, bool enable)
{
if (channel > 7)
return false;
uint16_t enable_mask = MASK_CLOCK_CH0 << channel;
uint16_t reg_value = (enable) ? enable_mask : 0;
//ESP_LOGD(TAG, "adc_register_write_masked(REG_CLOCK=%02X, reg_value=%04X, enable_mask=%04X, __LINE__)", REG_CLOCK, reg_value, enable_mask);
return adc_register_write_masked(REG_CLOCK, reg_value, enable_mask, __LINE__);
//return true;
}
bool ADS131M08Hub::set_channel_pga(uint8_t channel, ADS131M08_PGA_GAIN pga)
{
uint16_t pgaCode = (uint16_t) pga;
switch (channel) {
case 0:
if(!adc_register_write_masked(REG_GAIN1, pgaCode, MASK_GAIN_PGAGAIN0, __LINE__))
return false;
this->pgaGain[0] = pga;
return true;
case 1:
if(!adc_register_write_masked(REG_GAIN1, pgaCode << 4, MASK_GAIN_PGAGAIN1, __LINE__))
return false;
this->pgaGain[1] = pga;
return true;
case 2:
if(!adc_register_write_masked(REG_GAIN1, pgaCode << 8, MASK_GAIN_PGAGAIN2, __LINE__))
return false;
this->pgaGain[2] = pga;
return true;
case 3:
if(!adc_register_write_masked(REG_GAIN1, pgaCode << 12, MASK_GAIN_PGAGAIN3, __LINE__))
return false;
this->pgaGain[3] = pga;
return true;
case 4:
if(!adc_register_write_masked(REG_GAIN2, pgaCode, MASK_GAIN_PGAGAIN4, __LINE__))
return false;
this->pgaGain[4] = pga;
return true;
case 5:
if(!adc_register_write_masked(REG_GAIN2, pgaCode << 4, MASK_GAIN_PGAGAIN5, __LINE__))
return false;
this->pgaGain[5] = pga;
return true;
case 6:
if(!adc_register_write_masked(REG_GAIN2, pgaCode << 8, MASK_GAIN_PGAGAIN6, __LINE__))
return false;
this->pgaGain[6] = pga;
return true;
case 7:
if(!adc_register_write_masked(REG_GAIN2, pgaCode << 12, MASK_GAIN_PGAGAIN7, __LINE__))
return false;
this->pgaGain[7] = pga;
return true;
default:
return false; // Invalid channel
}
return false;
}
ADS131M08_PGA_GAIN ADS131M08Hub::get_channel_pga(uint8_t channel)
{
if(channel > 7)
{
return ADS131M08_PGA_GAIN::PGA_INVALID;
}
return pgaGain[channel];
}
void ADS131M08Hub::set_global_chop(uint16_t global_chop)
{
adc_register_write_masked(REG_CFG, global_chop << 8, MASK_CFG_GC_EN, __LINE__);
}
void ADS131M08Hub::set_global_chop_delay(uint16_t delay)
{
adc_register_write_masked(REG_CFG, delay << 9, MASK_CFG_GC_DLY, __LINE__);
}
bool ADS131M08Hub::set_channel_phase_calibration(uint8_t channel, int16_t phase_offset)
{
if(channel > 7)
return false;
uint16_t reg_addr = 5 * channel + REG_CH0_CFG;
if(phase_offset < -512 || phase_offset > 511)
return false;
return adc_register_write_masked(reg_addr, (phase_offset << 6), MASK_CHX_CFG_PHASE, __LINE__);
}
bool ADS131M08Hub::set_dcblock_filter_disable(uint8_t channel, bool disable)
{
if (channel > 7)
return false;
uint16_t reg_addr = 5 * channel + REG_CH0_CFG;
uint16_t reg_value = (disable) ? MASK_CHX_CFG_DCBLKX_DIS : 0;
return adc_register_write_masked(reg_addr, reg_value, MASK_CHX_CFG_DCBLKX_DIS, __LINE__);
}
bool ADS131M08Hub::set_channel_input_selection(uint8_t channel, ADS131M08_INPUT_CHANNEL_MUX input)
{
if(channel > 7)
return false;
uint16_t reg_addr = 5 * channel + REG_CH0_CFG;
return adc_register_write_masked(reg_addr, input, MASK_CHX_CFG_MUX, __LINE__);
}
bool ADS131M08Hub::set_channel_offset_calibration(uint8_t channel, int32_t offset)
{
if(channel > 7)
return false;
if(offset < -8388608 || offset > 8388607)
return false;
uint16_t MSB = offset >> 8;
uint16_t LSB = offset << 8;
uint16_t reg_addr = 5 * channel + REG_CH0_OCAL_MSB;
return adc_register_write_masked(reg_addr, { MSB, LSB }, { MASK_CHX_OCAL_MSB, MASK_CHX_OCAL_LSB }, __LINE__);
}
bool ADS131M08Hub::set_channel_gain_calibration(uint8_t channel, uint32_t gain)
{
if(channel > 7)
return false;
if(gain > 16777215)
return false;
uint16_t MSB = gain >> 8;
uint8_t LSB = gain;
uint16_t reg_addr = 5 * channel + REG_CH0_GCAL_MSB;
return adc_register_write_masked(reg_addr, { MSB, LSB }, { MASK_CHX_GCAL_MSB, MASK_CHX_GCAL_LSB }, __LINE__);
}
//bool ADS131M08Hub::is_data_ready()
//{
// if (digitalRead(drdyPin) == HIGH)
// {
// return false;
// }
// return true;
//}
uint16_t ADS131M08Hub::get_id()
{
return readRegister(REG_ID);
}
uint16_t ADS131M08Hub::get_mode_reg()
{
return readRegister(REG_MODE);
}
uint16_t ADS131M08Hub::get_clock_reg()
{
return readRegister(REG_CLOCK);
}
uint16_t ADS131M08Hub::get_cfg_reg()
{
return readRegister(REG_CFG);
}
//AdcOutput ADS131M08Hub::read_adc_raw()
//{
// uint8_t x = 0;
// uint8_t x2 = 0;
// uint8_t x3 = 0;
// int32_t aux;
// AdcOutput res;
//
// digitalWrite(csPin, LOW);
// delayMicroseconds(1);
//
// x = spi.transfer(0x00);
// x2 = spi.transfer(0x00);
// spi.transfer(0x00);
//
// this->resultRaw.status = ((x << 8) | x2);
//
// for(int i = 0; i<8; i++)
// {
// x = spi.transfer(0x00);
// x2 = spi.transfer(0x00);
// x3 = spi.transfer(0x00);
//
// aux = (((x << 16) | (x2 << 8) | x3) & 0x00FFFFFF);
// if (aux > 0x7FFFFF)
// {
// this->resultRaw.ch[i].i = ((~(aux)&0x00FFFFFF) + 1) * -1;
// }
// else
// {
// this->resultRaw.ch[i].i = aux;
// }
// }
//
// delayMicroseconds(1);
// digitalWrite(csPin, HIGH);
//
// return this->resultRaw;
//}
//float ADS131M08Hub::scale_result(uint8_t num)
//{
// if( num >= 8) {
// return 0.0;
// }
//
// return this->resultFloat.ch[num].f = (float)(this->resultRaw.ch[num].i * rawToVolts * this->full_scale.ch[num].f);
//}
//AdcOutput ADS131M08Hub::scale_result()
//{
// // update status
// this->resultFloat.status = this->resultRaw.status;
// // Scale all channels
// for(int i = 0; i<8; i++)
// {
// this->scaleResult(i);
// }
//
// return this->resultFloat;
//}
//
//AdcOutput ADS131M08Hub::read_adc_float()
//{
// this->readAdcRaw();
// return this->scaleResult();
//}
// end of from tpcorrea
// for debug only - remove references, declarations and definitions before submitting for production
std::string ADS131M08Hub::frame_to_string(const spiframe& frame)
{
std::string str;
char buffer[20];
const std::string::size_type new_cap(768);
str.reserve(new_cap);
for (int i = 0; i < frame.size(); i++) {
snprintf(buffer, sizeof(buffer), " %02X", frame[i]);
str += buffer;
}
return str;
}
std::string ADS131M08Hub::conversion_frame_to_string(const spiframe& frame)
{
std::string str;
char buffer[20];
const std::string::size_type new_cap(768);
str.reserve(new_cap);
int word_nbytes = adc_word_length_ >> 3;
int frame_nwords = frame.size() / word_nbytes;
uint16_t drdy_status = get_unsigned_frame_word(frame, 0, true) & MASK_STATUS_DRDY;
// init i = 0 to also print status word
for (int i = 1; i < frame_nwords - 1; i++) {
if(i == 0) {
for (int j = 0; j < word_nbytes; j++) {
snprintf(buffer, sizeof(buffer), "%02X", frame[j]);
str += buffer;
}
}
else {
if (drdy_status & 1) {
str += std::format(" CH{}:", i - 1);
for (int j = 0; j < word_nbytes; j++) {
snprintf(buffer, sizeof(buffer), "%02X", frame[i * word_nbytes + j]);
str += buffer;
}
}
drdy_status = drdy_status >> 1;
}
}
return str;
}
std::string ADS131M08Hub::rwreg_command_frame_to_string(const spiframe& frame)
{
char buffer[100];
std::string str;
str.reserve(512);
uint16_t cmdadr = get_unsigned_frame_word(frame, 0, true);
uint16_t address = (cmdadr & MASK_CMD_RW_REG_ADDRESS) >> 7;
int nregs = 1 + (cmdadr & MASK_CMD_RW_REG_COUNT);
str = command_to_string(cmdadr);
uint16_t command = (cmdadr & MASK_CMD_RW_REG) ? (cmdadr & MASK_CMD_RW_REG) : cmdadr;
const char* ws = " \t\n\r\f\v"; // Defines whitespace
if (command == CMD_RREG) {
str += " : regs ";
for (int i = 0; i < nregs; i++) {
str += reg_addr_to_string(address + i);
str.erase(str.find_last_not_of(ws) + 1);
str += (i < (nregs - 1) ? ", " : "");
}
}
if (command == CMD_WREG) {
str += ", data:";
for (int i = 0; i < nregs; i++) {
uint16_t data = get_unsigned_frame_word(frame, i + 1, true);
snprintf(buffer, sizeof(buffer), " 0x%04X", data);
str += buffer;
}
for (int i = 0; i < nregs; i++) {
uint16_t data = get_unsigned_frame_word(frame, i + 1, true);
str += "\n ";
str += reg_data_to_string(address + i, data);
str.erase(str.find_last_not_of(ws) + 1);
str += (i < (nregs - 1) ? ", " : "");
}
}
return str;
}
std::string ADS131M08Hub::reg_addr_to_string(int address)
{
return reg_data_to_string(address, 0, true);
}
std::string ADS131M08Hub::reg_data_to_string(int address, uint16_t data, bool nameonly)
{
std::string str;
char buffer[100];
str.reserve(120);
switch (address) {
case REG_ID:
str += std::format("{:<10}", "ID");
if (nameonly)
break;
snprintf(buffer, sizeof(buffer), ": %d ", (data >> 8) & 0x0F);
str += buffer;
break;
case REG_STATUS:
str += std::format("{:<10}", "STATUS");
if (nameonly)
break;
str += ":";
str += status_to_string(data);
break;
case REG_MODE:
str += std::format("{:<10}", "MODE");
if (nameonly)
break;
str += ":";
if ((data & MASK_MODE_REG_CRC_EN) != 0) str += " REGMAP_CRC_EN /";
if ((data & MASK_MODE_RX_CRC_EN) != 0) str += " SPI_IN_CRC_EN /";
if ((data & MASK_MODE_TIMEOUT) != 0) str += " SPI_TIMEOUT_EN /";
str += " CRC=";
str += ((data & MASK_MODE_CRC_TYPE) != 0) ? "ANSI /" : "CCITT /";
if ((data & MASK_MODE_RESET) != 0) str += " RESET /";
str += " WL=";
if ((data & MASK_MODE_WLENGTH) == WLENGTH_16_BITS) str += "16";
if ((data & MASK_MODE_WLENGTH) == WLENGTH_24_BITS) str += "24";
if ((data & MASK_MODE_WLENGTH) == WLENGTH_32_BITS_LSB_ZERO_PADDING) str += "32zp";
if ((data & MASK_MODE_WLENGTH) == WLENGTH_32_BITS_MSB_SIGN_EXTEND) str += "32se";
str += " / DRDY SEL=";
if ((data & MASK_MODE_DRDY_SEL) == DRDY_SEL_MOST_LAGGING) str += "MOST_LAGGING";
if ((data & MASK_MODE_DRDY_SEL) == DRDY_SEL_LOGICAL_OR) str += "OR_OF_CHANLS";
if ((data & MASK_MODE_DRDY_SEL) == DRDY_SEL_MOST_LEADING_CHAN) str += "MOST_LEADING";
if ((data & MASK_MODE_DRDY_SEL) == DRDY_SEL_MOST_LEADING_CHAN2) str += "MOST_LEADING";
str += " / DRDY IDLE=";
str += ((data & MASK_MODE_DRDY_HiZ) != 0) ? "Hi_IMP" : "LOGIC_HI";
str += " / DRDY ACTV=";
str += ((data & MASK_MODE_DRDY_FMT) != 0) ? "LOW_FIX_DUR" : "LOGIC_LOW";
break;
case REG_CLOCK:
str += std::format("{:<10}", "CLOCK");
if (nameonly)
break;
str += ": CH ENABLED=";
str += ((data & MASK_CLOCK_CH7) != 0) ? "7" : "_";
str += ((data & MASK_CLOCK_CH6) != 0) ? "6" : "_";
str += ((data & MASK_CLOCK_CH5) != 0) ? "5" : "_";
str += ((data & MASK_CLOCK_CH4) != 0) ? "4" : "_";
str += ((data & MASK_CLOCK_CH3) != 0) ? "3" : "_";
str += ((data & MASK_CLOCK_CH2) != 0) ? "2" : "_";
str += ((data & MASK_CLOCK_CH1) != 0) ? "1" : "_";
str += ((data & MASK_CLOCK_CH0) != 0) ? "0" : "_";
str += " / XTAL OSC=";
str += ((data & MASK_CLOCK_XTAL_DIS) != 0) ? "DIS" : "EN";
str += " / EXT VREF=";
str += ((data & MASK_CLOCK_EXTREF_EN) != 0) ? "EN" : "DIS";
{
uint16_t osr = 1 << (7 + ((data & MASK_CLOCK_OSR) >> 2));
if (osr == 16384) {
osr = 16256;
}
snprintf(buffer, sizeof(buffer), " / OSR=%d", osr);
str += buffer;
}
str += " / POWER=";
if ((data & MASK_CLOCK_PWR) == PM_VERY_LOW_POWER) str += "VERY_LOW";
if ((data & MASK_CLOCK_PWR) == PM_LOW_POWER) str += "VERY_LOW";
if ((data & MASK_CLOCK_PWR) == PM_HIGH_RESOLUTION) str += "HIGH_RES";
if ((data & MASK_CLOCK_PWR) == PM_HIGH_RESOLUTION2) str += "HIGH_RES";
break;
case REG_GAIN1:
{
str += std::format("{:<10}", "GAIN1");
if (nameonly)
break;
auto gain = 1 << ((data & MASK_GAIN_PGAGAIN3) >> 24);
snprintf(buffer, sizeof(buffer), ": Ch3=%d /", gain);
str += buffer;
gain = 1 << ((data & MASK_GAIN_PGAGAIN2) >> 16);
snprintf(buffer, sizeof(buffer), " Ch2=%d /", gain);
str += buffer;
gain = 1 << ((data & MASK_GAIN_PGAGAIN1) >> 8);
snprintf(buffer, sizeof(buffer), " Ch1=%d /", gain);
str += buffer;
gain = 1 << (data & MASK_GAIN_PGAGAIN0);
snprintf(buffer, sizeof(buffer), " Ch0=%d", gain);
str += buffer;
break;
}
case REG_GAIN2:
{
str += std::format("{:<10}", "GAIN2");
if (nameonly)
break;
auto gain = 1 << ((data & MASK_GAIN_PGAGAIN7) >> 24);
snprintf(buffer, sizeof(buffer), ": Ch7=%d /", gain);
str += buffer;
gain = 1 << ((data & MASK_GAIN_PGAGAIN6) >> 16);
snprintf(buffer, sizeof(buffer), " Ch6=%d /", gain);
str += buffer;
gain = 1 << ((data & MASK_GAIN_PGAGAIN5) >> 8);
snprintf(buffer, sizeof(buffer), " Ch5=%d /", gain);
str += buffer;
gain = 1 << (data & MASK_GAIN_PGAGAIN4);
snprintf(buffer, sizeof(buffer), " Ch4=%d", gain);
str += buffer;
break;
}
case REG_CFG:
{
str += std::format("{:<10}", "CFG");
if (nameonly)
break;
str += ": GC_EN=";
str += ((data & MASK_CFG_GC_EN) != 0) ? "Y /" : "N /";
auto gc_dly = 1 << (1 + ((data & MASK_CFG_GC_DLY) >> 9));
snprintf(buffer, sizeof(buffer), " GC DELAY= %d", gc_dly);
str += buffer;
str += " / CUR DET= [";
str += ((data & MASK_CFG_CD_EN) != 0) ? "Y] " : "N] ";
str += ((data & MASK_CFG_CD_ALLCH) != 0) ? "ALL_CH" : "ANY_CH";
auto cd_num = 1 << ((data & MASK_CFG_CD_NUM) >> 4);
snprintf(buffer, sizeof(buffer), " / CD_NUM= %d", cd_num);
str += buffer;
auto cd_len = (data & MASK_CFG_CD_LEN) >> 1;
switch (cd_len) {
case 0:
cd_len = 128;
break;
case 1:
cd_len = 256;
break;
case 2:
cd_len = 512;
break;
case 3:
cd_len = 768;
break;
case 4:
cd_len = 1280;
break;
case 5:
cd_len = 1792;
break;
case 6:
cd_len = 2560;
break;
case 7:
cd_len = 3584;
break;
default:
cd_len = 0; // illegal case
break;
}
snprintf(buffer, sizeof(buffer), " / CD_LEN= %d", cd_len);
str += buffer;
break;
}
case REG_THRSHLD_MSB:
str += std::format("{:<10}", "TH_MSB");
if (nameonly)
break;
snprintf(buffer, sizeof(buffer), ": 0x%04X", data);
str += buffer;
break;
case REG_THRSHLD_LSB:
str += std::format("{:<10}", "TH_LSB");
if (nameonly)
break;
snprintf(buffer, sizeof(buffer), ": 0x%04X / ", (data & MASK_THRSHLD_LSB_CD_TH_LSB) >> 8);
str += buffer;
snprintf(buffer, sizeof(buffer), " DCBLOCK: 0x%04X", data & MASK_THRSHLD_LSB_DCBLOCK);
str += buffer;
break;
case REG_CH0_CFG:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH0_OCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH0_OCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH0_GCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH0_GCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH1_CFG:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH1_OCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH1_OCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH1_GCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH1_GCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH2_CFG:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH2_OCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH2_OCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH2_GCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH2_GCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH3_CFG:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH3_OCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH3_OCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH3_GCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH3_GCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH4_CFG:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH4_OCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH4_OCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH4_GCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH4_GCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH5_CFG:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH5_OCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH5_OCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH5_GCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH5_GCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH6_CFG:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH6_OCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH6_OCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH6_GCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH6_GCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH7_CFG:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH7_OCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH7_OCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH7_GCAL_MSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REG_CH7_GCAL_LSB:
str += reg_config_to_string(address, data, nameonly);
break;
case REGMAP_CRC:
str += std::format("{:<10}", std::format("REGMAP_CRC[{:#02}]", address));
if (nameonly)
break;
snprintf(buffer, sizeof(buffer), " value: 0x%04X", data);
str += buffer;
}
return str;
}
std::string ADS131M08Hub::reg_config_to_string(int address, uint16_t data, bool nameonly)
{
std::string str;
str.reserve(256);
int ch_num = (address - REG_CH0_CFG) / 5;
int gen_addr = (address - REG_CH0_CFG) % 5;
std::string ch_str = std::format("CH{}_", ch_num);
switch (gen_addr)
{
case REG_CHX_CFG:
str += std::format("{:<10}", std::format("{}CFG", ch_str));
if (nameonly)
break;
str += std::format(": PH_DEL={0:}", (data & MASK_CHX_CFG_PHASE) >> 6);
str += " DCBLOCK_EN=";
str += ((data & MASK_CHX_CFG_DCBLKX_DIS) != 0) ? "N /" : "Y /";
str += std::format("{}INPUT=", ch_str);
if ((data & MASK_CHX_CFG_MUX) == ICM_AIN0P_AIN0N) str += "AIN0P and AIN0N";
if ((data & MASK_CHX_CFG_MUX) == ICM_INPUT_SHORTED) str += "ADC inputs shorted";
if ((data & MASK_CHX_CFG_MUX) == ICM_POSITIVE_DC_TEST_SIGNAL) str += "Positive DC test signal";
if ((data & MASK_CHX_CFG_MUX) == ICM_NEGATIVE_DC_TEST_SIGNAL) str += "Negative DC test signal";
break;
case REG_CHX_OCAL_MSB:
str += std::format("{:<13}", std::format("{}OCAL_MSB", ch_str));
if (nameonly)
break;
str += std::format(": {:#04x}", data);
break;
case REG_CHX_OCAL_LSB:
str += std::format("{:<13}", std::format("{}OCAL_LSB", ch_str));
if (nameonly)
break;
str += std::format(": {:#04x}", (data & MASK_CHX_OCAL_LSB) >> 8);
break;
case REG_CHX_GCAL_MSB:
str += std::format("{:<13}", std::format("{}GCAL_MSB", ch_str));
if (nameonly)
break;
str += std::format(": {:#04x}", data);
break;
case REG_CHX_GCAL_LSB:
str += std::format("{:<13}", std::format("{}GCAL_LSB", ch_str));
if (nameonly)
break;
str += std::format(": {:#04x}", (data & MASK_CHX_GCAL_LSB) >> 8);
break;
}
return str;
}
std::string ADS131M08Hub::command_to_string(uint16_t cmdadr)
{
std::string str;
uint16_t reg_addr, nregs;
char buffer[40];
const std::string::size_type new_cap(256);
str.reserve(new_cap);
snprintf(buffer, sizeof(buffer), "0x%04X", cmdadr);
uint16_t cmd_sw = (cmdadr & MASK_CMD_RW_REG) ? (cmdadr & MASK_CMD_RW_REG) : cmdadr;
switch (cmd_sw) {
case CMD_NULL:
str = "NULL [";
str += buffer;
str += "]";
break;
case CMD_RESET:
str = "RESET [";
str += buffer;
str += "]";
break;
case CMD_STANDBY:
str = "STANDBY [";
str += buffer;
str += "]";
break;
case CMD_WAKEUP:
str = "WAKEUP [";
str += buffer;
str += "]";
break;
case CMD_LOCK:
str = "LOCK [";
str += buffer;
str += "]";
break;
case CMD_UNLOCK:
str = "UNLOCK [";
str += buffer;
str += "]";
break;
case CMD_RREG:
str = "RREG [";
str += buffer;
str += "]: ";
nregs = cmdadr & MASK_CMD_RW_REG_COUNT;
nregs++;
reg_addr = (cmdadr & MASK_CMD_RW_REG_ADDRESS) >> 7;
snprintf(buffer, sizeof(buffer), "#regs:%d, start_addr:%d ", nregs, reg_addr);
str += buffer;
break;
case CMD_WREG:
str = "WREG [";
str += buffer;
str += "]: ";
nregs = cmdadr & MASK_CMD_RW_REG_COUNT;
nregs++;
reg_addr = (cmdadr & MASK_CMD_RW_REG_ADDRESS) >> 7;
snprintf(buffer, sizeof(buffer), "#regs:%d, start_addr:%d ", nregs, reg_addr);
str += buffer;
break;
default:
str = "UNKNOWN command [";
str += buffer;
str += "]";
break;
}
return str;
}
// we do not return strings from this function as its length could exceed maximum length that log print can handle
void ADS131M08Hub::print_command_response_to_string(uint16_t cmdadr_sent, const spiframe& frame)
{
std::string str;
uint16_t nregs, start_addr, respcmd;
char buffer[40];
str.reserve(256);
uint16_t response = frame[0] << 8 | frame[1];
snprintf(buffer, sizeof(buffer), " [0x%04X]: ", response);
std::string resp_txt(buffer);
uint16_t command = (cmdadr_sent & MASK_CMD_RW_REG) ? (cmdadr_sent & MASK_CMD_RW_REG) : cmdadr_sent;
switch (command) {
case CMD_NULL:
str = "STATUS" + resp_txt;
str += status_to_string(response);
ESP_LOGD(TAG, "%s", str.c_str());
break;
case CMD_RESET:
str = "RESET RESPONSE" + resp_txt;
switch (response) {
case RSP_RESET_OK:
str += "RESET SUCCESS";
break;
case RSP_RESET_NOK:
str += "RESET NOT COMPLETE";
break;
default:
str += "UNKNOWN RESET RESPONSE";
break;
}
ESP_LOGD(TAG, "%s", str.c_str());
break;
case CMD_STANDBY:
str = "STANDBY RESPONSE" + resp_txt;
if (response == CMD_STANDBY) {
str += "IN STANDBY";
}
else {
str += "UNKNOWN";
}
ESP_LOGD(TAG, "%s", str.c_str());
break;
case CMD_WAKEUP:
str = "WAKEUP RESPONSE" + resp_txt;
if (response == CMD_WAKEUP) {
str += "EXITED STANDBY";
}
else {
str += "UNKNOWN";
}
ESP_LOGD(TAG, "%s", str.c_str());
break;
case CMD_LOCK:
str = "LOCK RESPONSE " + resp_txt;
if (response == CMD_LOCK) {
str += "LOCKED";
}
else {
str += "UNKNOWN";
}
ESP_LOGD(TAG, "%s", str.c_str());
break;
case CMD_UNLOCK:
str = "UNLOCK RESPONSE" + resp_txt;
if (response == CMD_UNLOCK) {
str += "UNLOCKED";
}
else {
str += "UNKNOWN";
}
ESP_LOGD(TAG, "%s", str.c_str());
break;
case CMD_RREG:
{
int offset = 0;
str = "RREG RESPONSE" + resp_txt;
nregs = (cmdadr_sent & MASK_CMD_RW_REG_COUNT) + 1;
uint16_t rreg_ack = cmdadr_sent; // not really and ack, but since we don't get an ack when reading 1 register we pretend this is the ack
if (nregs > 1) {
offset = 1;
rreg_ack = get_unsigned_frame_word(frame, 0, true);;
nregs = (rreg_ack & MASK_CMD_RW_REG_COUNT) + 1; // should not change here, but just in case adc decided to sent different number of registers
}
start_addr = (rreg_ack & MASK_CMD_RW_REG_ADDRESS) >> 7;
snprintf(buffer, sizeof(buffer), "#regs:%d, start_addr:%d ", nregs, start_addr);
ESP_LOGVV(TAG, "%s", buffer);
if (nregs == 1) {
start_addr = (cmdadr_sent & MASK_CMD_RW_REG_ADDRESS) >> 7;
str = reg_data_to_string(start_addr, response);
ESP_LOGVV(TAG, "%s", str.c_str());
}
else {
respcmd = response & MASK_CMD_RW_REG_RESP;
if (respcmd == RREG_RESP) {
for (int i = 0; i < nregs; i++) {
uint16_t rxdata = get_unsigned_frame_word(frame, i + offset, true);
str = reg_data_to_string(start_addr + i, rxdata);
ESP_LOGVV(TAG, "%s", str.c_str());
}
}
else {
str = "WARNING: invalid response to RREG. Should be Exxxx or Fxxxx";
ESP_LOGW(TAG, "%s", str.c_str());
}
}
}
break;
case CMD_WREG:
str = "WREG RESPONSE" + resp_txt;
respcmd = response & MASK_CMD_RW_REG_RESP;
if (respcmd == WREG_RESP) {
nregs = response & MASK_CMD_RW_REG_COUNT;
start_addr = (response & MASK_CMD_RW_REG_ADDRESS) >> 7;
snprintf(buffer, sizeof(buffer), "#regs:%d, start-addr:%d ", nregs + 1, start_addr);
str += buffer;
ESP_LOGVV(TAG, "%s", str.c_str());
}
else {
str += "WARNING: invalid response to WREG. Should be 4xxxx or 5xxxx";
ESP_LOGW(TAG, "%s", str.c_str());
}
break;
default:
str = "Response to UNKNOWN command [";
str += buffer;
str += "]";
ESP_LOGW(TAG, "%s", str.c_str());
break;
}
}
std::string ADS131M08Hub::status_to_string(uint16_t response)
{
std::string str;
str.reserve(90);
if ((response & MASK_STATUS_LOCK) != 0) str += " LOCK /";
if ((response & MASK_STATUS_RESYNC) != 0) str += " RESYNC /";
if ((response & MASK_STATUS_REGMAP) != 0) str += " REGMAP /";
if ((response & MASK_STATUS_CRC_ERR) != 0) str += " CRC_ERR /";
str += " CRC=";
str += ((response & MASK_STATUS_CRC_TYPE) != 0) ? "ANSI /" : "CCITT /";
if ((response & MASK_STATUS_RESET) != 0) str += " RESET /";
str += " WL=";
if ((response & MASK_STATUS_WLENGTH) == WLENGTH_16_BITS) str += "16";
if ((response & MASK_STATUS_WLENGTH) == WLENGTH_24_BITS) str += "24";
if ((response & MASK_STATUS_WLENGTH) == WLENGTH_32_BITS_LSB_ZERO_PADDING) str += "32zp";
if ((response & MASK_STATUS_WLENGTH) == WLENGTH_32_BITS_MSB_SIGN_EXTEND) str += "32se";
str += " / DRDY=";
str += ((response & MASK_STATUS_DRDY7) != 0) ? "7" : "_";
str += ((response & MASK_STATUS_DRDY6) != 0) ? "6" : "_";
str += ((response & MASK_STATUS_DRDY5) != 0) ? "5" : "_";
str += ((response & MASK_STATUS_DRDY4) != 0) ? "4" : "_";
str += ((response & MASK_STATUS_DRDY3) != 0) ? "3" : "_";
str += ((response & MASK_STATUS_DRDY2) != 0) ? "2" : "_";
str += ((response & MASK_STATUS_DRDY1) != 0) ? "1" : "_";
str += ((response & MASK_STATUS_DRDY0) != 0) ? "0" : "_";
return str;
}
// end of for debug only section
} // namespace ads131m08
} // namespace esphome
Reference in New Issue View Git Blame Copy Permalink