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

Compare commits

base: dejvino:659926986b5eabc2d976575c968988577f51534b
Branches Tags
dejvino:main
..
compare: dejvino:f7a93ee5bd3b301494f8baabb717dc2db20ad9a8
Branches Tags
dejvino:main

No commits in common. "659926986b5eabc2d976575c968988577f51534b" and "f7a93ee5bd3b301494f8baabb717dc2db20ad9a8" have entirely different histories.
659926986b ... f7a93ee5bd

8 changed files with 270 additions and 167 deletions
Show Stats Expand all files Collapse all files

67
AudioThread.cpp
View File

@ -1,67 +0,0 @@
#include "AudioThread.h"
#include "SharedState.h"
#include <I2S.h>
#include <math.h>
// I2S Pin definitions
// You may need to change these to match your hardware setup (e.g., for a specific DAC).
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)
// Audio parameters
const int SAMPLE_RATE = 44100;
const int16_t AMPLITUDE = 16383; // Use a lower amplitude to avoid clipping (max is 32767 for 16-bit)
// Create an I2S output object
I2S i2s(OUTPUT);
// --- Synthesizer State ---
// Frequencies for a C-Major scale to pick from
const float NOTE_FREQUENCIES[] = {
261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25
};
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() {
// Configure I2S pins
i2s.setBCLK(I2S_BCLK_PIN);
i2s.setDATA(I2S_DOUT_PIN);
// Set the sample rate and start I2S communication
i2s.setFrequency(SAMPLE_RATE);
if (!i2s.begin()) {
Serial.println("Failed to initialize I2S!");
while (1); // Halt on error
}
// Seed the random number generator from an unconnected analog pin
randomSeed(analogRead(A0));
}
void loopAudio() {
unsigned long now = millis();
// Every 500ms, pick a new random note to play
if (now - lastNoteChangeTime > 500) {
lastNoteChangeTime = now;
int noteIndex = random(0, NUM_NOTES);
currentFrequency = NOTE_FREQUENCIES[noteIndex];
Serial.println("Playing note: " + String(currentFrequency) + " Hz");
}
// Generate the sine wave sample
double phaseIncrement = 2.0 * M_PI * currentFrequency / SAMPLE_RATE;
phase = fmod(phase + phaseIncrement, 2.0 * M_PI);
int16_t sample = static_cast<int16_t>(AMPLITUDE * sin(phase));
// Write the same sample to both left and right channels (mono audio).
// This call is blocking and will wait until there is space in the DMA buffer.
i2s.write(sample);
i2s.write(sample);
}

7
AudioThread.h
View File

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

35
README.md
View File

