dejvino/NoiceSynth
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Playing notes over I2S

Browse Source
This commit is contained in:
Dejvino 2026-02-27 00:02:56 +01:00
parent 09a2d83c49
commit 659926986b
6 changed files with 61 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
AudioThread.cpp
View File

@ -1,133 +1,67 @@
#include "AudioThread.h" #include "AudioThread.h"
#include "SharedState.h" #include "SharedState.h"
#include <I2S.h>
#include <math.h>
// --- MIDI --- // I2S Pin definitions
// Create a MIDI object listening on Serial1 (GP0/GP1) // You may need to change these to match your hardware setup (e.g., for a specific DAC).
MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, MIDI); const int I2S_BCLK_PIN = 9; // Bit Clock (GP9)
const int I2S_LRC_PIN = 10; // Left-Right Clock (GP10)
const int I2S_DOUT_PIN = 11; // Data Out (GP11)
// --- Forward Declarations --- // Audio parameters
void fill_audio_buffer(int16_t* buffer, size_t buffer_size); const int SAMPLE_RATE = 44100;
void handleNoteOn(byte channel, byte note, byte velocity); const int16_t AMPLITUDE = 16383; // Use a lower amplitude to avoid clipping (max is 32767 for 16-bit)
void handleNoteOff(byte channel, byte note, byte velocity);
#ifdef TEST_OUT // Create an I2S output object
// C Natural Minor Scale notes (C3 to C5) for testing I2S i2s(OUTPUT);
const byte c_minor_scale_notes[] = {
48, 50, 51, 53, 55, 56, 58, // C3 octave // --- Synthesizer State ---
60, 62, 63, 65, 67, 68, 70, // C4 octave // Frequencies for a C-Major scale to pick from
72 // C5 const float NOTE_FREQUENCIES[] = {
261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25
}; };
#endif const int NUM_NOTES = sizeof(NOTE_FREQUENCIES) / sizeof(NOTE_FREQUENCIES[0]);
float currentFrequency = 440.0f;
double phase = 0.0;
unsigned long lastNoteChangeTime = 0;
// ---
void setupAudio() { void setupAudio() {
#ifndef TEST_OUT // Configure I2S pins
// --- Initialize MIDI ---
// The optocoupler circuit inverts the signal, so we must enable inverse logic.
Serial1.setRX(MIDI_RX_PIN);
Serial1.setTX(0); // Not using TX
Serial1.begin(31250);
Serial1.setRXInverse(true);
MIDI.setHandleNoteOn(handleNoteOn);
MIDI.setHandleNoteOff(handleNoteOff);
MIDI.begin(MIDI_CHANNEL_OMNI);
Serial.println("MIDI Initialized.");
#else
Serial.println("TEST_OUT mode enabled. Playing random C minor notes.");
// Seed random from noise on the volume pot ADC pin
randomSeed(analogRead(VOL_POT_PIN));
#endif
// --- Initialize I2S Audio ---
i2s.setBCLK(I2S_BCLK_PIN); i2s.setBCLK(I2S_BCLK_PIN);
i2s.setLRCK(I2S_LRCK_PIN); i2s.setDATA(I2S_DOUT_PIN);
i2s.setDATA(I2S_DATA_PIN);
// Set the audio callback function // Set the sample rate and start I2S communication
i2s.setBufferCallback(fill_audio_buffer); i2s.setFrequency(SAMPLE_RATE);
if (!i2s.begin()) {
if (!i2s.begin(I2S_STEREO, SAMPLE_RATE, BITS_PER_SAMPLE)) {
Serial.println("Failed to initialize I2S!"); Serial.println("Failed to initialize I2S!");
while (1); // Stop forever while (1); // Halt on error
} }
Serial.println("I2S Initialized.");
// Seed the random number generator from an unconnected analog pin
randomSeed(analogRead(A0));
} }
void loopAudio() { void loopAudio() {
#ifdef TEST_OUT unsigned long now = millis();
static uint32_t last_note_event = 0;
static bool is_playing_test_note = false;
const uint16_t note_duration = 250; // ms
const uint16_t note_gap = 50; // ms
// Check if it's time to turn off the current note // Every 500ms, pick a new random note to play
if (is_playing_test_note && (millis() - last_note_event > note_duration)) { if (now - lastNoteChangeTime > 500) {
handleNoteOff(1, 0, 0); // Turn note off lastNoteChangeTime = now;
is_playing_test_note = false; int noteIndex = random(0, NUM_NOTES);
last_note_event = millis(); // Reset timer for the gap currentFrequency = NOTE_FREQUENCIES[noteIndex];
Serial.println("Playing note: " + String(currentFrequency) + " Hz");
} }
// Check if it's time to play a new note // Generate the sine wave sample
if (!is_playing_test_note && (millis() - last_note_event > note_gap)) { double phaseIncrement = 2.0 * M_PI * currentFrequency / SAMPLE_RATE;
// Pick a random note from the scale phase = fmod(phase + phaseIncrement, 2.0 * M_PI);
int note_index = random(sizeof(c_minor_scale_notes) / sizeof(c_minor_scale_notes[0])); int16_t sample = static_cast<int16_t>(AMPLITUDE * sin(phase));
byte midi_note = c_minor_scale_notes[note_index];
// Call NoteOn to set frequency and state // Write the same sample to both left and right channels (mono audio).
handleNoteOn(1, midi_note, 127); // Channel and velocity don't matter here // This call is blocking and will wait until there is space in the DMA buffer.
is_playing_test_note = true; i2s.write(sample);
last_note_event = millis(); // Reset timer for the duration i2s.write(sample);
}
#else
// Listen for incoming MIDI messages
MIDI.read();
#endif
}
// --- Audio Generation Callback ---
// This function is called by the I2S library on the second core (by default)
// to fill the audio buffer. It must be fast and should not do any allocations.
void fill_audio_buffer(int16_t* buffer, size_t buffer_size) {
if (!g_note_on || g_note_frequency <= 0.0) {
// If no note is playing, fill the buffer with silence.
memset(buffer, 0, buffer_size * sizeof(int16_t));
return;
}
// Calculate how much to increment the phase for each sample to get the desired frequency.
float phase_increment = (2.0 * PI * g_note_frequency) / SAMPLE_RATE;
// The maximum amplitude for a 16-bit signed integer.
const int16_t max_amplitude = 32767;
for (size_t i = 0; i < buffer_size; i += 2) { // Process in stereo pairs
// Generate a sawtooth wave sample (-1.0 to 1.0)
float sample = (g_phase / PI) - 1.0;
// Increment and wrap the phase
g_phase += phase_increment;
if (g_phase >= 2.0 * PI) {
g_phase -= 2.0 * PI;
}
// Apply volume and scale to 16-bit integer range
int16_t final_sample = static_cast<int16_t>(sample * max_amplitude * g_volume);
// Write the same sample to both left and right channels
buffer[i] = final_sample; // Left channel
buffer[i + 1] = final_sample; // Right channel
}
}
// --- MIDI Callback Functions ---
void handleNoteOn(byte channel, byte note, byte velocity) {
// Convert MIDI note number to frequency
g_note_frequency = 440.0 * pow(2.0, (note - 69.0) / 12.0);
g_note_on = true;
g_phase = 0.0; // Reset phase for a clean attack
}
void handleNoteOff(byte channel, byte note, byte velocity) {
g_note_on = false;
g_note_frequency = 0.0;
} }

