// NeoPixel Ring#include 

#define PIN_NEO   D10
#define NUM_LEDS  16
#define PIN_COLOR D0
#define PIN_VEL   D1

Adafruit_NeoPixel strip(NUM_LEDS, PIN_NEO, NEO_GRB + NEO_KHZ800);
// NEO_GRB = color order of WS2812B chip; NEO_KHZ800 = 800 kHz data signal

uint16_t hueBase = 0;
// Increases every loop to create the spinning animation; wraps 65535→0 automatically

void setup() {
  analogReadResolution(12);
  // RP2350 has a native 12-bit ADC → values 0–4095 instead of the usual 0–1023

  strip.begin();
  strip.setBrightness(60);
  // ~24% brightness (60/255) — keeps current consumption safe for USB power
  strip.clear();
  strip.show();
}

void loop() {
  uint32_t rawColor  = analogRead(PIN_COLOR);
  uint16_t colorBase = (uint16_t)((rawColor * 65535UL) / 4095);
  // Scales 0–4095 to 0–65535 to cover the full HSV hue wheel
  // UL suffix (unsigned long) prevents integer overflow during multiplication

  uint32_t rawVel = analogRead(PIN_VEL);
  int speed = map(rawVel, 0, 4095, 3, 60);
  // Low pot → 3 ms delay (fast spin) | High pot → 60 ms delay (slow spin)

  for (int i = 0; i < NUM_LEDS; i++) {
    uint16_t hue = colorBase + hueBase + (i * 65536UL / NUM_LEDS);
    // Spreads LEDs evenly across the hue wheel, shifted by pot + spin offset

    uint32_t color = strip.gamma32(strip.ColorHSV(hue, 255, 200));
    // ColorHSV(hue, saturation, brightness) — 255 = pure color, 200 = ~78% bright
    // gamma32() corrects for the eye's logarithmic perception of brightness

    strip.setPixelColor(i, color);
  }

  strip.show();

  hueBase += 256;
  // Advances the gradient by ~0.4% of the color wheel per frame → continuous spin

  delay(speed);
}

// OLED SSD1306 – Power test with U8g2 library
#include <U8g2lib.h>
#include <Wire.h>
 
// Hardware I2C, full frame buffer (F), no reset pin
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);
 
void setup() {
  u8g2.begin();
 
  // ── All pixels WHITE (max current draw) ──────────────────
  u8g2.clearBuffer();
  u8g2.setDrawColor(1);
  u8g2.drawBox(0, 0, 128, 64);  // Fill entire screen
  u8g2.sendBuffer();
  delay(3000);
 
  // ── Showing text (realistic use) ─────────────────────────
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_ncenB08_tr);
  u8g2.drawStr(0, 20, "Hola!");
  u8g2.sendBuffer();
  delay(3000);
 
  // ── All pixels OFF (min current draw) ────────────────────
  u8g2.clearBuffer();
  u8g2.sendBuffer();
}
 
void loop() {}   // Single-shot measurement — no loop needed

// Passive Buzzer – Note scale with potentiometer control
const int PIN_BUZZER = D4;
const int PIN_TONO   = D1;

// Musical scale: C D E F G A B C
float notes[] = {261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25};
int totalNotes = 8;

void setup() {
  pinMode(PIN_BUZZER, OUTPUT);
}

void loop() {
  static int counter = 0;
  static float currentNote = 261.63;

  // Read pot every 100 cycles to avoid interrupting the tone
  if (counter == 0) {
    int sum = 0;
    for (int i = 0; i < 3; i++) sum += analogRead(PIN_TONO);
    int potValue = sum / 3;

    // Map pot value to one of the 8 notes
    int index = constrain(map(potValue, 10, 1013, 0, totalNotes - 1), 0, totalNotes - 1);
    currentNote = notes[index];
  }

  counter++;
  if (counter >= 100) counter = 0;

  // Generate one wave cycle manually (tone() doesn't work well on RP2350)
  long periodUs = 1000000L / currentNote;
  long halfUs   = periodUs / 2;

  digitalWrite(PIN_BUZZER, HIGH);
  delayMicroseconds(halfUs);
  digitalWrite(PIN_BUZZER, LOW);
  delayMicroseconds(halfUs);
}

const int PIN_BUZZER = D4;

// Note frequencies (Hz)
#define NOTE_B4  493.88
#define NOTE_D5  587.33
#define NOTE_E5  659.25
#define NOTE_FS5 739.99
#define NOTE_GS5 830.61
#define NOTE_A5  880.00
#define NOTE_B5  987.77

// Melody - Take On Me (A-ha)
float melody[] = {
  NOTE_FS5, NOTE_FS5, NOTE_D5,  NOTE_B4,  NOTE_B4,  NOTE_E5,
  NOTE_E5,  NOTE_E5,  NOTE_GS5, NOTE_GS5, NOTE_A5,  NOTE_B5,
  NOTE_A5,  NOTE_A5,  NOTE_A5,  NOTE_E5,  NOTE_D5,  NOTE_FS5,
  NOTE_FS5, NOTE_FS5, NOTE_E5,  NOTE_E5,  NOTE_FS5, NOTE_E5
};

// Note durations: 8 = eighth note, 4 = quarter note, 5 = dotted quarter
int durations[] = {
  8, 8, 8, 4, 4, 4,
  4, 5, 8, 8, 8, 8,
  8, 8, 8, 4, 4, 4,
  4, 5, 8, 8, 8, 8
};

// Auto-calculate song length from array size
int songLength = sizeof(melody) / sizeof(melody[0]);

// Manual tone generator - replaces tone() which doesn't work on RP2350
// Calculates period from frequency and toggles pin for the given duration
void playTone(float frequency, int durationMs) {
  if (frequency == 0) {
    delay(durationMs); // silence
    return;
  }
  long periodUs = 1000000L / frequency; // period in microseconds
  long halfUs   = periodUs / 2;         // 50% duty cycle = best tone
  long cycles   = (durationMs * 1000L) / periodUs;

  for (long i = 0; i < cycles; i++) {
    digitalWrite(PIN_BUZZER, HIGH);
    delayMicroseconds(halfUs);
    digitalWrite(PIN_BUZZER, LOW);
    delayMicroseconds(halfUs);
  }
}

void setup() {
  pinMode(PIN_BUZZER, OUTPUT);
}

void loop() {
  for (int i = 0; i < songLength; i++) {
    int duration = 1000 / durations[i]; // convert note value to milliseconds
    playTone(melody[i], duration);
    delay(duration * 1.3); // short pause between notes (same as original)
  }

  delay(2000); // pause before repeating
}