ComputerCard.h

/*
ComputerCard  - by Chris Johnson

version 0.3.0   -  12 May 2026

ComputerCard is a header-only C++ library, providing a class that
manages the hardware aspects of the Music Thing Modular Workshop
System Computer.

It aims to present a very simple C++ interface for card programmers 
to use the jacks, knobs, switch and LEDs, for programs running at
a fixed 48kHz audio sample rate.

See examples/ directory
*/


#ifndef COMPUTERCARD_H
#define COMPUTERCARD_H

#include "hardware/gpio.h"
#include "hardware/pwm.h"

#define PULSE_1_RAW_OUT 8
#define PULSE_2_RAW_OUT 9

#define CV_OUT_1 23
#define CV_OUT_2 22

// USB host status pin
#define USB_HOST_STATUS 20

class ComputerCard
{
	constexpr static int numLeds = 6;
	constexpr static uint8_t leds[numLeds] = { 10, 11, 12, 13, 14, 15 };
public:

	/// Knob index, used by KnobVal
	enum Knob {Main, X, Y};
	/// Switch position, used by SwitchVal
	enum Switch {Down, Middle, Up};
	/// Input jack socket, used by Connected and Disconnected
	enum Input {Audio1, Audio2, CV1, CV2, Pulse1, Pulse2};
	/// Hardware version
	enum HardwareVersion_t {Proto1=0x2a, Proto2_Rev1=0x30, Rev1_1=0x0C, Unknown=0xFF};
	/// USB Power state
	enum USBPowerState_t {DFP, UFP, Unsupported};

	ComputerCard();

	/** \brief Start audio processing.

        The Run method starts audio processing, calling ProcessSample using an interrupt.
        Run is a blocking function (it never returns)
	*/
	void Run()
	{
		ComputerCard::thisptr = this;
		AudioWorker();
	}

	/// Use before Run() to enable Connected/Disconnected detection
	void EnableNormalisationProbe() {useNormProbe = true;}

	static ComputerCard *ThisPtr() {return thisptr;}

	// Call from the OTHER core to fully pause this core's audio/panel
	// interrupt servicing (DMA_IRQ_0 and PWM_IRQ_WRAP) - e.g. for the
	// duration of a flash erase/program. ProcessSample is a virtual call,
	// dispatched through a vtable that (like any const/rodata) lives in
	// flash; merely making ProcessSample's own code RAM-resident does not
	// make that vtable read safe during a flash write. Actually disabling
	// the IRQs (so BufferFull/AudioCallback never run at all, vtable lookup
	// included) is the only way to make this fully safe. Ported verbatim
	// from EvoSeq's ComputerCard.h (~/projects/evo_sequencer/) - proven
	// working in production; see RP2040_dual_core_flash_safety_notes.md.
	//
	// This is a hand-rolled equivalent of multicore_lockout, using plain
	// polling instead of the SDK's SIO-FIFO-based mechanism - the latter
	// was found to break USB enumeration entirely on this hardware/SDK
	// combination. irq_set_enabled() must be called from the core that
	// owns the NVIC entry, so the actual disable happens inside
	// AudioWorker()'s loop on this core, in response to the request below.
	void RequestPause()
	{
		pauseRequested = true;
		while (!paused) { tight_loop_contents(); }
	}

	void ReleasePause()
	{
		pauseRequested = false;
		while (paused) { tight_loop_contents(); }
	}

protected:

	class NotchFilter
	{
	public:
		NotchFilter()
		{
			mix1 = mix2 = mixf1 = mixf2 = 0;
		}
		int32_t operator()(int32_t val)
		{
			int32_t mixf = (ooa0 * (val + mix2) - a2oa0 * mixf2) >> 14;
			mix2 = mix1;
			mix1 = val;
			mixf2 = mixf1;
			mixf1 = mixf;
			return mixf;
		}
	private:
		// 12kHz notch filter, to remove interference from mux lines
		int32_t mix1, mix2, mixf1, mixf2;
		static constexpr int32_t ooa0 = 16302, a2oa0 = 16221; // Q = 100, very narrow notch
		
	};

	NotchFilter notchLeft, notchRight;
	
	/// Callback, called once per sample at 48kHz
	virtual void ProcessSample() = 0;




	/// Read knob position (returns 0-4095)
	int32_t __not_in_flash_func(KnobVal)(Knob ind) {return knobs[ind];}

	/// Read switch position
	Switch __not_in_flash_func(SwitchVal)() {return switchVal;}

	/// Read switch position
	bool __not_in_flash_func(SwitchChanged)() {return switchVal != lastSwitchVal;}


	/// Set Audio output (values -2048 to 2047)
	void __not_in_flash_func(AudioOut)(int i, int16_t val)
	{
		dacOut[i] = val;
	}
	
	/// Set Audio 1 output (values -2048 to 2047)
	void __not_in_flash_func(AudioOut1)(int16_t val)
	{
		dacOut[0] = val;
	}
	
	/// Set Audio 2 output (values -2048 to 2047)
	void __not_in_flash_func(AudioOut2)(int16_t val)
	{
		dacOut[1] = val;
	}

	
	/// Set CV output (values -2048 to 2047)
	void __not_in_flash_func(CVOut)(int i, int16_t val)
	{
		if (val<-2048) val = -2048;
		if (val > 2047) val = 2047;
		cvValue[i] = (2047-val)*125;
	}
	
	/// Set CV 1 output (values -2048 to 2047)
	void __not_in_flash_func(CVOut1)(int16_t val)
	{
		if (val<-2048) val = -2048;
		if (val > 2047) val = 2047;
		cvValue[0] = (2047-val)*125;
	}
	
