drumduino_firmware/drumduino_firmware.ino

#include <SoftwareSerial.h>

#define USE_DISPLAY 1

#if USE_DISPLAY
#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
#endif


enum DrumduinoFirmwareSettings {
	PORT_CNT = 1,
	CHAN_PER_PORT_CNT = 1,
	PAD_CNT = PORT_CNT * CHAN_PER_PORT_CNT,
	FRAME_BUFFER_SIZE = 3,
};

enum Pins {
	PIN_MULTIPLEX_A = 2,
	PIN_MULTIPLEX_B = 3 ,
	PIN_MULTIPLEX_C = 4 ,

	PIN_SOFTSERIAL_RX = 5,
	PIN_SOFTSERIAL_TX = 6,
};


//=================================================================================
// Set Bit and Clwear Bit Helpers
//=================================================================================
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif


//=================================================================================
// Prescaler
//=================================================================================
// Maximum sampling frequency    // Resolution
enum Prescaler {
	Prescaler_2   = B00000000, // 16 MHz / 2 = 8 MHz            //
	Prescaler_4   = B00000010, // 16 MHz / 4 = 4 MHz            // ~5.9
	Prescaler_8   = B00000011, // 16 MHz / 8 = 2 MHz            // ~7.4
	Prescaler_16  = B00000100, // 16 MHz / 16 = 1 MHz           // ~8.6
	Prescaler_32  = B00000101, // 16 MHz / 32 = 500 kHz         // ~8.9
	Prescaler_64  = B00000110, // 16 MHz / 64 = 250 kHz         // ~9.0
	Prescaler_128 = B00000111, // 16 MHz / 128 = 125 kHz        // ~9.1
};

inline void setPrescaler(int prescaler) {
	ADCSRA &= B11111000;
	ADCSRA |= prescaler;
}


//=================================================================================
//  Ad Pin
//=================================================================================
enum AdPin {
	AdPin_0   = B00000000,
	AdPin_1   = B00000001,
	AdPin_2   = B00000010,
	AdPin_3   = B00000011,
	AdPin_4   = B00000100,
	AdPin_5   = B00000101,
	AdPin_6   = B00000110, // Bei Atmega8 nur in der Gehäusebauform TQFP und MLF verfügbar, nicht in PDIP
	AdPin_7   = B00000111, // Bei Atmega8 nur in der Gehäusebauform TQFP und MLF verfügbar, nicht in PDIP
	AdPin_Vbg = B00001110, // 1.23V
	AdPin_GND = B00001111, // 0V
};

inline void setAdPin(int adPin) {
	ADMUX &= B11110000;
	ADMUX |= adPin;
}

//=================================================================================
// ADC Alignment
//=================================================================================
// Das Ergebnis wird in den Registern ADCH/ADCL linksbündig ausgerichtet.
// Die 8 höchstwertigen Bits des Ergebnisses werden in ADCH abgelegt.
// Die verbleibenden 2 niederwertigen Bits werden im Register ADCL in den Bits 6 und 7 abgelegt.
enum AdcAlignment {
	ADAlignmentLeft  = B00100000,
	ADAlignmentRight = B00000000,
};


inline void setADAlignment(int align) {
	ADMUX &= ~B00100000;
	ADMUX |= align;
}

//=================================================================================
inline void startADCConversion() {
	ADCSRA |= B01000000;
}

//=================================================================================

inline void disableAnalogComparator() {
	ACSR = B10000000;
}

inline void multiplexSelectChan(uint8_t chan) {
	PORTD = B00011100 & (chan << 2) | (B11100011 & PORTD);
}

//=================================================================================
// MIDI
//=================================================================================
namespace midi {
	/// http://www.midi.org/techspecs/midimessages.php
#if 0
	struct SysexFrame {
		byte begin = 0xf0;
		byte manufacturer = 42;
		unsigned long time1 = 0;
		unsigned long time2 = 0;
		byte values[PAD_CNT] = { 0 };
		byte end = 0xF7;
	};
#endif

	/**
	Note Off event.
	This message is sent when a note is released (ended).
	*/
	template<typename SERIAL_IF>
	void noteOn(SERIAL_IF& serial, uint8_t note, uint8_t velocity) {
		serial.write((uint8_t)0x90);
		serial.write((uint8_t)note);
		serial.write((uint8_t)velocity);
	}

	/**
	Note On event.
	This message is sent when a note is depressed (start).
	*/
	template<typename SERIAL_IF>
	void noteOff(SERIAL_IF& serial, uint8_t note, uint8_t velocity) {
		serial.write((uint8_t)0x80);
		serial.write((uint8_t)note);
		serial.write((uint8_t)velocity);
	}