@ -24,41 +24,23 @@ This guide provides the blueprint for building your own.
| **Power** | 3.7V LiPo Battery and a 5V booster/charger board (e.g., Adafruit PowerBoost). |
| **MIDI Circuit Parts** | 6N138 or 6N137 Optocoupler, 1N4148 Diode, various resistors (see diagram). |
## Powering Your Synth
## Powering Your Synth (Battery Operation)
You can power the synth either from a portable LiPo battery or directly from USB.
### Battery Operation (Portable)
To make the synth truly portable, use a LiPo battery and a 5V booster/charger board. This provides stable power to all components.
To make the synth truly portable, we'll use a LiPo battery and a booster board. This is critical for providing stable power to all components.
> **LIPO BATTERY WARNING**: LiPo batteries are powerful but require careful handling.
> * **Never** use a LiPo battery without a dedicated protection and charging circuit like the PowerBoost.
> * Do not puncture, bend, or short-circuit a LiPo battery.
### Wiring for Power:
1. Connect the **LiPo battery** to the JST connector on the **PowerBoost board**.
2. Connect the **PowerBoost's 5V output** to the **Pico's VBUS pin (Pin 40)**. This powers the Pico.
3. Connect the **PowerBoost's 5V output** to the **VCC/VIN pin of your I2S Audio Module**.
4. Connect the **PowerBoost's GND** to one of the **Pico's GND pins**. This creates a common ground.
4. Connect the **PowerBoost's GND** to one of the **Pico's GND pins**.
5. Connect this **common ground** to the **GND pins of all other components** (OLED, I2S Module, Encoder, Potentiometer, MIDI circuit).
### USB Operation
If you don't need battery power, you can run the synth from a USB source (like a computer or wall adapter). The wiring is simpler.
There are two ways to power the components:
**Option 1 (Simplest): Power everything from 3.3V**
The PCM5102A DAC chip runs natively on 3.3V. This is the easiest and safest wiring method for USB operation.
1. Power the Pico by connecting its **micro-USB port** to a USB power source.
2. Connect the Pico's **3V3(OUT) pin (Pin 36)** to the VCC/VIN pins of **all** components: the I2S Module, OLED, Rotary Encoder, Potentiometer, and MIDI circuit.
3. Ensure all components share a **common ground** with one of the Pico's GND pins.
**Option 2: Power I2S Module from 5V (with protection)**
If you prefer to give the audio module a separate 5V supply from USB. For good measure, adding a Schottky diode (e.g., 1N5817) is recommended to protect against any potential reverse voltage.
1. Power the Pico via its **micro-USB port**.
2. Connect the Pico's **VBUS pin (Pin 40)** to the **anode (+)** of a Schottky diode. Connect the **cathode (-)** of the diode to the **VCC/VIN pin of your I2S Audio Module**.
3. Connect the Pico's **3V3(OUT) pin (Pin 36)** to power the OLED, Encoder, Potentiometer, and MIDI circuit.
4. Ensure all components share a **common ground**.
This setup ensures everything shares a common ground and that the power-hungry components get the stable 5V they need, while the Pico's onboard regulator provides 3.3V for the lower-power parts.
## Wiring & Connections
@ -67,12 +49,11 @@ Establish a **common ground** by connecting the ground from your PowerBoost boar
| Component | Pico Pin | Description |
| ------------------ | ------------------ | ---------------------------------------------- |
| **I2S Audio Module** | | |
| VCC | 3.3V or 5V Source (see Power section) | Power for the amplifier |
| VCC | 5V from PowerBoost | Power for the amplifier |
| GND | Common GND | Ground |
| DIN (Data) | GP11 (Pin 15) | I2S Data Out |
| BCLK (Bit Clock) | GP9 (Pin 12) | I2S Bit Clock |
| LRCK (Word Clock) | GP10 (Pin 14) | I2S Left/Right Clock |
| SCK (System Clock) | GND | **PCM5102 Only**: Connect to GND for internal PLL |
| **SSD1306 OLED** | | |
| VCC | 3V3 (OUT) (Pin 36) | 3.3V Power |
| GND | Common GND | Ground |

294
RP2040_NoiceSynth.ino
View File