	/// Set CV 2 output (values -2048 to 2047)
	void __not_in_flash_func(CVOut2)(int16_t val)
	{
		if (val<-2048) val = -2048;
		if (val > 2047) val = 2047;
		cvValue[1] = (2047-val)*125;
	}

		
	/// Set CV output (values -262144 to 262143)
	void __not_in_flash_func(CVOutPrecise)(int i, int32_t val)
	{
		if (val<-262144) val = -262144;
		if (val > 262143) val = 262143;
		cvValue[i] = ((262143-val)*125)>>7;
	}
	
	/// Set CV 1 output (values -262144 to 262143)
	void __not_in_flash_func(CVOut1Precise)(int32_t val)
	{
		if (val<-262144) val = -262144;
		if (val > 262143) val = 262143;
		cvValue[0] = ((262143-val)*125)>>7;
	}
	
	/// Set CV 2 output (values -262144 to 262143)
	void __not_in_flash_func(CVOut2Precise)(int32_t val)
	{
		if (val<-262144) val = -262144;
		if (val > 262143) val = 262143;
		cvValue[1] = ((262143-val)*125)>>7;
	}

	/// Set CV 1 output from calibrated MIDI note number (values 0 to 127)
	void __not_in_flash_func(CVOutMIDINote)(int i, uint8_t noteNum)
	{
		cvValue[i] = MIDIToDAC(noteNum, i);
	}
	
	/// Set CV 1 output from calibrated MIDI note number (values 0 to 127)
	void __not_in_flash_func(CVOut1MIDINote)(uint8_t noteNum)
	{
		cvValue[0] = MIDIToDAC(noteNum, 0);
	}
	
	/// Set CV 2 output from calibrated MIDI note number (values 0 to 127)
	void __not_in_flash_func(CVOut2MIDINote)(uint8_t noteNum)
	{
		cvValue[1] = MIDIToDAC(noteNum, 1);
	}

	
	/// Set CV 1 output from calibrated MIDI note number (values 0 to 127)
	bool __not_in_flash_func(CVOutMillivolts)(int i, int32_t millivolts)
	{
		bool limited = false;
		cvValue[i] = MillivoltsToDAC(millivolts, i, limited);
		return limited;
	}
	
	/// Set CV 1 output from calibrated MIDI note number (values 0 to 127)
	bool __not_in_flash_func(CVOut1Millivolts)(int32_t millivolts)
	{
		bool limited = false;
		cvValue[0] = MillivoltsToDAC(millivolts, 0, limited);
		return limited;
	}
	
	/// Set CV 2 output from calibrated MIDI note number (values 0 to 127)
	bool __not_in_flash_func(CVOut2Millivolts)(int32_t millivolts)
	{
		bool limited = false;
		cvValue[1] = MillivoltsToDAC(millivolts, 1, limited);
		return limited;
	}

	
	/// Set Pulse output (true = on)
	void __not_in_flash_func(PulseOut)(int i, bool val)
	{
		gpio_put(PULSE_1_RAW_OUT + i, !val);
	}
	
	/// Set Pulse 1 output (true = on)
	void __not_in_flash_func(PulseOut1)(bool val)
	{
		gpio_put(PULSE_1_RAW_OUT, !val);
	}
	
	/// Set Pulse 2 output (true = on)
	void __not_in_flash_func(PulseOut2)(bool val)
	{
		gpio_put(PULSE_2_RAW_OUT, !val);
	}
	
	/// Return audio in (-2048 to 2047)
	int16_t __not_in_flash_func(AudioIn)(int i){return i?adcInR:adcInL;}
	
	/// Return audio in 1 (-2048 to 2047)
	int16_t __not_in_flash_func(AudioIn1)(){return adcInL;}

	/// Return audio in 1 (-2048 to 2047)
	int16_t __not_in_flash_func(AudioIn2)(){return adcInR;}

	/// Return CV in (-2048 to 2047)
	int16_t __not_in_flash_func(CVIn)(int i){return cv[i];}
	
	/// Return CV in 1 (-2048 to 2047)
	int16_t __not_in_flash_func(CVIn1)(){return cv[0];}

	/// Return CV in 2 (-2048 to 2047)
	int16_t __not_in_flash_func(CVIn2)(){return cv[1];}

	/// Read pulse in
	bool __not_in_flash_func(PulseIn)(int i){return pulse[i];}
	/// Return true for one sample on pulse rising edge
	bool __not_in_flash_func(PulseInRisingEdge)(int i){return pulse[i] && !last_pulse[i];}
	/// Return true for one sample on pulse falling edge
	bool __not_in_flash_func(PulseInFallingEdge)(int i){return !pulse[i] && last_pulse[i];}

	/// Read pulse in 1
	bool __not_in_flash_func(PulseIn1)(){return pulse[0];}
	/// Return true for one sample on pulse 1 rising edge
	bool __not_in_flash_func(PulseIn1RisingEdge)(){return pulse[0] && !last_pulse[0];}
	/// Return true for one sample on pulse 1 falling edge
	bool __not_in_flash_func(PulseIn1FallingEdge)(){return !pulse[0] && last_pulse[0];}

	/// Read pulse in 2
	bool __not_in_flash_func(PulseIn2)(){return pulse[1];}
	/// Return true for one sample on pulse 2 falling edge
	bool __not_in_flash_func(PulseIn2FallingEdge)(){return !pulse[1] && last_pulse[1];}
	/// Return true for one sample on pulse 2 rising edge
	bool __not_in_flash_func(PulseIn2RisingEdge)(){return pulse[1] && !last_pulse[1];}


	/// Return true if jack connected to input
	bool __not_in_flash_func(Connected)(Input i){return connected[i];}
	/// Return true if no jack connected to input
	bool __not_in_flash_func(Disconnected)(Input i){return !connected[i];}