	/**
	Polyphonic Key Pressure (Aftertouch).
	This message is most often sent by pressing down on the key after it "bottoms out".
	*/
	template<typename SERIAL_IF>
	void polyphonicKeyPressure(SERIAL_IF& serial, uint8_t note, uint8_t pressure) {
		serial.write((uint8_t)0xA0);
		serial.write((uint8_t)note);
		serial.write((uint8_t)pressure);
	}

	/**
	Control Change.
	This message is sent when a controller value changes.
	Controllers include devices such as pedals and levers.
	Controller numbers 120-127 are reserved as "Channel Mode Messages" (below).
	*/
	template<typename SERIAL_IF>
	void controlChange(SERIAL_IF& serial, uint8_t controllerNumber, uint8_t controllerValue) {
		serial.write((uint8_t)0xB0);
		serial.write((uint8_t)controllerNumber);
		serial.write((uint8_t)controllerValue);
	}
}



//=================================================================================
//
//=================================================================================
struct Configuration {
	enum Type {
		TypeDisabled,
		TypePiezo,
	} type[PAD_CNT] = { TypePiezo };

	struct CurveSettings {
		enum CurveType {
			CurveNormal,
			CurveExp,
			CurveLog,
			CurveSigma,
			CurveFlat,
			CurveExtra,
		};

		CurveType type = CurveNormal;
		uint8_t value = 127;
		int8_t offset = 0;
		uint8_t factor = 127;
	} curve[PAD_CNT];

	uint8_t note[PAD_CNT] = { 0 };
	uint8_t threshold[PAD_CNT] = { 25 };
	uint8_t scanTime[PAD_CNT] = { 25 };
	uint8_t maskTime[PAD_CNT] = { 35 };

} g_configuration;


//=================================================================================
//
//=================================================================================
struct Runtime {
	SoftwareSerial softSerial{ PIN_SOFTSERIAL_RX, PIN_SOFTSERIAL_TX }; // RX, TX

	uint8_t value[PAD_CNT][FRAME_BUFFER_SIZE];

	enum State {
		StateAwait,
		StateScan,
		StateMask,
	} state[PAD_CNT] = { StateAwait };

	uint8_t  trigger[PAD_CNT] = { 0 };
	uint8_t max[PAD_CNT] = { 0 };
	//uint64_t sum[PAD_CNT] = { 0 };

	uint64_t frameCounter = 0;
#if USE_DISPLAY
	bool displayTriggerEvent[PAD_CNT] = { 0 };
#endif
} g_runtime;


//=================================================================================
//
//=================================================================================
inline uint8_t calcCurve(const Configuration::CurveSettings& curveSettings, uint8_t value) {
	uint8_t ret = 0;

	float x = value * 8.0;
	float f = ((float)curveSettings.value) / 64.0; //[1;127]->[0.;2.0]

	switch(curveSettings.type) {
		//[0-1023]x[0-127]
		case Configuration::CurveSettings::CurveNormal:
			ret = x * f / 16.0;
			break;

		case Configuration::CurveSettings::CurveExp:
			ret = (127.0 / (exp(2.0 * f) - 1)) * (exp(f * x / 512.0) - 1.0);
			break; //Exp 4*(exp(x/256)-1)

		case Configuration::CurveSettings::CurveLog:
			ret = log(1.0 + (f * x / 128.0)) * (127.0 / log((8 * f) + 1));
			break; //Log 64*log(1+x/128)

		case Configuration::CurveSettings::CurveSigma:
			ret = (127.0 / (1.0 + exp(f * (512.0 - x) / 64.0)));
			break; //Sigma

		case Configuration::CurveSettings::CurveFlat:
			ret = (64.0 - ((8.0 / f) * log((1024 / (1 + x)) - 1)));
			break; //Flat

		case Configuration::CurveSettings::CurveExtra:
			ret = (x + 0x20) * f / 16.0;

	}

	ret = ret * (curveSettings.factor / 127.0) + curveSettings.offset;

	if(ret <= 0) {
		return 0;
	}

	if(ret >= 127) {
		return 127;    //127
	}

	return ret;
}


//=================================================================================
//
//=================================================================================
void setup() {
#if USE_DISPLAY
	lcd.begin(16, 2);
	delay(500);
	lcd.print("Drumduino  0.0.1");
	delay(1000);
#endif


	memset(g_runtime.value, 0, sizeof(g_runtime.value));

	// generate note mapping
	for(uint8_t pad = 0; pad < PAD_CNT; ++pad) {
		uint8_t note = 0x1E + pad;
		g_configuration.note[pad] = note;
	}

	// Setup MultiplexSelection Pins
	pinMode(PIN_MULTIPLEX_A, OUTPUT);
	pinMode(PIN_MULTIPLEX_B, OUTPUT);
	pinMode(PIN_MULTIPLEX_C, OUTPUT);

	// Setup ADCs
	analogReference(DEFAULT);
	disableAnalogComparator();
	setPrescaler(Prescaler_8);
	//setADAlignment(ADAlignmentLeft);

	// Disable digital input buffers on all analog input pins
	DIDR0 = DIDR0 | B00111111;

	// Setup Serial
	Serial.begin(2000000);
	Serial.flush();

	g_runtime.softSerial.begin(31250);
	//g_runtime.softSerial.flush();
}


