Simple Midi Synth

[fesch]

I have tried to build a simple midi synth using an EPS32-S3 in Arduino IDE 2 (the breadboard on the picture below). It which should also be controllable and thus programmable via some other midi devices. I used the example from the current HEAD's code, but noticed that the synth puts a lot of noise on the line and that reading from the midi keyboard does not always work. I suspect the CPU is somewhat too busy.

I then decided to roll back to my previous code, where I used the MIDI.h to control midi events on my own. My first hardware also has an encoder button to switch patches, but it is not really necessary, as I prefer controlling the synth from my control-box (the dark green box on the picture below). With this new version the noise on the output has completely gone and the sound quality is very good.

Here is my entire code. Maybe it will also help somebody else :-)

// midi related library
#include <MIDI.h>
// encoder button library
#include <EncoderButton.h>

// define pins for secondary uart
#define RXD1 18
#define TXD1 17

// create a hardware serial onto these pins
MIDI_CREATE_INSTANCE(HardwareSerial, Serial1, Midi);

/*
/!\
/!\ Midi library and object creation must be done
/!\ before including amy, otherwise midi routines 
/!\ won't be found any more!
/!\
*/

// amy synth library
#include <AMY-Arduino.h>

// i2s DAC pins
#define CONFIG_I2S_BCLK 13 
#define CONFIG_I2S_LRCLK 12
#define CONFIG_I2S_DIN 11

// actual applied patch
int patch = 0;
// actual bank
// 256 patches defined, so bank#0=[0..127] and bank#1=[128..255]
int bank = 0;

// encoder button object
EncoderButton button(7,6,36);
// encore button pressed
boolean pressed = false;


void setup() {
  // start the console
  Serial.begin(115200);
  Serial.println("Starting ...");

  // start midi uart interface
  Serial1.begin(31250, SERIAL_8N1, RXD1, TXD1);

  // connect callbacks
  Midi.setHandleNoteOn(handleNoteOn);
  Midi.setHandleNoteOff(handleNoteOff);
  Midi.setHandleProgramChange(handleProgramChange);
  Midi.setHandleControlChange(handleControlChange);
  // listen to all channels
  Midi.begin(MIDI_CHANNEL_OMNI);  
  // furn of midi through
  Midi.turnThruOff();

  // attach encoder button callbacks
  button.setEncoderHandler(onRotEncoder);
  button.setPressedHandler(onRotPressed); 
  button.setReleasedHandler(onRotReleased); 
  
  // amy config
  amy_config_t amy_config = amy_default_config();
  // make bleep as start
  amy_config.features.startup_bleep = 1;
  // i2c DAC pins
  amy_config.i2s_bclk = CONFIG_I2S_BCLK;
  amy_config.i2s_lrc = CONFIG_I2S_LRCLK;
  amy_config.i2s_dout = CONFIG_I2S_DIN;

  //amy_config.features.chorus=1; // not yet supported by C version of amy_event
  //amy_config.features.reverb=1; // not yet supported by C version of amy_event

  // use the two cores please
  amy_config.features.dualcore=1;

  // start amy
  amy_start(amy_config);
  // start amy live
  amy_live_start();

  // configure channel 1
  amy_event e = amy_default_event();
  e.synth = 1;
  e.num_voices = 10;  
  amy_add_event(&e);

  // configure channel 2
  e = amy_default_event();
  e.synth = 2;
  e.num_voices = 10;  
  amy_add_event(&e);

  // put patch 29 on channel 1
  e = amy_default_event();
  e.synth = 1;
  e.patch_number = 29;
  amy_add_event(&e);
}

void handleNoteOn(byte channel, byte pitch, byte velocity)
{
  Serial.println("handleNoteOn > C:"+(String)channel+" > N:"+(String)pitch+" > V:"+(String)velocity);
  
  // play note
  amy_event e = amy_default_event();
  e.synth = channel;
  e.midi_note = pitch;
  e.velocity = (float)velocity/127.0;
  amy_add_event(&e);
}

void handleNoteOff(byte channel, byte pitch, byte velocity)
{
  Serial.println("handleNoteOff > C:"+(String)channel+" > N:"+(String)pitch+" > V:"+(String)velocity);

  // play note
  amy_event e = amy_default_event();
  e.synth = channel;
  e.midi_note = pitch;
  e.velocity = 0;
  amy_add_event(&e);
}


void handleProgramChange(byte channel, byte number)
{
  Serial.println("handleProgramChange > C:"+(String)channel+" > P:"+(String)number);
  
  patch=bank*128+number;
  Serial.println("Patch is now: "+(String)patch);

  // change patch
  amy_event e = amy_default_event();
  e.synth = channel;
  e.patch_number = patch;
  amy_add_event(&e);
}

void handleControlChange(byte channel, byte number, byte value)
{
  Serial.println("handleControlChange > C:"+(String)channel+" > C:"+(String)number+" > V:"+(String)value);

  // volume
  if(number==7)
  {
    amy_event e = amy_default_event();
    e.synth = channel;
    e.volume = (float)value/127.0;;
    amy_add_event(&e);
  }
  // bank change, react only to #32
  if(number==32)
  {
    bank=value;
  }
  // sustain pedal
  else if(number==64)
  {
    amy_event e = amy_default_event();
    e.synth = channel;
    e.pedal = value;
    amy_add_event(&e);
  }
}