	/// Set LED brightness, values 0-4095
	// Led numbers are:
	// 0 1
	// 2 3
	// 4 5
	void __not_in_flash_func(LedBrightness)(uint32_t index, uint16_t value)
	{
		pwm_set_gpio_level(leds[index], (value*value)>>8);
	}
	
	/// Turn LED on/off
	void __not_in_flash_func(LedOn)(uint32_t index, bool value = true)
	{
		pwm_set_gpio_level(leds[index], value?65535:0);
	}

	/// Turn LED off
	void __not_in_flash_func(LedOff)(uint32_t index)
	{
		pwm_set_gpio_level(leds[index], 0);
	}

	// Return power state of USB port
	USBPowerState_t USBPowerState()
	{
		if (HardwareVersion() != Rev1_1)
			return Unsupported;
		else if (gpio_get(USB_HOST_STATUS))
			return UFP;
		else
			return DFP;
	}

	/// Return hardware version
	HardwareVersion_t HardwareVersion() const
	{
		return hw;
	}

	/// Return ID number unique to flash card
	uint64_t UniqueCardID()	const
	{
		return uniqueID;
	}	

	/// Return true iff CV outputs are calibrated.
	/// Returns false if using default calibration values.
	bool CVOutsCalibrated() const
	{
		return cvOutsCalibrated;
	}

	
	void Abort();

	uint16_t CRCencode(const uint8_t *data, int length);

private:
	
	typedef struct
	{
		float m, b;
		int32_t mi, bi;
	} CalCoeffs;

	typedef struct
	{
		int32_t dacSetting;
		int8_t voltage;
	} CalPoint;

	static constexpr int calMaxChannels = 2;
	static constexpr int calMaxPoints = 10;

	static volatile uint32_t cvValue[2];
	
	uint8_t numCalibrationPoints[calMaxChannels];
	CalPoint calibrationTable[calMaxChannels][calMaxPoints];
	CalCoeffs calCoeffs[calMaxChannels];

	uint64_t uniqueID;
	
	uint8_t ReadByteFromEEPROM(unsigned int eeAddress, bool &failed);
	int ReadIntFromEEPROM(unsigned int eeAddress, bool &failed);
	void CalcCalCoeffs(int channel);
	int ReadEEPROM();
	uint32_t MIDIToDAC(int midiNote, int channel);
	uint32_t MillivoltsToDAC(int millivolts, int channel, bool &limited);
	
	HardwareVersion_t hw;
	HardwareVersion_t ProbeHardwareVersion();
	
	int16_t dacOut[2];
	
	volatile int32_t knobs[4] = { 0, 0, 0, 0 }; // 0-4095
	volatile bool pulse[2] = { 0, 0 };
	volatile bool last_pulse[2] = { 0, 0 };
	volatile int32_t cv[2] = { 0, 0 }; // -2047 - 2048
	volatile int16_t adcInL = 0x800, adcInR = 0x800;

	volatile uint8_t mxPos = 0; // external multiplexer value

	volatile int32_t plug_state[6] = {0,0,0,0,0,0};
	volatile bool connected[6] = {0,0,0,0,0,0};
	bool useNormProbe;

	Switch switchVal, lastSwitchVal;
	
	volatile uint8_t runADCMode;

	// See RequestPause()/ReleasePause() above.
	volatile bool pauseRequested = false;
	volatile bool paused = false;

	bool cvOutsCalibrated;

// Buffers that DMA reads into / out of
	uint16_t ADC_Buffer[2][8];
	uint16_t SPI_Buffer[2][2];

	uint8_t adc_dma, spi_dma; // DMA ids



	uint8_t dmaPhase = 0;

	// Convert signed int16 value into data string for DAC output
	uint16_t __not_in_flash_func(dacval)(int16_t value, uint16_t dacChannel)
	{
		if (value<-2048) value = -2048;
		if (value > 2047) value = 2047;
		return (dacChannel | 0x3000) | (((uint16_t)((value & 0x0FFF) + 0x800)) & 0x0FFF);
	}
	uint32_t next_norm_probe();

	
    void CorrectADCDNL(uint16_t &value) const;
	
	void BufferFull();

	void AudioWorker();
	
	static void AudioCallback()
	{
		thisptr->BufferFull();
	}
	static ComputerCard *thisptr;

	// 19-bit CV outputs
	static void OnCVPWMWrap()
	{
		static int32_t error1 = 0, error2 = 0;

		pwm_clear_irq(pwm_gpio_to_slice_num(CV_OUT_1)); // clear the interrupt flag
		uint32_t truncated_cv1_val = (cvValue[0]-error1) & 0xFFFFFF00;
		error1 += truncated_cv1_val - cvValue[0];
		pwm_set_gpio_level(CV_OUT_1, (truncated_cv1_val>>8));
		uint32_t truncated_cv2_val = (cvValue[1]-error2) & 0xFFFFFF00;
		error2 += truncated_cv2_val - cvValue[1];
		pwm_set_gpio_level(CV_OUT_2, (truncated_cv2_val>>8));
	}

};


#ifndef COMPUTERCARD_NOIMPL


#include "hardware/adc.h"
#include "hardware/clocks.h"
#include "hardware/dma.h"
#include "hardware/flash.h"
#include "hardware/i2c.h"
#include "hardware/irq.h"
#include "hardware/spi.h"

// Input normalisation probe pin
#define NORMALISATION_PROBE 4

// Mux pins
#define MX_A 24
#define MX_B 25

// ADC input pins
#define AUDIO_L_IN_1 27
#define AUDIO_R_IN_1 26
#define MUX_IO_1 28
#define MUX_IO_2 29

#define DAC_CHANNEL_A 0x0000
#define DAC_CHANNEL_B 0x8000

#define DAC_CS 21
#define DAC_SCK 18
#define DAC_TX 19