6
AudioThread.h
View File

@ -1,7 +1,7 @@
#ifndef AUDIO_THREAD_H #ifndef AUDIOTHREAD_H
#define AUDIO_THREAD_H #define AUDIOTHREAD_H
void setupAudio(); void setupAudio();
void loopAudio(); void loopAudio();
#endif #endif // AUDIOTHREAD_H

16
SharedState.cpp
View File

@ -1,19 +1,5 @@
#include "SharedState.h" #include "SharedState.h"
// --- Global Objects ---
I2S i2s;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
// --- Watchdog ---
volatile unsigned long lastLoop0Time = 0; volatile unsigned long lastLoop0Time = 0;
volatile unsigned long lastLoop1Time = 0; volatile unsigned long lastLoop1Time = 0;
volatile bool watchdogActive = false; volatile bool watchdogActive = false;
// --- Synthesizer State ---
volatile float g_note_frequency = 0.0;
volatile bool g_note_on = false;
volatile float g_volume = 0.5;
float g_phase = 0.0;
// --- Control State ---
int g_encoder_value = 0;

55
SharedState.h
View File

@ -1,59 +1,10 @@
#ifndef SHARED_STATE_H #ifndef SHAREDSTATE_H
#define SHARED_STATE_H #define SHAREDSTATE_H
#include <Arduino.h> #include <Arduino.h>
#include <I2S.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <MIDI.h>
// --- Pin Definitions ---
// I2S Audio
#define I2S_BCLK_PIN 9
#define I2S_LRCK_PIN 10
#define I2S_DATA_PIN 11
// I2C OLED Display
#define OLED_SDA_PIN 4
#define OLED_SCL_PIN 5
// Controls
#define ENCODER_CLK_PIN 12
#define ENCODER_DT_PIN 13
#define ENCODER_SW_PIN 14
#define VOL_POT_PIN 26 // ADC0
// MIDI Input
#define MIDI_RX_PIN 1 // UART0 RX
// --- Constants ---
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SAMPLE_RATE 44100
#define BITS_PER_SAMPLE 16
// --- Global Objects ---
extern I2S i2s;
extern Adafruit_SSD1306 display;
extern midi::MidiInterface<HardwareSerial> MIDI;
// --- Watchdog ---
extern volatile unsigned long lastLoop0Time; extern volatile unsigned long lastLoop0Time;
extern volatile unsigned long lastLoop1Time; extern volatile unsigned long lastLoop1Time;
extern volatile bool watchdogActive; extern volatile bool watchdogActive;
// --- Synthesizer State --- #endif // SHAREDSTATE_H
extern volatile float g_note_frequency;
extern volatile bool g_note_on;
extern volatile float g_volume;
extern float g_phase;
// --- Control State ---
extern int g_encoder_value;
// --- Test Mode ---
// #define TEST_OUT
#endif

