Remove thin wrapper functions, use BusIO directly

Author: clawpi

Adafruit_AS7331.cpp

@@ -243,29 +243,26 @@ as7331_clock_t Adafruit_AS7331::getClockFrequency(void) {
  * @return UVA measurement counts
  */
 uint16_t Adafruit_AS7331::readUVA(void) {
-  uint16_t value = 0;
-  readRegister(AS7331_REG_MRES1, &value);
-  return value;
+  Adafruit_BusIO_Register mres1(_i2c_dev, AS7331_REG_MRES1, 2, LSBFIRST);
+  return mres1.read();
 }
 
 /**
  * @brief Read the UVB channel counts
  * @return UVB measurement counts
  */
 uint16_t Adafruit_AS7331::readUVB(void) {
-  uint16_t value = 0;
-  readRegister(AS7331_REG_MRES2, &value);
-  return value;
+  Adafruit_BusIO_Register mres2(_i2c_dev, AS7331_REG_MRES2, 2, LSBFIRST);
+  return mres2.read();
 }
 
 /**
  * @brief Read the UVC channel counts
  * @return UVC measurement counts
  */
 uint16_t Adafruit_AS7331::readUVC(void) {
-  uint16_t value = 0;
-  readRegister(AS7331_REG_MRES3, &value);
-  return value;
+  Adafruit_BusIO_Register mres3(_i2c_dev, AS7331_REG_MRES3, 2, LSBFIRST);
+  return mres3.read();
 }
 
 /**
@@ -277,7 +274,8 @@ uint16_t Adafruit_AS7331::readUVC(void) {
  */
 bool Adafruit_AS7331::readAllUV(uint16_t *uva, uint16_t *uvb, uint16_t *uvc) {
   uint8_t buffer[6] = {0};
-  if (!readRegisters(AS7331_REG_MRES1, buffer, sizeof(buffer))) {
+  uint8_t reg = AS7331_REG_MRES1;
+  if (!_i2c_dev->write_then_read(&reg, 1, buffer, sizeof(buffer))) {
     return false;
   }
 
@@ -445,9 +443,8 @@ bool Adafruit_AS7331::oneShot_uWcm2(float *uva, float *uvb, float *uvc) {
  * @return Temperature in degrees Celsius
  */
 float Adafruit_AS7331::readTemperature(void) {
-  uint16_t raw = 0;
-  readRegister(AS7331_REG_TEMP, &raw);
-  raw &= 0x0FFF;
+  Adafruit_BusIO_Register temp_reg(_i2c_dev, AS7331_REG_TEMP, 2, LSBFIRST);
+  uint16_t raw = temp_reg.read() & 0x0FFF;
   return (raw * 0.05f) - 66.9f;
 }
 
@@ -456,23 +453,19 @@ float Adafruit_AS7331::readTemperature(void) {
  * @return true if data is ready, false otherwise
  */
 bool Adafruit_AS7331::isDataReady(void) {
-  uint16_t status = 0;
-  if (!readRegister(AS7331_REG_OSR, &status)) {
-    return false;
-  }
-
-  bool not_ready = (status >> 10) & 0x1;
-  return !not_ready;
+  Adafruit_BusIO_Register osr(_i2c_dev, AS7331_REG_OSR, 2, LSBFIRST);
+  Adafruit_BusIO_RegisterBits nready(&osr, 1, 10);
+  return !nready.read();
 }
 
 /**
  * @brief Read the status register byte
  * @return Status register value
  */
 uint8_t Adafruit_AS7331::getStatus(void) {
-  uint16_t val = 0;
-  readRegister(AS7331_REG_OSR, &val);
-  return (val >> 8) & 0xFF; // STATUS is high byte
+  Adafruit_BusIO_Register osr(_i2c_dev, AS7331_REG_OSR, 2, LSBFIRST);
+  Adafruit_BusIO_RegisterBits status_bits(&osr, 8, 8);
+  return status_bits.read();
 }
 
 /**
@@ -641,37 +634,3 @@ bool Adafruit_AS7331::getStandby(void) {
   Adafruit_BusIO_RegisterBits sb(&creg3, 1, 4);
   return sb.read();
 }
-
-/**
- * @brief Read an 8-bit register
- * @param reg Register address
- * @param value Pointer to storage for the read value
- * @return true if the operation succeeded, false otherwise
- */
-bool Adafruit_AS7331::readRegister(uint8_t reg, uint8_t *value) {
-  Adafruit_BusIO_Register bus_reg(_i2c_dev, reg);
-  return bus_reg.read(value);
-}
-
-/**
- * @brief Read a 16-bit register
- * @param reg Register address
- * @param value Pointer to storage for the read value
- * @return true if the operation succeeded, false otherwise
- */
-bool Adafruit_AS7331::readRegister(uint8_t reg, uint16_t *value) {
-  Adafruit_BusIO_Register bus_reg(_i2c_dev, reg, 2, LSBFIRST);
-  return bus_reg.read(value);
-}
-
-/**
- * @brief Read multiple bytes starting at a register address
- * @param reg Starting register address
- * @param buffer Buffer to fill with data
- * @param len Number of bytes to read
- * @return true if the operation succeeded, false otherwise
- */
-bool Adafruit_AS7331::readRegisters(uint8_t reg, uint8_t *buffer, uint8_t len) {
-  Adafruit_BusIO_Register bus_reg(_i2c_dev, reg, len, LSBFIRST);
-  return bus_reg.read(buffer, len);
-}

Adafruit_AS7331.h

@@ -160,10 +160,6 @@ class Adafruit_AS7331 {
   bool getStandby(void);
 
 private:
-  bool readRegister(uint8_t reg, uint8_t *value);
-  bool readRegister(uint8_t reg, uint16_t *value);
-  bool readRegisters(uint8_t reg, uint8_t *buffer, uint8_t len);
-
   float _countsToIrradiance(uint16_t counts, float baseSensitivity);
 
   Adafruit_I2CDevice *_i2c_dev = nullptr; ///< Pointer to I2C device

hw_tests/pwm_demo/pwm_demo.ino

@@ -0,0 +1,160 @@
+/**
+ * PWM Demo for Metro Mini Oscilloscope Testing
+ * 
+ * Generates three different PWM frequencies using direct timer register manipulation:
+ *   - Timer2: ~245 Hz on pins 3 and 11
+ *   - Timer1: 1000 Hz on pins 9 and 10
+ *   - Timer0: 5000 Hz on pins 5 and 6
+ * 
+ * Each frequency pair has:
+ *   - One pin with fixed 50% duty cycle (square wave reference)
+ *   - One pin with sweeping duty cycle (0% → 100% → 0% over ~5 seconds)
+ * 
+ * WARNING: Timer0 modification breaks millis()/delay() - uses _delay_ms() instead
+ * 
+ * Hardware: Metro Mini (ATmega328P @ 16 MHz)
+ */
+
+#include <util/delay.h>
+
+// Pin assignments (fixed by ATmega328P hardware)
+#define PIN_245HZ_FIXED    11  // OC2A - 50% duty
+#define PIN_245HZ_SWEEP    3   // OC2B - sweeping duty
+#define PIN_1KHZ_FIXED     9   // OC1A - 50% duty  
+#define PIN_1KHZ_SWEEP     10  // OC1B - sweeping duty
+#define PIN_5KHZ_FIXED     6   // OC0A - 50% duty (toggle mode)
+#define PIN_5KHZ_SWEEP     5   // OC0B - sweeping duty
+
+// Timer1 TOP value for 1000 Hz (16-bit timer allows exact frequency)
+// f = f_clk / (2 * N * TOP) for Phase Correct PWM
+// 1000 = 16000000 / (2 * 1 * 8000)
+#define TIMER1_TOP 8000
+
+// Timer0 TOP value for 5000 Hz
+// f = f_clk / (2 * N * TOP) for Phase Correct PWM
+// 5000 = 16000000 / (2 * 8 * 200)
+#define TIMER0_TOP 200
+
+// Sweep timing
+#define SWEEP_STEPS 100        // Steps in one direction
+#define SWEEP_DELAY_MS 25      // Delay per step (~5 sec full cycle)
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) { ; }
+  
+  Serial.println(F("\n=== PWM Demo for Oscilloscope Testing ==="));
+  Serial.println(F("Metro Mini (ATmega328P @ 16 MHz)\n"));
+  
+  // Configure all PWM pins as outputs
+  pinMode(PIN_245HZ_FIXED, OUTPUT);
+  pinMode(PIN_245HZ_SWEEP, OUTPUT);
+  pinMode(PIN_1KHZ_FIXED, OUTPUT);
+  pinMode(PIN_1KHZ_SWEEP, OUTPUT);
+  pinMode(PIN_5KHZ_FIXED, OUTPUT);
+  pinMode(PIN_5KHZ_SWEEP, OUTPUT);
+  
+  // ========================================
+  // Timer2: ~245 Hz (pins 3, 11)
+  // Phase Correct PWM, prescaler 128
+  // f = 16MHz / (128 * 510) = 245.1 Hz
+  // ========================================
+  TCCR2A = (1 << COM2A1) |   // Clear OC2A on up-count match, set on down-count
+           (1 << COM2B1) |   // Clear OC2B on up-count match, set on down-count
+           (1 << WGM20);     // Phase Correct PWM, TOP = 0xFF
+  TCCR2B = (1 << CS22) |     // Prescaler = 128 (CS22:CS20 = 101)
+           (0 << CS21) |
+           (1 << CS20);
+  OCR2A = 127;               // Pin 11: 50% duty (127/255)
+  OCR2B = 0;                 // Pin 3: start at 0%
+  
+  float freq2 = 16000000.0 / (128.0 * 510.0);
+  Serial.println(F("Timer2 (~245 Hz):"));
+  Serial.print(F("  Pin 11 (OC2A): 50% fixed   - "));
+  Serial.print(freq2, 1);
+  Serial.println(F(" Hz"));
+  Serial.print(F("  Pin 3  (OC2B): sweeping    - "));
+  Serial.print(freq2, 1);
+  Serial.println(F(" Hz\n"));
+  
+  // ========================================
+  // Timer1: 1000 Hz exact (pins 9, 10)
+  // Phase & Freq Correct PWM, ICR1 = TOP
+  // f = 16MHz / (2 * 1 * 8000) = 1000 Hz
+  // ========================================
+  TCCR1A = (1 << COM1A1) |   // Clear OC1A on up-count match, set on down-count
+           (1 << COM1B1);    // Clear OC1B on up-count match, set on down-count
+  TCCR1B = (1 << WGM13) |    // Phase & Freq Correct PWM, TOP = ICR1
+           (1 << CS10);      // Prescaler = 1
+  ICR1 = TIMER1_TOP;         // TOP = 8000 for 1000 Hz
+  OCR1A = TIMER1_TOP / 2;    // Pin 9: 50% duty (4000/8000)
+  OCR1B = 0;                 // Pin 10: start at 0%
+  
+  uint32_t freq1 = 16000000UL / (2UL * 1UL * TIMER1_TOP);
+  Serial.println(F("Timer1 (1000 Hz):"));
+  Serial.print(F("  Pin 9  (OC1A): 50% fixed   - "));
+  Serial.print(freq1);
+  Serial.println(F(" Hz"));
+  Serial.print(F("  Pin 10 (OC1B): sweeping    - "));
+  Serial.print(freq1);
+  Serial.println(F(" Hz\n"));
+  
+  // ========================================
+  // Timer0: 5000 Hz (pins 5, 6)
+  // Phase Correct PWM with OCRA as TOP
+  // f = 16MHz / (2 * 8 * 200) = 5000 Hz
+  // WARNING: This breaks millis()/delay()!
+  // ========================================
+  TCCR0A = (1 << COM0A0) |   // Toggle OC0A on compare match (50% square wave)
+           (1 << COM0B1) |   // Clear OC0B on up-count match, set on down-count
+           (1 << WGM00);     // Phase Correct PWM (WGM = 101 with WGM02)
+  TCCR0B = (1 << WGM02) |    // Phase Correct PWM, TOP = OCRA
+           (1 << CS01);      // Prescaler = 8
+  OCR0A = TIMER0_TOP;        // TOP = 200, Pin 6 toggles = 50% square wave
+  OCR0B = 0;                 // Pin 5: start at 0%
+  
+  uint32_t freq0 = 16000000UL / (2UL * 8UL * TIMER0_TOP);
+  Serial.println(F("Timer0 (5000 Hz):"));
+  Serial.print(F("  Pin 6  (OC0A): 50% fixed   - "));
+  Serial.print(freq0);
+  Serial.println(F(" Hz"));
+  Serial.print(F("  Pin 5  (OC0B): sweeping    - "));
+  Serial.print(freq0);
+  Serial.println(F(" Hz\n"));
+  
+  Serial.println(F("WARNING: millis()/delay() broken (Timer0 modified)"));
+  Serial.println(F("Using _delay_ms() for timing.\n"));
+  Serial.println(F("Sweep cycle: ~5 seconds (0% -> 100% -> 0%)"));
+  Serial.println(F("Probe pins with oscilloscope to see waveforms!"));
+  Serial.println(F("==========================================\n"));
+}
+
+void loop() {
+  // Sweep duty cycle up: 0% -> 100%
+  for (uint8_t i = 0; i <= SWEEP_STEPS; i++) {
+    // Timer2 sweep (8-bit, max 255)
+    OCR2B = (uint8_t)(((uint32_t)i * 255) / SWEEP_STEPS);
+    
+    // Timer1 sweep (16-bit, max = TIMER1_TOP)
+    OCR1B = (uint16_t)(((uint32_t)i * TIMER1_TOP) / SWEEP_STEPS);
+    
+    // Timer0 sweep (8-bit, max = TIMER0_TOP)
+    OCR0B = (uint8_t)(((uint32_t)i * TIMER0_TOP) / SWEEP_STEPS);
+    
+    _delay_ms(SWEEP_DELAY_MS);
+  }
+  
+  // Sweep duty cycle down: 100% -> 0%
+  for (uint8_t i = SWEEP_STEPS; i > 0; i--) {
+    // Timer2 sweep
+    OCR2B = (uint8_t)(((uint32_t)i * 255) / SWEEP_STEPS);
+    
+    // Timer1 sweep
+    OCR1B = (uint16_t)(((uint32_t)i * TIMER1_TOP) / SWEEP_STEPS);
+    
+    // Timer0 sweep
+    OCR0B = (uint8_t)(((uint32_t)i * TIMER0_TOP) / SWEEP_STEPS);
+    
+    _delay_ms(SWEEP_DELAY_MS);
+  }
+}