#define EEPROM_SDA 16
#define EEPROM_SCL 17

#define PULSE_1_INPUT 2
#define PULSE_2_INPUT 3

#define DEBUG_1 0
#define DEBUG_2 1

#define SPI_PORT spi0
#define SPI_DREQ DREQ_SPI0_TX


#define BOARD_ID_0 7
#define BOARD_ID_1 6
#define BOARD_ID_2 5

// The ADC (/DMA) run mode, used to stop DMA in a known state before writing to flash
#define RUN_ADC_MODE_RUNNING 0
#define RUN_ADC_MODE_REQUEST_ADC_STOP 1
#define RUN_ADC_MODE_ADC_STOPPED 2
#define RUN_ADC_MODE_REQUEST_ADC_RESTART 3


#define EEPROM_ADDR_ID 0
#define EEPROM_ADDR_VERSION 2
#define EEPROM_ADDR_CRC_L 87
#define EEPROM_ADDR_CRC_H 86
#define EEPROM_VAL_ID 2001
#define EEPROM_NUM_BYTES 88

#define EEPROM_PAGE_ADDRESS 0x50


// Initialise CV output delta-sigma target to half-way (near 0V)
volatile uint32_t ComputerCard::cvValue[2] = {262144,262144};


ComputerCard *ComputerCard::thisptr;

// Return pseudo-random bit for normalisation probe
uint32_t __not_in_flash_func(ComputerCard::next_norm_probe)()
{
	static uint32_t lcg_seed = 1;
	lcg_seed = 1664525 * lcg_seed + 1013904223;
	return lcg_seed >> 31;
}

// Main audio core function
void __not_in_flash_func(ComputerCard::AudioWorker)()
{

	adc_select_input(0);
	adc_set_round_robin(0b0001111U);

	// enabled, with DMA request when FIFO contains data, no erro flag, no byte shift
	adc_fifo_setup(true, true, 1, false, false);


	// ADC clock runs at 48MHz
	// 48MHz ÷ (124+1) = 384kHz ADC sample rate
	//                 = 8×48kHz audio sample rate
	adc_set_clkdiv(124);

	// claim and setup DMAs for reading to ADC, and writing to SPI DAC
	adc_dma = dma_claim_unused_channel(true);
	spi_dma = dma_claim_unused_channel(true);

	dma_channel_config adc_dmacfg, spi_dmacfg;
	adc_dmacfg = dma_channel_get_default_config(adc_dma);
	spi_dmacfg = dma_channel_get_default_config(spi_dma);

	// Reading from ADC into memory buffer, so increment on write, but no increment on read
	channel_config_set_transfer_data_size(&adc_dmacfg, DMA_SIZE_16);
	channel_config_set_read_increment(&adc_dmacfg, false);
	channel_config_set_write_increment(&adc_dmacfg, true);

	// Synchronise ADC DMA the ADC samples
	channel_config_set_dreq(&adc_dmacfg, DREQ_ADC);

	// Setup DMA for 8 ADC samples
	dma_channel_configure(adc_dma, &adc_dmacfg, ADC_Buffer[dmaPhase], &adc_hw->fifo, 8, true);

	// Turn on IRQ for ADC DMA
	dma_channel_set_irq0_enabled(adc_dma, true);

	// Call buffer_full ISR when ADC DMA finished
	irq_set_enabled(DMA_IRQ_0, true);
	irq_set_exclusive_handler(DMA_IRQ_0, ComputerCard::AudioCallback);


	// Turn on IRQ for CV output PWM
	uint slice_num = pwm_gpio_to_slice_num(CV_OUT_1);
	pwm_clear_irq(slice_num);
	pwm_set_irq_enabled(slice_num, true);
	
	irq_set_exclusive_handler(PWM_IRQ_WRAP, ComputerCard::OnCVPWMWrap);
	irq_set_priority(PWM_IRQ_WRAP, 255);
	irq_set_enabled(PWM_IRQ_WRAP, true);

	
	// Set up DMA for SPI
	spi_dmacfg = dma_channel_get_default_config(spi_dma);
	channel_config_set_transfer_data_size(&spi_dmacfg, DMA_SIZE_16);

	// SPI DMA timed to SPI TX
	channel_config_set_dreq(&spi_dmacfg, SPI_DREQ);

	// Set up DMA to transmit 2 samples to SPI
	dma_channel_configure(spi_dma, &spi_dmacfg, &spi_get_hw(SPI_PORT)->dr, NULL, 2, false);

	adc_run(true);

	while (1)
	{
		// If ready to restart
		if (runADCMode == RUN_ADC_MODE_REQUEST_ADC_RESTART)
		{
			runADCMode = RUN_ADC_MODE_RUNNING;

			dma_hw->ints0 = 1u << adc_dma; // reset adc interrupt flag
			dma_channel_set_write_addr(adc_dma, ADC_Buffer[dmaPhase], true); // start writing into new buffer
			dma_channel_set_read_addr(spi_dma, SPI_Buffer[dmaPhase], true); // start reading from new buffer

			adc_set_round_robin(0);
			adc_select_input(0);
			adc_set_round_robin(0b0001111U);
			adc_run(true);
		}
		else if (runADCMode == RUN_ADC_MODE_ADC_STOPPED)
		{
			// We can't remove the PWM IRQ from within the ADC IRQ callback, so we do it here instead.
			irq_set_enabled(PWM_IRQ_WRAP, false);
			pwm_clear_irq(pwm_gpio_to_slice_num(CV_OUT_1)); // reset CV PWM interrupt flag
			irq_remove_handler(PWM_IRQ_WRAP, ComputerCard::OnCVPWMWrap);
			break;
		}

		// See RequestPause()/ReleasePause(). Disabling these IRQs (rather
		// than just hoping the handler code is RAM-resident) is what
		// actually stops BufferFull/AudioCallback from running at all -
		// including the virtual ProcessSample() dispatch, which reads a
		// vtable that lives in flash regardless of where ProcessSample's
		// own code is placed. Ported verbatim from EvoSeq's ComputerCard.h.
		if (pauseRequested)
		{
			irq_set_enabled(DMA_IRQ_0, false);
			irq_set_enabled(PWM_IRQ_WRAP, false);
			paused = true;
			while (pauseRequested) { tight_loop_contents(); }
			irq_set_enabled(DMA_IRQ_0, true);
			irq_set_enabled(PWM_IRQ_WRAP, true);
			paused = false;
		}

	}
}