86
UIThread.cpp
View File

@ -1,90 +1,12 @@
#include "UIThread.h" #include "UIThread.h"
#include "SharedState.h" #include "SharedState.h"
#include <Wire.h> #include <Arduino.h>
// --- Local State ---
static int g_last_clk_state;
// --- Forward Declarations ---
static void readEncoder();
static void updateDisplay();
void setupUI() { void setupUI() {
// --- Initialize I2C and Display --- // This is the UI thread, running on core 0. For this example, we do nothing here.
Wire.setSDA(OLED_SDA_PIN);
Wire.setSCL(OLED_SCL_PIN);
Wire.begin();
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3C for 128x64
Serial.println(F("SSD1306 allocation failed"));
for (;;); // Don't proceed, loop forever
}
display.clearDisplay();
display.setTextColor(SSD1306_WHITE);
display.setTextSize(1);
display.println("NoiceSynth Booting...");
display.display();
delay(1000);
// --- Initialize Controls ---
pinMode(ENCODER_CLK_PIN, INPUT_PULLUP);
pinMode(ENCODER_DT_PIN, INPUT_PULLUP);
pinMode(ENCODER_SW_PIN, INPUT_PULLUP);
g_last_clk_state = digitalRead(ENCODER_CLK_PIN);
} }
void loopUI() { void loopUI() {
// Read the volume potentiometer (Pico ADC is 12-bit, 0-4095) // The loop on core 0 is responsible for updating the UI. In this simple example, it does nothing.
// We use a bit of filtering by averaging with the old value to reduce noise. delay(100);
float new_volume = analogRead(VOL_POT_PIN) / 4095.0f;
g_volume = (g_volume * 0.95) + (new_volume * 0.05);
// Read the rotary encoder
readEncoder();
// Update the display periodically
static uint32_t last_display_update = 0;
if (millis() - last_display_update > 100) { // Update 10 times/sec
last_display_update = millis();
updateDisplay();
}
}
static void updateDisplay() {
display.clearDisplay();
display.setCursor(0, 0);
display.println(F(" NoiceSynth"));
display.println(F("--------------------"));
if (g_note_on) {
display.print(F("Note Freq: "));
display.print(g_note_frequency, 2);
display.println(F(" Hz"));
} else {
display.println(F("Note: Off"));
}
display.print(F("Volume: "));
display.print(static_cast<int>(g_volume * 100));
display.println(F("%"));
display.print(F("Encoder: "));
display.println(g_encoder_value);
display.display();
}
static void readEncoder() {
int new_clk_state = digitalRead(ENCODER_CLK_PIN);
// Check for a change on the CLK pin (a "tick" of the encoder)
if (new_clk_state != g_last_clk_state && new_clk_state == LOW) {
// Read the DT pin to determine direction
if (digitalRead(ENCODER_DT_PIN) == LOW) {
g_encoder_value++; // Clockwise
} else {
g_encoder_value--; // Counter-clockwise
}
}
g_last_clk_state = new_clk_state;
} }

6
UIThread.h
View File

@ -1,7 +1,7 @@
#ifndef UI_THREAD_H #ifndef UITHREAD_H
#define UI_THREAD_H #define UITHREAD_H
void setupUI(); void setupUI();
void loopUI(); void loopUI();
#endif #endif // UITHREAD_H