@ -1,45 +1,275 @@
#include "SharedState.h"
#include "UIThread.h"
#include "AudioThread.h"
/**
* NoiceSynth - A Compact RP2040 Synthesizer
*
* This sketch provides the foundational code for a portable MIDI synthesizer
* based on the Raspberry Pi Pico (RP2040).
*
* Features implemented:
* - I2S audio output for a simple sawtooth oscillator.
* - MIDI input handling (Note On/Off) via TRS jack to control the oscillator.
* - OLED display for visual feedback (current note, volume).
* - Analog volume control via a potentiometer.
* - Basic rotary encoder reading (framework for future parameter control).
*
* Libraries Required (Install via Arduino Library Manager):
* - Adafruit GFX Library
* - Adafruit SSD1306
* - MIDI Library (by Forty Seven Effects)
*
* The I2S library by Earle F. Philhower, III is included with the RP2040 board core.
*/
#include <I2S.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <MIDI.h>
// --- Pin Definitions (as per README.md) ---
// 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 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SAMPLE_RATE 44100
#define BITS_PER_SAMPLE 16
// --- Global Objects ---
I2S i2s;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
// Create a MIDI object listening on Serial1 (GP0/GP1)
MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, MIDI);
// --- Synthesizer State Variables ---
volatile float g_note_frequency = 0.0;
volatile bool g_note_on = false;
volatile float g_volume = 0.5;
#ifdef TEST_OUT
// C Natural Minor Scale notes (C3 to C5) for testing
const byte c_minor_scale_notes[] = {
48, 50, 51, 53, 55, 56, 58, // C3 octave
60, 62, 63, 65, 67, 68, 70, // C4 octave
72 // C5
};
#endif
// Oscillator phase
float g_phase = 0.0;
// Rotary encoder state
int g_encoder_value = 0;
int g_last_clk_state;
// --- 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.
for (size_t i = 0; i < buffer_size; i++) {
buffer[i] = 0;
}
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;
}
// --- Helper Functions ---
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();
}
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;
}
void setup() {
Serial.begin(115200);
delay(2000); // Wait for serial monitor
Serial.println(F("Starting NoiceSynth..."));
setupUI();
setupAudio();
// --- Initialize I2C and Display ---
Wire.setSDA(OLED_SDA_PIN);
Wire.setSCL(OLED_SCL_PIN);
Wire.begin();
Serial.println(F("Started."));
// Enable Watchdog
lastLoop0Time = millis();
lastLoop1Time = millis();
watchdogActive = true;
}
void loop1() {
if (!watchdogActive) {
delay(100);
return;
}
unsigned long now = millis();
lastLoop1Time = now;
if (watchdogActive && (now - lastLoop0Time > 1000)) {
Serial.println(F("Core 0 Freeze detected! Rebooting..."));
rp2040.reboot();
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);
loopAudio();
// --- 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);
#ifndef TEST_OUT
// --- 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.setLRCK(I2S_LRCK_PIN);
i2s.setDATA(I2S_DATA_PIN);
// Set the audio callback function
i2s.setBufferCallback(fill_audio_buffer);
if (!i2s.begin(I2S_STEREO, SAMPLE_RATE, BITS_PER_SAMPLE)) {
Serial.println("Failed to initialize I2S!");
while (1); // Stop forever
}
Serial.println("I2S Initialized.");
}
void loop() {
unsigned long now = millis();
lastLoop0Time = now;
if (watchdogActive && (now - lastLoop1Time > 1000)) {
Serial.println(F("Core 1 Freeze detected! Rebooting..."));
rp2040.reboot();
#ifdef TEST_OUT
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
if (is_playing_test_note && (millis() - last_note_event > note_duration)) {
handleNoteOff(1, 0, 0); // Turn note off
is_playing_test_note = false;
last_note_event = millis(); // Reset timer for the gap
}
loopUI();
// Check if it's time to play a new note
if (!is_playing_test_note && (millis() - last_note_event > note_gap)) {
// Pick a random note from the scale
int note_index = random(sizeof(c_minor_scale_notes) / sizeof(c_minor_scale_notes[0]));
byte midi_note = c_minor_scale_notes[note_index];
// Call NoteOn to set frequency and state
handleNoteOn(1, midi_note, 127); // Channel and velocity don't matter here
is_playing_test_note = true;
last_note_event = millis(); // Reset timer for the duration
}
#else
// Listen for incoming MIDI messages
MIDI.read();
#endif
// Read the volume potentiometer (Pico ADC is 12-bit, 0-4095)
// We use a bit of filtering by averaging with the old value to reduce noise.
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();
}
}

5
SharedState.cpp
View File

@ -1,5 +0,0 @@
#include "SharedState.h"
volatile unsigned long lastLoop0Time = 0;
volatile unsigned long lastLoop1Time = 0;
volatile bool watchdogActive = false;

10
SharedState.h
View File

@ -1,10 +0,0 @@
#ifndef SHAREDSTATE_H
#define SHAREDSTATE_H
#include <Arduino.h>
extern volatile unsigned long lastLoop0Time;
extern volatile unsigned long lastLoop1Time;
extern volatile bool watchdogActive;
#endif // SHAREDSTATE_H

12
UIThread.cpp
View File

@ -1,12 +0,0 @@
#include "UIThread.h"
#include "SharedState.h"
#include <Arduino.h>
void setupUI() {
// This is the UI thread, running on core 0. For this example, we do nothing here.
}
void loopUI() {
// The loop on core 0 is responsible for updating the UI. In this simple example, it does nothing.
delay(100);
}

7
UIThread.h
View File

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