void ComputerCard::Abort()
{
	runADCMode = RUN_ADC_MODE_REQUEST_ADC_STOP;
}

void __not_in_flash_func(ComputerCard::CorrectADCDNL)(uint16_t &value) const
{
	uint16_t adc512 = value + 512;
	value += ((value & 0x3FF) == 0x1FF) << 2;
	value += (adc512 >> 10) << 3;
	value = uint32_t(value * 520349) >> 19; // Multiply by factor that maps 0-4095 input into 0-4095 output
}

// Per-audio-sample ISR, called when two sets of ADC samples have been collected from all four inputs
void __not_in_flash_func(ComputerCard::BufferFull)()
{
	static int startupCounter = 8; // Decreases by 1 each sample, can do startup things when nonzero.
	static int mux_state = 0;
	static int norm_probe_count = 0;

	// Internal variables for IIR filters on knobs/cv
	static volatile int32_t knobssm[4] = { 0, 0, 0, 0 };
	static volatile int32_t cvsm[2] = { 0, 0 };
	__attribute__((unused)) static int np = 0, np1 = 0, np2 = 0;

	adc_select_input(0);

	// Advance external mux to next state
	int next_mux_state = (mux_state + 1) & 0x3;
	gpio_put(MX_A, next_mux_state & 1);
	gpio_put(MX_B, next_mux_state & 2);

	// Set up new writes into next buffer
	uint8_t cpuPhase = dmaPhase;
	dmaPhase = 1 - dmaPhase;

	dma_hw->ints0 = 1u << adc_dma; // reset adc interrupt flag
	dma_channel_set_write_addr(adc_dma, ADC_Buffer[dmaPhase], true); // start writing into new buffer
	dma_channel_set_read_addr(spi_dma, SPI_Buffer[dmaPhase], true); // start reading from new buffer

	////////////////////////////////////////
	// Collect various inputs and put them in variables for the DSP

	// Set CV inputs, with ~240Hz LPF on CV input
	int cvi = mux_state % 2;

	// Compensation of ADC DNL errors.
	CorrectADCDNL(ADC_Buffer[cpuPhase][7]); // CV inputs
	CorrectADCDNL(ADC_Buffer[cpuPhase][0]); // Audio inputs
	CorrectADCDNL(ADC_Buffer[cpuPhase][4]);
	CorrectADCDNL(ADC_Buffer[cpuPhase][1]);
	CorrectADCDNL(ADC_Buffer[cpuPhase][5]);
	
	cvsm[cvi] = (15 * (cvsm[cvi]) + 16 * ADC_Buffer[cpuPhase][7]) >> 4;
	cv[cvi] = 2048 - (cvsm[cvi] >> 4);


	// Set audio inputs, by averaging the two samples collected.
	// Invert to counteract inverting op-amp input configuration
	adcInR = -(((ADC_Buffer[cpuPhase][0] + ADC_Buffer[cpuPhase][4]) - 0x1000) >> 1);
	adcInL = -(((ADC_Buffer[cpuPhase][1] + ADC_Buffer[cpuPhase][5]) - 0x1000) >> 1);

	// 12kHz notch filters
	adcInR = notchRight(adcInR);
	adcInL = notchLeft(adcInL);
	
	// Set pulse inputs
	last_pulse[0] = pulse[0];
	last_pulse[1] = pulse[1];
	pulse[0] = !gpio_get(PULSE_1_INPUT);
	pulse[1] = !gpio_get(PULSE_2_INPUT);

	// Set knobs, with ~60Hz LPF
	int knob = mux_state;
	knobssm[knob] = (127 * (knobssm[knob]) + 16 * ADC_Buffer[cpuPhase][6]) >> 7;
	knobs[knob] = knobssm[knob] >> 4;

	// Set switch value
	switchVal = static_cast<Switch>((knobs[3]>1000) + (knobs[3]>3000));
	if (startupCounter)
	{
		// Don't detect switch changes in first few cycles
		lastSwitchVal = switchVal;
		// Should initialise knob and CV smoothing filters here too
	}
	
	////////////////////////////
	// Normalisation probe

	if (useNormProbe)
	{
		// Set normalisation probe output value
		// and update np to the expected history string
		if (norm_probe_count == 0)
		{
			int32_t normprobe = next_norm_probe();
			gpio_put(NORMALISATION_PROBE, normprobe);
			np = (np<<1)+(normprobe&0x1);
		}

		// CV sampled at 24kHz comes in over two successive samples
		if (norm_probe_count == 14 || norm_probe_count == 15)
		{
			plug_state[2+cvi] = (plug_state[2+cvi]<<1)+(ADC_Buffer[cpuPhase][7]<1800);
		}

		// Audio and pulse measured every sample at 48kHz
		if (norm_probe_count == 15)
		{
			plug_state[Input::Audio1] = (plug_state[Input::Audio1]<<1)+(ADC_Buffer[cpuPhase][5]<1800);
			plug_state[Input::Audio2] = (plug_state[Input::Audio2]<<1)+(ADC_Buffer[cpuPhase][4]<1800);
			plug_state[Input::Pulse1] = (plug_state[Input::Pulse1]<<1)+(pulse[0]);
			plug_state[Input::Pulse2] = (plug_state[Input::Pulse2]<<1)+(pulse[1]);

			for (int i=0; i<6; i++)
			{
				connected[i] = (np != plug_state[i]);
			}
		}
		
		// Force disconnected values to zero, rather than the normalisation probe garbage
		if (Disconnected(Input::Audio1)) adcInL = 0;
		if (Disconnected(Input::Audio2)) adcInR = 0;
		if (Disconnected(Input::CV1)) cv[0] = 0;
		if (Disconnected(Input::CV2)) cv[1] = 0;
		if (Disconnected(Input::Pulse1)) pulse[0] = 0;
		if (Disconnected(Input::Pulse2)) pulse[1] = 0;
	}
	
	////////////////////////////////////////
	// Run the DSP
	ProcessSample();

	////////////////////////////////////////
	// Collect DSP outputs and put them in the DAC SPI buffer
	// CV/Pulse outputs are done immediately in ProcessSample

	// Invert dacout to counteract inverting output configuration
	SPI_Buffer[cpuPhase][0] = dacval(-dacOut[0], DAC_CHANNEL_A);
	SPI_Buffer[cpuPhase][1] = dacval(-dacOut[1], DAC_CHANNEL_B);

	mux_state = next_mux_state;

	// If Abort called, stop ADC and DMA
	if (runADCMode == RUN_ADC_MODE_REQUEST_ADC_STOP)
	{
		adc_run(false);
		adc_set_round_robin(0);
		adc_select_input(0);

		dma_hw->ints0 = 1u << adc_dma; // reset adc interrupt flag
		dma_channel_cleanup(adc_dma);
		dma_channel_cleanup(spi_dma);
		irq_set_enabled(DMA_IRQ_0, false);
		irq_remove_handler(DMA_IRQ_0, ComputerCard::AudioCallback);


		
		runADCMode = RUN_ADC_MODE_ADC_STOPPED;
	}

	norm_probe_count = (norm_probe_count + 1) & 0xF;

	lastSwitchVal = switchVal;
	
	if (startupCounter) startupCounter--;
}