void onRotEncoder(EncoderButton& eb) 
{
  Serial.print("onRotEncoder: ");

  int value = eb.increment()*abs(eb.increment());
  Serial.println(" >> VALUE: "+(String)value);

  if(pressed) value=value*10;
  patch=(patch+value)%256;

  Serial.println("Patch is now: "+(String)patch);

  amy_event e = amy_default_event();
  e.synth = 1;
  e.patch_number = patch;
  amy_add_event(&e);
}

void onRotPressed(EncoderButton& eb) 
{
  Serial.println("onRotPressed");
  pressed=true;
}

void onRotReleased(EncoderButton& eb) 
{
  Serial.println("onRotReleased");
  pressed = false;
}


void loop() {
  // pass the hand to amy
  amy_update(); 
  // pass the hand to the button
  button.update();
  // pass the hand to midi
  Midi.read();
}

I have ordered an ESP32-P4 to see what that will change in performance. Another option I see to use more instruments at the same time is to have one ESP per midi channel.

[dpwe]

Thanks for the report and the example.

I just built the AMY_MIDI_Synth.ino example from current HEAD under Arduino 1.8.19 on a Raspberry Pi to program an ESP32-S3 dev board, hooked to a PCM5101 DAC module, and with UART MIDI coming in.

Everything worked fine, I got 10-12 simultaneous instances of Juno Patch 1 playing cleanly - see picture below. (Ignore the QFP48 chip in the middle. I'm using a prototype AMYboard -- the red PCB -- for my MIDI->logic interface).

Pedal and program change are handled by the built-in MIDI handler, although to get the bank and global volume control of your patch, you'd probably want to modify src/midi_mappings.c.

I can't explain why you experienced a noisy output, although I have found that routing the 1.4 MHz BLCK signal on a breadboard can be fragile.

I see that you're printing messages to the console, and we've found that can cause dropped audio buffers on Arduino: the DAC servicing relies on amy_update() being called every few milliseconds worst-case, but some console transactions can block for longer.

[dpwe]

.. although the src/midi_mappings.c approach won't work until #422 is resolved!

[fesch]

I tried to build the example from the actual HEAD again this afternoon and now it works without any noise. I did not touch my cabling although ...?! Anyway ;-)

[dpwe]

That's a bit disturbing; there's nothing worse than intermittent bugs, but I'm glad it appears to be working now. Thanks for the update.

[dpwe]

p.s. I liked the way you put global volume on a MIDI CC (#7), and I'd been meaning to add Bank Select, so I included them both in the latest PR (#426, which also fixed #422).

However, per http://midi.teragonaudio.com/tech/midispec/bank.htm, for Bank Select with a limited number of banks it's more common to use just CC 0 and ignore CC 32, rather than the other way around, so that's what I did.

[fesch]

Thanks for that :-)

The reason why I did it that way for the bank select, is because I designed my control device (the dark green box) to work with predefined banks of Roland JVC-1010. So I was lazy and simply reused it's bank selectors in the most simple way 😅. Of course you are right with what you said. 👍

[gritd]

Seeing this implementation I'm not quite sure if I understand the core of AMY: As I read through the documentation it looks like amy_live_start() attaches it's own MIDI routine's to the audio engine but in this example you double up the input handling with the midi.h library?

edit: ok wait I think I see it, you did not define amy_config.midi = AMY_MIDI_IS_UART so the whole internal midi thing is not used?

[dpwe]

I understand your confusion and I'm trying to re-engineer some of this at the moment.

To make AMY-Arduino as easy as possible to use, we implemented I2S audio and UART MIDI IO to run "transparently" on a number of common platforms. But these implementations won't cover every use-case or hardware setup, so there will always be situations where users handle them explicitly.

These features are controlled via flags in amy_config. So for instance if you don't set the midi field to AMY_MIDI_IS_UART, AMY won't set up any MIDI input handler and you'll have to receive MIDI messages and forward them to AMY yourself.

I'm hoping to document this better and unify behavior for all the advanced platform features (MIDI, audio IO, multiprocessing, multithreading, ...).

[gritd]

got it, yes well I'm slowly getting there in making amy respond to my own wishes. And I must say - Amy is the first audio engine which compiled without too much troubles, very nice work! I should mention though that I'm using an ESP32s3 and in my old arduino environment where it's all good but very slow compiling. In Visual Studio Code the I2S library seems to have switched to a new version which is not compatible with amy's i2s implementation anymore

Also - how would you initialize a synth by an event on a midi channel which does the drum samples (or other types)? according to the online docs I tried:

e = amy_default_event();
e.synth = 10;
/// not known: e.patch_string='w7f0Z';
// text does not work on uint type
e.synth_flags = 3;
e.num_voices = 3;
amy_add_event(&e);

the synth_flags = 3 alone does not do the trick on setting a midi channel to the drum samples so I'm not sure how to handle these patch_number / patch_string thing

[EDIT] PS: about the bank change on midi CCs, you have midi CC0 and Midi CC32 which are defined as a bank change LSB and MSB, you can implement those to control Amy in sort of a 'standardized MIDI' fashion; 'GM Style'. CC7 is volume and CC10 is panning, I figured this out which is nice to add in the midi handling:

if(number==10)
{
amy_event e = amy_default_event();
e.synth = channel;
e.pan_coefs[COEF_CONST] = (float)value/127.0;
amy_add_event(&e);
}

There's a good CC list here to see what is already standardised (also for example filter cutoff / resonance on CC numbers 74 / 71 ): https://www.presetpatch.com/midi-cc-list.aspx