From 3120783000d0025b183b0397acaa8b769499eb38 Mon Sep 17 00:00:00 2001 From: krolyxon Date: Mon, 8 Jun 2026 23:10:46 +0530 Subject: Initial gh-pages firmware hosting --- .../genericdevice_uartregtest/.uno.test.skip | 0 .../genericdevice_uartregtest.ino | 219 +++++++++++++++++ .../examples/genericdevice_uarttest/.uno.test.skip | 0 .../genericdevice_uarttest.ino | 98 ++++++++ .../i2c_address_detect/i2c_address_detect.ino | 22 ++ .../examples/i2c_readwrite/i2c_readwrite.ino | 45 ++++ .../examples/i2c_registers/i2c_registers.ino | 43 ++++ .../i2corspi_register/i2corspi_register.ino | 40 +++ .../examples/spi_modetest/spi_modetest.ino | 35 +++ .../examples/spi_readwrite/spi_readwrite.ino | 43 ++++ .../spi_register_bits/spi_register_bits.ino | 268 +++++++++++++++++++++ .../examples/spi_registers/spi_registers.ino | 40 +++ 12 files changed, 853 insertions(+) create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/.uno.test.skip create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/genericdevice_uartregtest.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/.uno.test.skip create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/genericdevice_uarttest.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_address_detect/i2c_address_detect.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_readwrite/i2c_readwrite.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_registers/i2c_registers.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2corspi_register/i2corspi_register.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_modetest/spi_modetest.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_readwrite/spi_readwrite.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_register_bits/spi_register_bits.ino create mode 100644 .pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_registers/spi_registers.ino (limited to '.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples') diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/.uno.test.skip b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/.uno.test.skip new file mode 100644 index 0000000..e69de29 diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/genericdevice_uartregtest.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/genericdevice_uartregtest.ino new file mode 100644 index 0000000..59af308 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uartregtest/genericdevice_uartregtest.ino @@ -0,0 +1,219 @@ +/* + Advanced example of using bstracted transport for reading and writing + register data from a UART-based device such as a TMC2209 + + Written with help by Claude! + https://claude.ai/chat/335f50b1-3dd8-435e-9139-57ec7ca26a3c (at this time + chats are not shareable :( +*/ + +#include "Adafruit_BusIO_Register.h" +#include "Adafruit_GenericDevice.h" + +// Debugging macros +#define DEBUG_SERIAL Serial + +#ifdef DEBUG_SERIAL +#define DEBUG_PRINT(x) DEBUG_SERIAL.print(x) +#define DEBUG_PRINTLN(x) DEBUG_SERIAL.println(x) +#define DEBUG_PRINT_HEX(x) \ + do { \ + if (x < 0x10) \ + DEBUG_SERIAL.print('0'); \ + DEBUG_SERIAL.print(x, HEX); \ + DEBUG_SERIAL.print(' '); \ + } while (0) +#else +#define DEBUG_PRINT(x) +#define DEBUG_PRINTLN(x) +#define DEBUG_PRINT_HEX(x) +#endif + +#define TMC2209_IOIN 0x06 + +class TMC2209_UART { +private: + Stream *_uart_stream; + uint8_t _addr; + + static bool uart_read(void *thiz, uint8_t *buffer, size_t len) { + TMC2209_UART *dev = (TMC2209_UART *)thiz; + uint16_t timeout = 100; + while (dev->_uart_stream->available() < len && timeout--) { + delay(1); + } + if (timeout == 0) { + DEBUG_PRINTLN("Read timeout!"); + return false; + } + + DEBUG_PRINT("Reading: "); + for (size_t i = 0; i < len; i++) { + buffer[i] = dev->_uart_stream->read(); + DEBUG_PRINT_HEX(buffer[i]); + } + DEBUG_PRINTLN(""); + + return true; + } + + static bool uart_write(void *thiz, const uint8_t *buffer, size_t len) { + TMC2209_UART *dev = (TMC2209_UART *)thiz; + DEBUG_PRINT("Writing: "); + for (size_t i = 0; i < len; i++) { + DEBUG_PRINT_HEX(buffer[i]); + } + DEBUG_PRINTLN(""); + + dev->_uart_stream->write(buffer, len); + return true; + } + + static bool uart_readreg(void *thiz, uint8_t *addr_buf, uint8_t addrsiz, + uint8_t *data, uint16_t datalen) { + TMC2209_UART *dev = (TMC2209_UART *)thiz; + while (dev->_uart_stream->available()) + dev->_uart_stream->read(); + + uint8_t packet[4] = {0x05, uint8_t(dev->_addr << 1), addr_buf[0], 0x00}; + + packet[3] = calcCRC(packet, 3); + if (!uart_write(thiz, packet, 4)) + return false; + + // Read back echo + uint8_t echo[4]; + if (!uart_read(thiz, echo, 4)) + return false; + + // Verify echo + for (uint8_t i = 0; i < 4; i++) { + if (echo[i] != packet[i]) { + DEBUG_PRINTLN("Echo mismatch"); + return false; + } + } + + uint8_t response[8]; // sync + 0xFF + reg + 4 data bytes + CRC + if (!uart_read(thiz, response, 8)) + return false; + + // Verify response + if (response[0] != 0x05) { + DEBUG_PRINTLN("Invalid sync byte"); + return false; + } + + if (response[1] != 0xFF) { + DEBUG_PRINTLN("Invalid reply address"); + return false; + } + + if (response[2] != addr_buf[0]) { + DEBUG_PRINTLN("Register mismatch"); + return false; + } + + uint8_t crc = calcCRC(response, 7); + if (crc != response[7]) { + DEBUG_PRINTLN("CRC mismatch"); + return false; + } + + memcpy(data, &response[3], 4); + return true; + } + + static bool uart_writereg(void *thiz, uint8_t *addr_buf, uint8_t addrsiz, + const uint8_t *data, uint16_t datalen) { + TMC2209_UART *dev = (TMC2209_UART *)thiz; + while (dev->_uart_stream->available()) + dev->_uart_stream->read(); + + uint8_t packet[8] = {0x05, + uint8_t(dev->_addr << 1), + uint8_t(addr_buf[0] | 0x80), + data[0], + data[1], + data[2], + data[3], + 0x00}; + + packet[7] = calcCRC(packet, 7); + if (!uart_write(thiz, packet, 8)) + return false; + + uint8_t echo[8]; + if (!uart_read(thiz, echo, 8)) + return false; + + for (uint8_t i = 0; i < 8; i++) { + if (echo[i] != packet[i]) { + DEBUG_PRINTLN("Write echo mismatch"); + return false; + } + } + + return true; + } + + static uint8_t calcCRC(uint8_t *data, uint8_t length) { + uint8_t crc = 0; + for (uint8_t i = 0; i < length; i++) { + uint8_t currentByte = data[i]; + for (uint8_t j = 0; j < 8; j++) { + if ((crc >> 7) ^ (currentByte & 0x01)) { + crc = (crc << 1) ^ 0x07; + } else { + crc = crc << 1; + } + currentByte = currentByte >> 1; + } + } + return crc; + } + +public: + TMC2209_UART(Stream *serial, uint8_t addr) + : _uart_stream(serial), _addr(addr) {} + + Adafruit_GenericDevice *createDevice() { + return new Adafruit_GenericDevice(this, uart_read, uart_write, uart_readreg, + uart_writereg); + } +}; + +void setup() { + Serial.begin(115200); + while (!Serial) + ; + delay(100); + Serial.println("TMC2209 Generic Device register read/write test!"); + + Serial1.begin(115200); + + TMC2209_UART uart(&Serial1, 0); + Adafruit_GenericDevice *device = uart.createDevice(); + device->begin(); + + // Create register object for IOIN + Adafruit_BusIO_Register ioin_reg(device, + TMC2209_IOIN, // device and register address + 4, // width = 4 bytes + MSBFIRST, // byte order + 1); // address width = 1 byte + Serial.print("IOIN = 0x"); + Serial.println(ioin_reg.read(), HEX); + + // Create RegisterBits for VERSION field (bits 31:24) + Adafruit_BusIO_RegisterBits version_bits( + &ioin_reg, 8, 24); // 8 bits wide, starting at bit 24 + + Serial.println("Reading VERSION..."); + uint8_t version = version_bits.read(); + + Serial.print("VERSION = 0x"); + Serial.println(version, HEX); +} + +void loop() { delay(1000); } \ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/.uno.test.skip b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/.uno.test.skip new file mode 100644 index 0000000..e69de29 diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/genericdevice_uarttest.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/genericdevice_uarttest.ino new file mode 100644 index 0000000..6a11dbf --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/genericdevice_uarttest/genericdevice_uarttest.ino @@ -0,0 +1,98 @@ +/* + Abstracted transport for reading and writing data from a UART-based + device such as a TMC2209 + + Written with help by Claude! + https://claude.ai/chat/335f50b1-3dd8-435e-9139-57ec7ca26a3c (at this time + chats are not shareable :( +*/ + +#include "Adafruit_GenericDevice.h" + +/** + * Basic UART device class that demonstrates using GenericDevice with a Stream + * interface. This example shows how to wrap a Stream (like HardwareSerial or + * SoftwareSerial) with read/write callbacks that can be used by BusIO's + * register functions. + */ +class UARTDevice { +public: + UARTDevice(Stream *serial) : _serial(serial) {} + + // Static callback for writing data to UART + // Called by GenericDevice when data needs to be sent + static bool uart_write(void *thiz, const uint8_t *buffer, size_t len) { + UARTDevice *dev = (UARTDevice *)thiz; + dev->_serial->write(buffer, len); + return true; + } + + // Static callback for reading data from UART + // Includes timeout and will return false if not enough data available + static bool uart_read(void *thiz, uint8_t *buffer, size_t len) { + UARTDevice *dev = (UARTDevice *)thiz; + uint16_t timeout = 100; + while (dev->_serial->available() < len && timeout--) { + delay(1); + } + if (timeout == 0) { + return false; + } + for (size_t i = 0; i < len; i++) { + buffer[i] = dev->_serial->read(); + } + return true; + } + + // Create a GenericDevice instance using our callbacks + Adafruit_GenericDevice *createDevice() { + return new Adafruit_GenericDevice(this, uart_read, uart_write); + } + +private: + Stream *_serial; // Underlying Stream instance (HardwareSerial, etc) +}; + +void setup() { + Serial.begin(115200); + while (!Serial) + ; + delay(100); + + Serial.println("Generic Device test!"); + + // Initialize UART for device communication + Serial1.begin(115200); + + // Create UART wrapper and BusIO device + UARTDevice uart(&Serial1); + Adafruit_GenericDevice *device = uart.createDevice(); + device->begin(); + + // Test write/read cycle + uint8_t write_buf[4] = {0x5, 0x0, 0x0, 0x48}; + uint8_t read_buf[8]; + + Serial.println("Writing data..."); + if (!device->write(write_buf, 4)) { + Serial.println("Write failed!"); + return; + } + + Serial.println("Reading response..."); + if (!device->read(read_buf, 8)) { + Serial.println("Read failed!"); + return; + } + + // Print response bytes + Serial.print("Got response: "); + for (int i = 0; i < 8; i++) { + Serial.print("0x"); + Serial.print(read_buf[i], HEX); + Serial.print(" "); + } + Serial.println(); +} + +void loop() { delay(1000); } \ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_address_detect/i2c_address_detect.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_address_detect/i2c_address_detect.ino new file mode 100644 index 0000000..f2e6ba7 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_address_detect/i2c_address_detect.ino @@ -0,0 +1,22 @@ +#include + +Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(0x10); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("I2C address detection test"); + + if (!i2c_dev.begin()) { + Serial.print("Did not find device at 0x"); + Serial.println(i2c_dev.address(), HEX); + while (1) + ; + } + Serial.print("Device found on address 0x"); + Serial.println(i2c_dev.address(), HEX); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_readwrite/i2c_readwrite.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_readwrite/i2c_readwrite.ino new file mode 100644 index 0000000..4ac2626 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_readwrite/i2c_readwrite.ino @@ -0,0 +1,45 @@ +#include + +#define I2C_ADDRESS 0x60 +Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(I2C_ADDRESS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("I2C device read and write test"); + + if (!i2c_dev.begin()) { + Serial.print("Did not find device at 0x"); + Serial.println(i2c_dev.address(), HEX); + while (1) + ; + } + Serial.print("Device found on address 0x"); + Serial.println(i2c_dev.address(), HEX); + + uint8_t buffer[32]; + // Try to read 32 bytes + i2c_dev.read(buffer, 32); + Serial.print("Read: "); + for (uint8_t i = 0; i < 32; i++) { + Serial.print("0x"); + Serial.print(buffer[i], HEX); + Serial.print(", "); + } + Serial.println(); + + // read a register by writing first, then reading + buffer[0] = 0x0C; // we'll reuse the same buffer + i2c_dev.write_then_read(buffer, 1, buffer, 2, false); + Serial.print("Write then Read: "); + for (uint8_t i = 0; i < 2; i++) { + Serial.print("0x"); + Serial.print(buffer[i], HEX); + Serial.print(", "); + } + Serial.println(); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_registers/i2c_registers.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_registers/i2c_registers.ino new file mode 100644 index 0000000..2d44c83 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2c_registers/i2c_registers.ino @@ -0,0 +1,43 @@ +#include +#include + +#define I2C_ADDRESS 0x60 +Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(I2C_ADDRESS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("I2C device register test"); + + if (!i2c_dev.begin()) { + Serial.print("Did not find device at 0x"); + Serial.println(i2c_dev.address(), HEX); + while (1) + ; + } + Serial.print("Device found on address 0x"); + Serial.println(i2c_dev.address(), HEX); + + Adafruit_BusIO_Register id_reg = + Adafruit_BusIO_Register(&i2c_dev, 0x0C, 2, LSBFIRST); + uint16_t id; + id_reg.read(&id); + Serial.print("ID register = 0x"); + Serial.println(id, HEX); + + Adafruit_BusIO_Register thresh_reg = + Adafruit_BusIO_Register(&i2c_dev, 0x01, 2, LSBFIRST); + uint16_t thresh; + thresh_reg.read(&thresh); + Serial.print("Initial threshold register = 0x"); + Serial.println(thresh, HEX); + + thresh_reg.write(~thresh); + + Serial.print("Post threshold register = 0x"); + Serial.println(thresh_reg.read(), HEX); +} + +void loop() {} \ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2corspi_register/i2corspi_register.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2corspi_register/i2corspi_register.ino new file mode 100644 index 0000000..be04606 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/i2corspi_register/i2corspi_register.ino @@ -0,0 +1,40 @@ +#include + +// Define which interface to use by setting the unused interface to NULL! + +#define SPIDEVICE_CS 10 +Adafruit_SPIDevice *spi_dev = NULL; // new Adafruit_SPIDevice(SPIDEVICE_CS); + +#define I2C_ADDRESS 0x5D +Adafruit_I2CDevice *i2c_dev = new Adafruit_I2CDevice(I2C_ADDRESS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("I2C or SPI device register test"); + + if (spi_dev && !spi_dev->begin()) { + Serial.println("Could not initialize SPI device"); + } + + if (i2c_dev) { + if (i2c_dev->begin()) { + Serial.print("Device found on I2C address 0x"); + Serial.println(i2c_dev->address(), HEX); + } else { + Serial.print("Did not find I2C device at 0x"); + Serial.println(i2c_dev->address(), HEX); + } + } + + Adafruit_BusIO_Register id_reg = + Adafruit_BusIO_Register(i2c_dev, spi_dev, ADDRBIT8_HIGH_TOREAD, 0x0F); + uint8_t id = 0; + id_reg.read(&id); + Serial.print("ID register = 0x"); + Serial.println(id, HEX); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_modetest/spi_modetest.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_modetest/spi_modetest.ino new file mode 100644 index 0000000..ebf14f9 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_modetest/spi_modetest.ino @@ -0,0 +1,35 @@ +#include + +#define SPIDEVICE_CS 10 +Adafruit_SPIDevice spi_dev = + Adafruit_SPIDevice(SPIDEVICE_CS, 100000, SPI_BITORDER_MSBFIRST, SPI_MODE1); +// Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS, 13, 12, 11, +// 100000, SPI_BITORDER_MSBFIRST, SPI_MODE1); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("SPI device mode test"); + + if (!spi_dev.begin()) { + Serial.println("Could not initialize SPI device"); + while (1) + ; + } +} + +void loop() { + Serial.println("\n\nTransfer test"); + for (uint16_t x = 0; x <= 0xFF; x++) { + uint8_t i = x; + Serial.print("0x"); + Serial.print(i, HEX); + spi_dev.read(&i, 1, i); + Serial.print("/"); + Serial.print(i, HEX); + Serial.print(", "); + delay(25); + } +} \ No newline at end of file diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_readwrite/spi_readwrite.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_readwrite/spi_readwrite.ino new file mode 100644 index 0000000..4b9ecf1 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_readwrite/spi_readwrite.ino @@ -0,0 +1,43 @@ +#include + +#define SPIDEVICE_CS 10 +Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("SPI device read and write test"); + + if (!spi_dev.begin()) { + Serial.println("Could not initialize SPI device"); + while (1) + ; + } + + uint8_t buffer[32]; + + // Try to read 32 bytes + spi_dev.read(buffer, 32); + Serial.print("Read: "); + for (uint8_t i = 0; i < 32; i++) { + Serial.print("0x"); + Serial.print(buffer[i], HEX); + Serial.print(", "); + } + Serial.println(); + + // read a register by writing first, then reading + buffer[0] = 0x8F; // we'll reuse the same buffer + spi_dev.write_then_read(buffer, 1, buffer, 2, false); + Serial.print("Write then Read: "); + for (uint8_t i = 0; i < 2; i++) { + Serial.print("0x"); + Serial.print(buffer[i], HEX); + Serial.print(", "); + } + Serial.println(); +} + +void loop() {} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_register_bits/spi_register_bits.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_register_bits/spi_register_bits.ino new file mode 100644 index 0000000..d11b440 --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_register_bits/spi_register_bits.ino @@ -0,0 +1,268 @@ +/*************************************************** + + This is an example for how to use Adafruit_BusIO_RegisterBits from + Adafruit_BusIO library. + + Designed specifically to work with the Adafruit RTD Sensor + ----> https://www.adafruit.com/products/3328 + uisng a MAX31865 RTD-to-Digital Converter + ----> https://datasheets.maximintegrated.com/en/ds/MAX31865.pdf + + This sensor uses SPI to communicate, 4 pins are required to + interface. + A fifth pin helps to detect when a new conversion is ready. + + Adafruit invests time and resources providing this open source code, + please support Adafruit and open-source hardware by purchasing + products from Adafruit! + + Example written (2020/3) by Andreas Hardtung/AnHard. + BSD license, all text above must be included in any redistribution + ****************************************************/ + +#include +#include + +#define MAX31865_SPI_SPEED (5000000) +#define MAX31865_SPI_BITORDER (SPI_BITORDER_MSBFIRST) +#define MAX31865_SPI_MODE (SPI_MODE1) + +#define MAX31865_SPI_CS (10) +#define MAX31865_READY_PIN (2) + +Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice( + MAX31865_SPI_CS, MAX31865_SPI_SPEED, MAX31865_SPI_BITORDER, + MAX31865_SPI_MODE, &SPI); // Hardware SPI +// Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice( MAX31865_SPI_CS, 13, 12, 11, +// MAX31865_SPI_SPEED, MAX31865_SPI_BITORDER, MAX31865_SPI_MODE); // Software +// SPI + +// MAX31865 chip related +// ********************************************************************************************* +Adafruit_BusIO_Register config_reg = + Adafruit_BusIO_Register(&spi_dev, 0x00, ADDRBIT8_HIGH_TOWRITE, 1, MSBFIRST); +Adafruit_BusIO_RegisterBits bias_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 7); +Adafruit_BusIO_RegisterBits auto_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 6); +Adafruit_BusIO_RegisterBits oneS_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 5); +Adafruit_BusIO_RegisterBits wire_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 4); +Adafruit_BusIO_RegisterBits faultT_bits = + Adafruit_BusIO_RegisterBits(&config_reg, 2, 2); +Adafruit_BusIO_RegisterBits faultR_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 1); +Adafruit_BusIO_RegisterBits fi50hz_bit = + Adafruit_BusIO_RegisterBits(&config_reg, 1, 0); + +Adafruit_BusIO_Register rRatio_reg = + Adafruit_BusIO_Register(&spi_dev, 0x01, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST); +Adafruit_BusIO_RegisterBits rRatio_bits = + Adafruit_BusIO_RegisterBits(&rRatio_reg, 15, 1); +Adafruit_BusIO_RegisterBits fault_bit = + Adafruit_BusIO_RegisterBits(&rRatio_reg, 1, 0); + +Adafruit_BusIO_Register maxRratio_reg = + Adafruit_BusIO_Register(&spi_dev, 0x03, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST); +Adafruit_BusIO_RegisterBits maxRratio_bits = + Adafruit_BusIO_RegisterBits(&maxRratio_reg, 15, 1); + +Adafruit_BusIO_Register minRratio_reg = + Adafruit_BusIO_Register(&spi_dev, 0x05, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST); +Adafruit_BusIO_RegisterBits minRratio_bits = + Adafruit_BusIO_RegisterBits(&minRratio_reg, 15, 1); + +Adafruit_BusIO_Register fault_reg = + Adafruit_BusIO_Register(&spi_dev, 0x07, ADDRBIT8_HIGH_TOWRITE, 1, MSBFIRST); +Adafruit_BusIO_RegisterBits range_high_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 7); +Adafruit_BusIO_RegisterBits range_low_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 6); +Adafruit_BusIO_RegisterBits refin_high_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 5); +Adafruit_BusIO_RegisterBits refin_low_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 4); +Adafruit_BusIO_RegisterBits rtdin_low_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 3); +Adafruit_BusIO_RegisterBits voltage_fault_bit = + Adafruit_BusIO_RegisterBits(&fault_reg, 1, 2); + +// Print the details of the configuration register. +void printConfig(void) { + Serial.print("BIAS: "); + if (bias_bit.read()) + Serial.print("ON"); + else + Serial.print("OFF"); + Serial.print(", AUTO: "); + if (auto_bit.read()) + Serial.print("ON"); + else + Serial.print("OFF"); + Serial.print(", ONES: "); + if (oneS_bit.read()) + Serial.print("ON"); + else + Serial.print("OFF"); + Serial.print(", WIRE: "); + if (wire_bit.read()) + Serial.print("3"); + else + Serial.print("2/4"); + Serial.print(", FAULTCLEAR: "); + if (faultR_bit.read()) + Serial.print("ON"); + else + Serial.print("OFF"); + Serial.print(", "); + if (fi50hz_bit.read()) + Serial.print("50HZ"); + else + Serial.print("60HZ"); + Serial.println(); +} + +// Check and print faults. Then clear them. +void checkFaults(void) { + if (fault_bit.read()) { + Serial.print("MAX: "); + Serial.println(maxRratio_bits.read()); + Serial.print("VAL: "); + Serial.println(rRatio_bits.read()); + Serial.print("MIN: "); + Serial.println(minRratio_bits.read()); + + if (range_high_fault_bit.read()) + Serial.println("Range high fault"); + if (range_low_fault_bit.read()) + Serial.println("Range low fault"); + if (refin_high_fault_bit.read()) + Serial.println("REFIN high fault"); + if (refin_low_fault_bit.read()) + Serial.println("REFIN low fault"); + if (rtdin_low_fault_bit.read()) + Serial.println("RTDIN low fault"); + if (voltage_fault_bit.read()) + Serial.println("Voltage fault"); + + faultR_bit.write(1); // clear fault + } +} + +void setup() { +#if (MAX31865_1_READY_PIN != -1) + pinMode(MAX31865_READY_PIN, INPUT_PULLUP); +#endif + + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("SPI Adafruit_BusIO_RegisterBits test on MAX31865"); + + if (!spi_dev.begin()) { + Serial.println("Could not initialize SPI device"); + while (1) + ; + } + + // Set up for automode 50Hz. We don't care about selfheating. We want the + // highest possible sampling rate. + auto_bit.write(0); // Don't switch filtermode while auto_mode is on. + fi50hz_bit.write(1); // Set filter to 50Hz mode. + faultR_bit.write(1); // Clear faults. + bias_bit.write(1); // In automode we want to have the bias current always on. + delay(5); // Wait until bias current settles down. + // 10.5 time constants of the input RC network is required. + // 10ms worst case for 10kω reference resistor and a 0.1µF capacitor + // across the RTD inputs. Adafruit Module has 0.1µF and only + // 430/4300ω So here 0.43/4.3ms + auto_bit.write( + 1); // Now we can set automode. Automatically starting first conversion. + +// Test the READY_PIN +#if (defined(MAX31865_READY_PIN) && (MAX31865_READY_PIN != -1)) + int i = 0; + while (digitalRead(MAX31865_READY_PIN) && i++ <= 100) { + delay(1); + } + if (i >= 100) { + Serial.print("ERROR: Max31865 Pin detection does not work. PIN:"); + Serial.println(MAX31865_READY_PIN); + } +#else + delay(100); +#endif + + // Set ratio range. + // Setting the temperatures would need some more calculation - not related to + // Adafruit_BusIO_RegisterBits. + uint16_t ratio = rRatio_bits.read(); + maxRratio_bits.write((ratio < 0x8fffu - 1000u) ? ratio + 1000u : 0x8fffu); + minRratio_bits.write((ratio > 1000u) ? ratio - 1000u : 0u); + + printConfig(); + checkFaults(); +} + +void loop() { +#if (defined(MAX31865_READY_PIN) && (MAX31865_1_READY_PIN != -1)) + // Is conversion ready? + if (!digitalRead(MAX31865_READY_PIN)) +#else + // Warant conversion is ready. + delay(21); // 21ms for 50Hz-mode. 19ms in 60Hz-mode. +#endif + { + // Read ratio, calculate temperature, scale, filter and print. + Serial.println(rRatio2C(rRatio_bits.read()) * 100.0f, + 0); // Temperature scaled by 100 + // Check, print, clear faults. + checkFaults(); + } + + // Do something else. + // delay(15000); +} + +// Module/Sensor related. Here Adafruit PT100 module with a 2_Wire PT100 Class C +// ***************************** +float rRatio2C(uint16_t ratio) { + // A simple linear conversion. + const float R0 = 100.0f; + const float Rref = 430.0f; + const float alphaPT = 0.003850f; + const float ADCmax = (1u << 15) - 1.0f; + const float rscale = Rref / ADCmax; + // Measured temperature in boiling water 101.08°C with factor a = 1 and b = 0. + // Rref and MAX at about 22±2°C. Measured temperature in ice/water bath 0.76°C + // with factor a = 1 and b = 0. Rref and MAX at about 22±2°C. + // const float a = 1.0f / (alphaPT * R0); + const float a = (100.0f / 101.08f) / (alphaPT * R0); + // const float b = 0.0f; // 101.08 + const float b = -0.76f; // 100.32 > 101.08 + + return filterRing(((ratio * rscale) - R0) * a + b); +} + +// General purpose +// ********************************************************************************************* +#define RINGLENGTH 250 +float filterRing(float newVal) { + static float ring[RINGLENGTH] = {0.0}; + static uint8_t ringIndex = 0; + static bool ringFull = false; + + if (ringIndex == RINGLENGTH) { + ringFull = true; + ringIndex = 0; + } + ring[ringIndex] = newVal; + uint8_t loopEnd = (ringFull) ? RINGLENGTH : ringIndex + 1; + float ringSum = 0.0f; + for (uint8_t i = 0; i < loopEnd; i++) + ringSum += ring[i]; + ringIndex++; + return ringSum / loopEnd; +} diff --git a/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_registers/spi_registers.ino b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_registers/spi_registers.ino new file mode 100644 index 0000000..af6069b --- /dev/null +++ b/.pio/libdeps/esp32-s3-n16r8/Adafruit BusIO/examples/spi_registers/spi_registers.ino @@ -0,0 +1,40 @@ +#include +#include + +#define SPIDEVICE_CS 10 +Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS); + +void setup() { + while (!Serial) { + delay(10); + } + Serial.begin(115200); + Serial.println("SPI device register test"); + + if (!spi_dev.begin()) { + Serial.println("Could not initialize SPI device"); + while (1) + ; + } + + Adafruit_BusIO_Register id_reg = + Adafruit_BusIO_Register(&spi_dev, 0x0F, ADDRBIT8_HIGH_TOREAD); + uint8_t id = 0; + id_reg.read(&id); + Serial.print("ID register = 0x"); + Serial.println(id, HEX); + + Adafruit_BusIO_Register thresh_reg = Adafruit_BusIO_Register( + &spi_dev, 0x0C, ADDRBIT8_HIGH_TOREAD, 2, LSBFIRST); + uint16_t thresh = 0; + thresh_reg.read(&thresh); + Serial.print("Initial threshold register = 0x"); + Serial.println(thresh, HEX); + + thresh_reg.write(~thresh); + + Serial.print("Post threshold register = 0x"); + Serial.println(thresh_reg.read(), HEX); +} + +void loop() {} -- cgit v1.2.3