ComputerCard::HardwareVersion_t ComputerCard::ProbeHardwareVersion()
{
	// Enable pull-downs, and measure
	gpio_set_pulls(BOARD_ID_0, false, true);
	gpio_set_pulls(BOARD_ID_1, false, true);
	gpio_set_pulls(BOARD_ID_2, false, true);
	sleep_us(1);

	// Pull-down state in bits 0, 2, 4
	uint8_t pd = gpio_get(BOARD_ID_0) | (gpio_get(BOARD_ID_1) << 2) | (gpio_get(BOARD_ID_2) << 4);
	
	// Enable pull-ups, and measure
	gpio_set_pulls(BOARD_ID_0, true, false);
	gpio_set_pulls(BOARD_ID_1, true, false);
	gpio_set_pulls(BOARD_ID_2, true, false);
	sleep_us(1);

	// Pull-up state in bits 1, 3, 5
	uint8_t pu = (gpio_get(BOARD_ID_0) << 1) | (gpio_get(BOARD_ID_1) << 3) | (gpio_get(BOARD_ID_2) << 5);

	// Combine to give 6-bit ID
	uint8_t id = pd | pu;

	// Set pull-downs
	gpio_set_pulls(BOARD_ID_0, false, true);
	gpio_set_pulls(BOARD_ID_1, false, true);
	gpio_set_pulls(BOARD_ID_2, false, true);

	switch (id)
	{
	case Proto1:
	case Proto2_Rev1:
	case Rev1_1:
		return static_cast<ComputerCard::HardwareVersion_t>(id);
	default:
		return Unknown;
	}
}

