main.cpp

// ===========================================================================
// MiniLoopDeck - Lo-Fi sample looper for the M5Stack Core2
// ===========================================================================
//
//  Controls
//  --------
//    BtnA (left dot)   : REC / STOP   - record into the selected track
//    BtnB (mid dot)    : PLAY / STOP  - loop all tracks mixed together
//    BtnC (right dot)  : FX>          - cycle the effect of the selected track
//
//    Tap a track tile  : select it (tap again to MUTE / un-mute)
//    Hold a track tile : clear that track
//
//  Effects (per track): DRY, REVERSE, CRUSH, LOFI, DRIVE, ECHO
//
//  Remember: mic and speaker share one I2S bus, so recording and playback
//  never happen at the same time (no live overdub).
// ===========================================================================

#include <M5Unified.h>
#include "Config.h"
#include "AudioEngine.h"
#include "NetAudio.h"
#include "Ui.h"

static constexpr int VOL_STEP = 15;

static void changeVolume(int delta) {
  int v = (int)Engine.volume() + delta;
  if (v < 0)   v = 0;
  if (v > 255) v = 255;
  Engine.setVolume((uint8_t)v);
  UI.markDirty();
}

// The three transport actions, shared by the hardware dots and the on-screen
// touch buttons. They are context-sensitive (deck vs. settings screen).
static void actionA() {                       // REC / STOP  |  VOL-
  if (UI.screen() == SCREEN_SETTINGS) { changeVolume(-VOL_STEP); return; }
  if (Engine.state() == STATE_RECORDING) {
    // A remote (StickS3) take is controlled by KEY1, not this button.
    if (Engine.micSource() == MIC_REMOTE) return;
    Engine.stopRecording();
  } else {
    Engine.startRecording(UI.selected());
  }
  UI.markDirty();
}

static void actionB() {                       // PLAY / STOP |  BACK
  if (UI.screen() == SCREEN_SETTINGS) { UI.closeSettings(); return; }
  if (Engine.state() == STATE_PLAYING)   Engine.stopPlayback();
  else if (Engine.state() == STATE_IDLE) Engine.startPlayback();
  UI.markDirty();
}

static void actionC() {                       // FX>         |  VOL+
  if (UI.screen() == SCREEN_SETTINGS) { changeVolume(+VOL_STEP); return; }
  Engine.cycleFx(UI.selected());
  UI.markDirty();
}

static void handleButtons() {
  if (M5.BtnA.wasClicked()) actionA();
  if (M5.BtnB.wasClicked()) actionB();
  if (M5.BtnC.wasClicked()) actionC();
}

static void handleTouch() {
  // Gear button toggles the settings screen from anywhere.
  if (UI.gearTapped()) {
    if (UI.screen() == SCREEN_DECK) UI.openSettings();
    else                            UI.closeSettings();
    return;
  }

  // In-tile MERGE button: arm that track as the merge target (or cancel).
  int mt = UI.pollMergeButton();
  if (mt >= 0) {
    if (UI.mergeArmed() && mt == UI.selected()) UI.setMergeArmed(false);
    else { UI.select((uint8_t)mt); UI.setMergeArmed(true); }
    return;
  }

  // On-screen transport buttons mirror the hardware dots.
  int btn = UI.pollBottom();
  if (btn == 0) { actionA(); return; }
  if (btn == 1) { actionB(); return; }
  if (btn == 2) { actionC(); return; }

  if (UI.screen() == SCREEN_SETTINGS) {
    switch (UI.pollSettings()) {
      case SA_VOL_DOWN: changeVolume(-VOL_STEP); break;
      case SA_VOL_UP:   changeVolume(+VOL_STEP); break;
      case SA_BACK:     UI.closeSettings();      break;
      default: break;
    }
    return;
  }

  int hold = UI.pollHold();
  if (hold >= 0) {
    Engine.clearTrack((uint8_t)hold);
    UI.markDirty();
    return;
  }

  int tap = UI.pollTap();
  if (tap >= 0) {
    if (UI.mergeArmed()) {
      // Tapping another track merges it into the selected one; tapping the
      // selected track (or an empty one) just cancels merge mode.
      if (tap != UI.selected()) Engine.mergeTracks(UI.selected(), (uint8_t)tap);
      UI.setMergeArmed(false);
    } else if (tap == UI.selected()) {
      Engine.toggleMute((uint8_t)tap);                          // 2nd tap = mute
    } else {
      UI.select((uint8_t)tap);
    }
    UI.markDirty();
  }
}

void setup() {
  auto cfg = M5.config();
  cfg.internal_mic = true;
  cfg.internal_spk = true;
  M5.begin(cfg);

  M5.Display.setBrightness(120);

  if (!Engine.begin()) {
    M5.Display.fillScreen(TFT_RED);
    M5.Display.setTextColor(TFT_WHITE);
    M5.Display.setTextSize(2);
    M5.Display.setCursor(10, 100);
    M5.Display.print("PSRAM alloc failed");
    while (true) { M5.delay(1000); }
  }

  Net.begin();   // ESP-NOW receiver for the StickS3 wireless mic (best effort)

  UI.begin();
  UI.draw();
}

// Drive the remote (StickS3) overdub lifecycle from the network state.
static void handleRemote() {
  const bool rec = Net.remoteRecActive();
  const DeckState st = Engine.state();

  if (rec) {
    if (st != STATE_RECORDING) {        // begin overdub from idle or playback
      Engine.startRemoteRecording(UI.selected());
      UI.markDirty();
    }
    if (Engine.micSource() == MIC_REMOTE) Engine.serviceRemoteRecording(Net);
  } else if (st == STATE_RECORDING && Engine.micSource() == MIC_REMOTE) {
    Engine.stopRemoteRecording();       // KEY1 released / stream timed out
    UI.markDirty();
  }
}

void loop() {
  M5.update();

  handleButtons();
  handleTouch();
  handleRemote();

  if (Engine.state() == STATE_RECORDING && Engine.micSource() == MIC_INTERNAL) {
    Engine.serviceRecording();
  }

  static uint32_t lastStatus = 0;
  if (millis() - lastStatus > 300) {
    Net.sendStatus((uint8_t)Engine.state(), UI.selected(),
                   Engine.micSource() == MIC_REMOTE &&
                       Engine.state() == STATE_RECORDING);
    lastStatus = millis();
  }

  UI.draw();                          // only redraws when dirty

  static uint32_t lastBar = 0;
  if (Engine.state() != STATE_IDLE && millis() - lastBar > 60) {
    UI.drawProgress();                // animate the progress bar
    lastBar = millis();
  }

  static uint32_t lastBeat = 0;
  if (Engine.state() == STATE_RECORDING && millis() - lastBeat > 25) {
    UI.drawMetronome();               // flash the beat grid while recording
    lastBeat = millis();
  }

  static uint32_t lastBatt = 0;
  if (millis() - lastBatt > 10000) {  // refresh battery gauge every 10 s
    UI.refreshBattery();
    lastBatt = millis();
  }

  static uint32_t lastLink = 0;
  if (millis() - lastLink > 1000) {   // refresh RF link indicator every 1 s
    UI.refreshLink();
    lastLink = millis();
  }

  M5.delay(2);
}