//=================================================================================
//
//=================================================================================
void loop() {
	uint64_t& frameCounter = g_runtime.frameCounter;
	size_t curFrameIdx = frameCounter % FRAME_BUFFER_SIZE;
	size_t lastFrameIdx = (frameCounter - 1) % FRAME_BUFFER_SIZE;

	for(uint8_t chan = 0; chan < CHAN_PER_PORT_CNT; ++chan) {
		multiplexSelectChan(chan);

		for(uint8_t port = 0; port < PORT_CNT; ++port) {
			int pad = port * CHAN_PER_PORT_CNT + chan;

			// shortcuts!
			uint8_t& currentValue = g_runtime.value[pad][curFrameIdx];
			const uint8_t& lastValue = g_runtime.value[pad][lastFrameIdx];

			Runtime::State& state = g_runtime.state[pad];
			uint8_t& triggerFrame = g_runtime.trigger[pad];
			uint8_t& maxValue = g_runtime.max[pad];
			//const uint8_t& sumValue = g_runtime.sum[pad];

			const Configuration::Type& type = g_configuration.type[pad];
			const uint8_t& threshold = g_configuration.threshold[pad];
			const uint8_t& scanTime = g_configuration.scanTime[pad];
			const uint8_t& maskTime = g_configuration.maskTime[pad];

			// real processing
			currentValue = uint8_t(analogRead(port) >> 3);

			switch(type) {
				case Configuration::TypePiezo: {
					switch(state) {
						// In this state we wait for a signal to trigger
						default:
						case Runtime::StateAwait: {
STATE_AGAIN:

							if(currentValue < lastValue + threshold) {
								break;
							}

							state = Runtime::StateScan;
							triggerFrame = frameCounter;
							maxValue = currentValue;
							//sumValue = currentValue;
							//### fallthrough
						}

						// In this state we measure the value for the given time period to get the max value
						case Runtime::StateScan: {
							if(frameCounter < triggerFrame + scanTime) {
								maxValue = max(currentValue, maxValue);
								//sumValue += currentValue;
								break;
							}

							const Configuration::CurveSettings& curve = g_configuration.curve[pad];
							uint8_t velocity = calcCurve(curve, maxValue);

							const uint8_t& note = g_configuration.note[pad];
							midi::noteOn(g_runtime.softSerial, note, velocity);
							state = Runtime::StateMask;
#if USE_DISPLAY
							g_runtime.displayTriggerEvent[pad] = true;
#endif
							//### fallthrough
						}

						// In this state we do nothing to prevent retriggering
						case Runtime::StateMask: {
							if(frameCounter < triggerFrame + scanTime + maskTime) {
								break;
							}

							state = Runtime::StateAwait;
							//goto STATE_AGAIN;
						}
					}
				}
			}
		}
	}

#if USE_DISPLAY

	if(frameCounter % 1000 == 0) {
		lcd.clear();

		lcd.setCursor(0, 0);

		switch(g_configuration.type[0]) {
			default:
			case Configuration::TypeDisabled: {
				lcd.print("Off");
				break;
			}

			case Configuration::TypePiezo: {
				lcd.print("Piez");
				break;
			}
		}

		lcd.setCursor(5, 0);
		lcd.print(g_configuration.note[0]);
		lcd.setCursor(9, 0);
		lcd.print(g_configuration.scanTime[0]);
		lcd.setCursor(13, 0);
		lcd.print(g_configuration.threshold[0]);


		lcd.setCursor(0, 1);
		lcd.print("CurV:");
		lcd.setCursor(6, 1);
		lcd.print(g_runtime.value[0][curFrameIdx]);

		lcd.setCursor(11, 1);

		switch(g_runtime.state[0]) {
			default:
			case Runtime::StateAwait: {
				lcd.print("A");
				break;
			}

			case Runtime::StateScan: {
				lcd.print("S");
				break;
			}

			case Runtime::StateMask: {
				lcd.print("M");
				break;
			}
		}

		lcd.setCursor(13, 1);

		if(g_runtime.displayTriggerEvent[0]) {

			lcd.print("[x]");
		}
		else {
			lcd.print("[ ]");
		}
	}

	if(frameCounter % 1000 == 0) {
		memset(g_runtime.displayTriggerEvent, 0, sizeof(g_runtime.displayTriggerEvent));
	}

#endif

	++frameCounter;
}