ComputerCard::ComputerCard()
{
	runADCMode = RUN_ADC_MODE_RUNNING;

	adc_run(false);
	adc_select_input(0);


	useNormProbe = false;
	for (int i=0; i<6; i++)
	{
		connected[i] = false;
	}

	
	////////////////////////////////////////
	// Initialise LEDs (PWM, set up in pairs due pinout and PWM hardware)
	for (int i = 0; i < numLeds; i+=2)
	{	
		gpio_set_function(leds[i], GPIO_FUNC_PWM);
		gpio_set_function(leds[i]+1, GPIO_FUNC_PWM);

		// now create PWM config struct
		pwm_config config = pwm_get_default_config();
		pwm_config_set_wrap(&config, 65535); // 16-bit PWM


		// now set this PWM config to apply to the two outputs
		pwm_init(pwm_gpio_to_slice_num(leds[i]), &config, true); 
		pwm_init(pwm_gpio_to_slice_num(leds[i]+1), &config, true); 

		// set initial level 
		pwm_set_gpio_level(leds[i], 0);
		pwm_set_gpio_level(leds[i]+1, 0);
	}

	
	////////////////////////////////////////
	// Initialise knobs / audio in / CV in (ADC + Mux)
	
	adc_init(); // Initialize the ADC

	// Set ADC pins
	adc_gpio_init(AUDIO_L_IN_1);
	adc_gpio_init(AUDIO_R_IN_1);
	adc_gpio_init(MUX_IO_1);
	adc_gpio_init(MUX_IO_2);

	// Initialize Mux Control pins
	gpio_init(MX_A);
	gpio_init(MX_B);
	gpio_set_dir(MX_A, GPIO_OUT);
	gpio_set_dir(MX_B, GPIO_OUT);

	
	////////////////////////////////////////

	gpio_init(PULSE_1_RAW_OUT);
	gpio_set_dir(PULSE_1_RAW_OUT, GPIO_OUT);
	gpio_put(PULSE_1_RAW_OUT, true); // set raw value high (output low)

	
	gpio_init(PULSE_2_RAW_OUT);
	gpio_set_dir(PULSE_2_RAW_OUT, GPIO_OUT);
	gpio_put(PULSE_2_RAW_OUT, true); // set raw value high (output low)


	////////////////////////////////////////
	// Initialise pulse inputs
	gpio_init(PULSE_1_INPUT);
	gpio_set_dir(PULSE_1_INPUT, GPIO_IN);
	gpio_pull_up(PULSE_1_INPUT); // NB Needs pullup to activate transistor on inputs

	gpio_init(PULSE_2_INPUT);
	gpio_set_dir(PULSE_2_INPUT, GPIO_IN);
	gpio_pull_up(PULSE_2_INPUT); // NB: Needs pullup to activate transistor on inputs

	
	////////////////////////////////////////
	// Initialise audio outputs (SPI for external DAC)
	spi_init(SPI_PORT, 15625000);
	spi_set_format(SPI_PORT, 16, SPI_CPOL_0, SPI_CPHA_0, SPI_MSB_FIRST);
	gpio_set_function(DAC_SCK, GPIO_FUNC_SPI);
	gpio_set_function(DAC_TX, GPIO_FUNC_SPI);
	gpio_set_function(DAC_CS, GPIO_FUNC_SPI);


	////////////////////////////////////////
	// Initialise CV outputs
	// We set up the PWM here, and add the IRQ for sigma-delta later one Run() is called

	// First, tell the CV pins that the PWM is in charge of the value.
	gpio_set_function(CV_OUT_1, GPIO_FUNC_PWM);
	gpio_set_function(CV_OUT_2, GPIO_FUNC_PWM);

	// now create PWM config struct
	{
	pwm_config config = pwm_get_default_config();
	pwm_config_set_wrap(&config, 1999); // less than 11-bit PWM
	// now set this PWM config to apply to the two outputs
	// NB: CV_A and CV_B share the same PWM slice, which means that they share a PWM config
	// They have separate 'gpio_level's (output compare unit) though, so they can have different PWM on-times
	pwm_init(pwm_gpio_to_slice_num(CV_OUT_1), &config, true); // Slice 1, channel A
	pwm_init(pwm_gpio_to_slice_num(CV_OUT_2), &config, true); // slice 1 channel B (redundant to set up again)

	}
	// set initial level to half way (0V)
	pwm_set_gpio_level(CV_OUT_1, 1000);
	pwm_set_gpio_level(CV_OUT_2, 1000);


	////////////////////////////////////////
	// Miscellaneous pins

	// Initialise board version ID pins
	gpio_init(BOARD_ID_0);
	gpio_init(BOARD_ID_1);
	gpio_init(BOARD_ID_2);
	gpio_set_dir(BOARD_ID_0, GPIO_IN);
	gpio_set_dir(BOARD_ID_1, GPIO_IN);
	gpio_set_dir(BOARD_ID_2, GPIO_IN);
	
	// Initialise USB host status pin
	gpio_init(USB_HOST_STATUS);
	gpio_disable_pulls(USB_HOST_STATUS);

	// Initialise normalisation probe pin
	gpio_init(NORMALISATION_PROBE);
	gpio_set_dir(NORMALISATION_PROBE, GPIO_OUT);
	gpio_put(NORMALISATION_PROBE, false);
	
	// Initialise EEPROM (I2C)
	i2c_init(i2c0, 100 * 1000);
	gpio_set_function(EEPROM_SDA, GPIO_FUNC_I2C);
	gpio_set_function(EEPROM_SCL, GPIO_FUNC_I2C);

	
	// If not using UART pins for UART, instead use as debug lines
#ifndef ENABLE_UART_DEBUGGING
	// Debug pins
	gpio_init(DEBUG_1);
	gpio_set_dir(DEBUG_1, GPIO_OUT);

	gpio_init(DEBUG_2);
	gpio_set_dir(DEBUG_2, GPIO_OUT);
#endif

	// Read hardware version
	hw = ProbeHardwareVersion();
	
	// Read EEPROM calibration values
	cvOutsCalibrated = (ReadEEPROM() == 0);
	
	// Read unique card ID
	flash_get_unique_id((uint8_t *) &uniqueID);
	// Do some mixing up of the bits using full-cycle 64-bit LCG
	// Should help ensure most bytes change even if many bits of
	// the original flash unique ID are the same between flash chips.
	for (int i=0; i<20; i++)
	{
		uniqueID = uniqueID * 6364136223846793005ULL + 1442695040888963407ULL;
	}
}



// Read a byte from EEPROM
uint8_t ComputerCard::ReadByteFromEEPROM(unsigned int eeAddress, bool &failed)
{
	uint8_t deviceAddress = EEPROM_PAGE_ADDRESS | ((eeAddress >> 8) & 0x0F);
	uint8_t data = 0xFF;

	uint8_t addr_low_byte = eeAddress & 0xFF;
   
	if (i2c_write_timeout_us(i2c0, deviceAddress, &addr_low_byte, 1, false, 10000) <= 0)
	{
		failed = true;
		return 0;
	}

	if (i2c_read_timeout_us(i2c0, deviceAddress, &data, 1, false, 10000) <= 0)
	{
		failed = true;
		return 0;
	}

	return data;
}

// Read a 16-bit integer from EEPROM
int ComputerCard::ReadIntFromEEPROM(unsigned int eeAddress, bool &failed)
{
	uint8_t highByte = ReadByteFromEEPROM(eeAddress, failed);
	uint8_t lowByte = ReadByteFromEEPROM(eeAddress + 1, failed);

	return (highByte << 8) | lowByte;
}

