Wireless Volume Amplifier

#include <Arduino.h>
#include <WiFi.h>
#include <esp_now.h>
#include <Wire.h>

// This one sketch is deployed to both ESP32 DevKit v1 boards.
// GPIO33 high = AUX receiver; GPIO33 low = battery-powered knob remote.
static const uint8_t MODE_PIN = 33;
static const uint8_t I2C_SDA_PIN = 21;
static const uint8_t I2C_SCL_PIN = 22;
static const uint8_t ENCODER_CLK_PIN = 25;
static const uint8_t ENCODER_DT_PIN = 26;
static const uint8_t ENCODER_SW_PIN = 27;

static const uint8_t PT2258_ADDRESS = 0x44; // 7-bit form of the usual 0x88 address.
static const uint8_t BROADCAST_ADDRESS[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
static const uint32_t PACKET_MAGIC = 0x564F4C31; // "VOL1"

enum Command : uint8_t { COMMAND_STEP = 1, COMMAND_TOGGLE_MUTE = 2 };

struct VolumePacket {
  uint32_t magic;
  uint8_t command;
  int8_t step;
  uint16_t sequence;
};

bool isReceiver = false;
uint8_t attenuation = 24; // 12 dB below full line level at startup.
bool muted = false;
int lastEncoderClock = HIGH;
bool lastButton = HIGH;
uint32_t lastEncoderChangeMs = 0;
uint32_t lastButtonChangeMs = 0;
uint16_t sequenceNumber = 0;

void writePt2258(uint8_t amount) {
  // PT2258 master attenuation command: 0 = loudest, 63 = quietest.
  Wire.beginTransmission(PT2258_ADDRESS);
  Wire.write((uint8_t)(0xC0 | (amount & 0x3F)));
  Wire.endTransmission();
}

void applyVolume() {
  writePt2258(muted ? 63 : attenuation);
}

void handleCommand(const VolumePacket &packet) {
  if (packet.magic != PACKET_MAGIC) {
    return;
  }

  if (packet.command == COMMAND_STEP) {
    int next = (int)attenuation - (int)packet.step;
    attenuation = (uint8_t)constrain(next, 0, 63);
    muted = false;
    applyVolume();
  } else if (packet.command == COMMAND_TOGGLE_MUTE) {
    muted = !muted;
    applyVolume();
  }
}

#if ESP_ARDUINO_VERSION_MAJOR >= 3
void onEspNowReceive(const esp_now_recv_info_t *info, const uint8_t *data, int dataLength) {
  (void)info;
  if (dataLength == (int)sizeof(VolumePacket)) {
    VolumePacket packet;
    memcpy(&packet, data, sizeof(packet));
    handleCommand(packet);
  }
}
#else
void onEspNowReceive(const uint8_t *mac, const uint8_t *data, int dataLength) {
  (void)mac;
  if (dataLength == (int)sizeof(VolumePacket)) {
    VolumePacket packet;
    memcpy(&packet, data, sizeof(packet));
    handleCommand(packet);
  }
}
#endif

bool startEspNow() {
  WiFi.mode(WIFI_STA);
  if (esp_now_init() != ESP_OK) {
    return false;
  }

  if (isReceiver) {
    esp_now_register_recv_cb(onEspNowReceive);
  } else {
    esp_now_peer_info_t peer = {};
    memcpy(peer.peer_addr, BROADCAST_ADDRESS, sizeof(BROADCAST_ADDRESS));
    peer.channel = 0;
    peer.encrypt = false;
    if (!esp_now_is_peer_exist(BROADCAST_ADDRESS) && esp_now_add_peer(&peer) != ESP_OK) {
      return false;
    }
  }
  return true;
}

void sendCommand(Command command, int8_t step = 0) {
  VolumePacket packet = {PACKET_MAGIC, (uint8_t)command, step, sequenceNumber++};
  esp_now_send(BROADCAST_ADDRESS, (const uint8_t *)&packet, sizeof(packet));
}

void setupReceiver() {
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  applyVolume();
  startEspNow();
}

void setupRemote() {
  pinMode(ENCODER_CLK_PIN, INPUT_PULLUP);
  pinMode(ENCODER_DT_PIN, INPUT_PULLUP);
  pinMode(ENCODER_SW_PIN, INPUT_PULLUP);
  lastEncoderClock = digitalRead(ENCODER_CLK_PIN);
  lastButton = digitalRead(ENCODER_SW_PIN);
  startEspNow();
}

void setup() {
  pinMode(MODE_PIN, INPUT);
  delay(10);
  isReceiver = digitalRead(MODE_PIN) == HIGH;
  if (isReceiver) {
    setupReceiver();
  } else {
    setupRemote();
  }
}

void serviceRemote() {
  const uint32_t now = millis();
  int clockNow = digitalRead(ENCODER_CLK_PIN);
  if (clockNow != lastEncoderClock && clockNow == LOW && now - lastEncoderChangeMs >= 3) {
    int8_t step = digitalRead(ENCODER_DT_PIN) == HIGH ? 1 : -1;
    sendCommand(COMMAND_STEP, step);
    lastEncoderChangeMs = now;
  }
  lastEncoderClock = clockNow;

  bool buttonNow = digitalRead(ENCODER_SW_PIN);
  if (lastButton == HIGH && buttonNow == LOW && now - lastButtonChangeMs >= 30) {
    sendCommand(COMMAND_TOGGLE_MUTE);
    lastButtonChangeMs = now;
  }
  lastButton = buttonNow;
}

void loop() {
  if (!isReceiver) {
    serviceRemote();
  }
  delay(2);
}