ZephyrDriverCommon.h

Go to the documentation of this file.

#pragma once
 
#include <assert.h>
#include <stdint.h>
 
#include "DriverCommon.h"
#include "Platforms/API_Delay.h"
#include "Platforms/API_I2C.h"
 
namespace audio_driver {
 
class ZephyrDriverCommon {
 public:
 
  void setAddress(uint8_t addr) { i2c_addr = addr; }
 
  uint8_t address() { return i2c_addr; }
 
  void setWire(i2c_bus_handle_t w) { wire = w; }
 
  i2c_bus_handle_t getWire() { return wire; }
 
  virtual bool begin(uint32_t sample_rate, uint8_t bits, codec_mode_t mode,
                      i2s_format_t fmt, bool is_master, uint8_t channels) = 0;
 
  virtual bool setVolume(int volume) {
    volume_percent = volume;
    return true;
  }
 
  virtual int getVolume() { return volume_percent; }
 
  virtual bool setMute(bool mute) {
    (void)mute;
    return false;
  }
 
  virtual bool setActive(codec_mode_t mode) {
    return setMute(!(mode & CODEC_MODE_DECODE));
  }
 
  virtual bool setInputVolume(int volume) { return false;}
 
  virtual int getInputVolume() { return input_volume_percent; }
 
  virtual bool isInputVolumeSupported() { return false;}
 
  virtual bool setDevices(input_device_t input_device, output_device_t output_device){ return true;}
 
 protected:
  i2c_bus_handle_t wire = nullptr;
  uint8_t i2c_addr = 0;
  int volume_percent = 100;
  int input_volume_percent = 100;
 
  bool writeReg(uint8_t reg, uint8_t value) {
    assert(wire != nullptr);
    return i2c_bus_write_bytes(wire, i2c_addr, &reg, 1, &value, 1) == 0;
  }
 
  bool readReg(uint8_t reg, uint8_t& value, bool stopBit=true) {
    assert(wire != nullptr);
  #if defined(ARDUINO) && !AUDIO_DRIVER_FORCE_IDF
    return i2c_bus_read_bytes(wire, i2c_addr, &reg, 1, &value, 1, stopBit) == 0;
  #else
    return i2c_bus_read_bytes(wire, i2c_addr, &reg, 1, &value, 1) == 0;
  #endif // defined(ARDUINO) && !AUDIO_DRIVER_FORCE_IDF
  }
 
  bool updateReg(uint8_t reg, uint8_t mask, uint8_t value) {
    uint8_t old = 0;
    if (!readReg(reg, old)) return false;
    uint8_t updated = (old & ~mask) | (value & mask);
    if (updated == old) return true;
    return writeReg(reg, updated);
  }
 
  bool writeReg16(uint8_t reg, uint16_t value) {
    assert(wire != nullptr);
    uint8_t data[2] = {(uint8_t)(value >> 8), (uint8_t)(value & 0xFF)};
    return i2c_bus_write_bytes(wire, i2c_addr, &reg, 1, data, 2) == 0;
  }
 
  bool readReg16(uint8_t reg, uint16_t& value) {
    assert(wire != nullptr);
    uint8_t data[2] = {0, 0};
    if (i2c_bus_read_bytes(wire, i2c_addr, &reg, 1, data, 2) != 0)
      return false;
    value = ((uint16_t)data[0] << 8) | data[1];
    return true;
  }
 
  bool updateReg16(uint8_t reg, uint16_t mask, uint16_t value) {
    uint16_t old = 0;
    if (!readReg16(reg, old)) return false;
    uint16_t updated = (old & ~mask) | (value & mask);
    if (updated == old) return true;
    return writeReg16(reg, updated);
  }
 
};
 
}  // namespace audio_driver