uint16_t ComputerCard::CRCencode(const uint8_t *data, int length)
{
	uint16_t crc = 0xFFFF; // Initial CRC value
	for (int i = 0; i < length; i++)
	{
		crc ^= ((uint16_t)data[i]) << 8; // Bring in the next byte
		for (uint8_t bit = 0; bit < 8; bit++)
		{
			if (crc & 0x8000)
			{
				crc = (crc << 1) ^ 0x1021; // CRC-CCITT polynomial
			}
			else
			{
				crc = crc << 1;
			}
		}
	}
	return crc;
}


int ComputerCard::ReadEEPROM()
{
	// Set up default values in the calibration table,
	// to be used if we can't read valid calibration from EEPROM
	for (unsigned channel = 0; channel < calMaxChannels; channel++)
	{	
		numCalibrationPoints[channel] = 3;
		calibrationTable[channel][0].voltage = -20; // -2V
		calibrationTable[channel][0].dacSetting = 347700;
		calibrationTable[channel][1].voltage = 0; // 0V
		calibrationTable[channel][1].dacSetting = 261200;
		calibrationTable[channel][2].voltage = 20; // +2V
		calibrationTable[channel][2].dacSetting = 174400;
		CalcCalCoeffs(channel); // calculate the coefficients
	}

	// Read magic number
	// Failure here could occur if I2C failed, or if incorrect/no magic number stored in EEPROM
	bool i2cFailed = false;
	if (ReadIntFromEEPROM(EEPROM_ADDR_ID, i2cFailed) != EEPROM_VAL_ID)
	{
		return 1;
	}

	// Read the EEPROM into RAM
	uint8_t buf[EEPROM_NUM_BYTES];
	for (int i = 0; i < EEPROM_NUM_BYTES; i++)
	{
		buf[i] = ReadByteFromEEPROM(i, i2cFailed);
	}

	// Check CRC and fail if incorrect
	uint16_t calculatedCRC = CRCencode(buf, 86);
	uint16_t foundCRC = ((uint16_t)buf[EEPROM_ADDR_CRC_H] << 8) | buf[EEPROM_ADDR_CRC_L];
	if (calculatedCRC != foundCRC)
	{
		return 1;
	}

	// CRC passed, so now read the calibration information
	for (uint8_t channel = 0; channel < calMaxChannels; channel++)
	{
		int channelOffset = 4 + (41 * channel); // channel 0 = 4, channel 1 = 45
		numCalibrationPoints[channel] = buf[channelOffset++];
		for (uint8_t point = 0; point < numCalibrationPoints[channel]; point++)
		{
			// Unpack Pack targetVoltage (int8_t) from buf
			int8_t targetVoltage = (int8_t)buf[channelOffset++];

			// Unpack dacSetting (uint32_t) from buf (4 bytes)
			uint32_t dacSetting = 0;
			dacSetting |= ((uint32_t)buf[channelOffset++]) << 24; // MSB
			dacSetting |= ((uint32_t)buf[channelOffset++]) << 16;
			dacSetting |= ((uint32_t)buf[channelOffset++]) << 8;
			dacSetting |= ((uint32_t)buf[channelOffset++]); // LSB

			// Write settings into calibration table
			calibrationTable[channel][point].voltage = targetVoltage;
			calibrationTable[channel][point].dacSetting = dacSetting;
		}
		
		// Now calculate the calibration coeffs that are actually used
		// by the calibrated CVOut functions
		CalcCalCoeffs(channel);
	}

	return 0;
}

void ComputerCard::CalcCalCoeffs(int channel)
{
	float sumV = 0.0;
	float sumDAC = 0.0;
	float sumV2 = 0.0;
	float sumVDAC = 0.0;
	int N = numCalibrationPoints[channel];

	for (int i = 0; i < N; i++)
	{
		float v = calibrationTable[channel][i].voltage * 0.1f;
		float dac = calibrationTable[channel][i].dacSetting;
		sumV += v;
		sumDAC += dac;
		sumV2 += v * v;
		sumVDAC += v * dac;
	}

	float denominator = N * sumV2 - sumV * sumV;
	if (denominator != 0)
	{
		calCoeffs[channel].m = (N * sumVDAC - sumV * sumDAC) / denominator;
	}
	else
	{
		calCoeffs[channel].m = 0.0;
	}
	calCoeffs[channel].b = (sumDAC - calCoeffs[channel].m * sumV) / N;

	calCoeffs[channel].mi = int32_t(calCoeffs[channel].m * 1.333333333333333f + 0.5f);
	calCoeffs[channel].bi = int32_t(calCoeffs[channel].b + 0.5f);
}


uint32_t ComputerCard::MIDIToDAC(int midiNote, int channel)
{
	int32_t dacValue = ((calCoeffs[channel].mi * (midiNote - 60)) >> 4) + calCoeffs[channel].bi;
	if (dacValue > 524287) dacValue = 524287;
	if (dacValue < 0) dacValue = 0;
	return (dacValue*125)>>7;
}

/// Converts voltage in millivolts to corresponding 19-bit sigma-delta PWM DAC value
/// Returns true if requested voltage is outside of full range of DAC values
/// millivolts should be in range -6000 to 6000.
/// Accuracy is dependent, of course, on the calibration coefficients
uint32_t ComputerCard::MillivoltsToDAC(int millivolts, int channel, bool &limited)
{
	limited = false;
	int32_t dacValue = ((((calCoeffs[channel].mi * millivolts) >> 9) * 1573) >> 12) + calCoeffs[channel].bi;
	if (dacValue > 524287)
	{
		dacValue = 524287;
		limited = true;
	}
	if (dacValue < 0)
	{
		dacValue = 0;
		limited = true;
	}
	return (dacValue*125)>>7;
}

#endif

#endif