Blackaddr Audio
7 years ago
committed by
GitHub
commit
d7fdb462d3
@ -0,0 +1,142 @@ |
||||
#include <MIDI.h> |
||||
#include "BAGuitar.h" |
||||
|
||||
using namespace BAGuitar; |
||||
|
||||
AudioInputI2S i2sIn; |
||||
AudioOutputI2S i2sOut; |
||||
BAAudioControlWM8731 codec; |
||||
|
||||
/// IMPORTANT /////
|
||||
// YOU MUST COMPILE THIS DEMO USING Serial + Midi
|
||||
|
||||
//#define USE_EXT // uncomment this line to use External MEM0
|
||||
|
||||
#define MIDI_DEBUG // uncomment to see raw MIDI info in terminal
|
||||
|
||||
#ifdef USE_EXT |
||||
// If using external SPI memory, we will instantiance an SRAM
|
||||
// manager and create an external memory slot to use as the memory
|
||||
// for our audio delay
|
||||
ExternalSramManager externalSram; |
||||
ExtMemSlot delaySlot; // Declare an external memory slot.
|
||||
|
||||
// Instantiate the AudioEffectAnalogDelay to use external memory by
|
||||
/// passing it the delay slot.
|
||||
AudioEffectAnalogDelay analogDelay(&delaySlot); |
||||
#else |
||||
// If using internal memory, we will instantiate the AudioEffectAnalogDelay
|
||||
// by passing it the maximum amount of delay we will use in millseconds. Note that
|
||||
// audio delay lengths are very limited when using internal memory due to limited
|
||||
// internal RAM size.
|
||||
AudioEffectAnalogDelay analogDelay(200.0f); // max delay of 200 ms.
|
||||
#endif |
||||
|
||||
AudioFilterBiquad cabFilter; // We'll want something to cut out the highs and smooth the tone, just like a guitar cab.
|
||||
|
||||
// Record the audio to the PC
|
||||
//AudioOutputUSB usb;
|
||||
|
||||
// Simply connect the input to the delay, and the output
|
||||
// to both i2s channels
|
||||
AudioConnection input(i2sIn,0, analogDelay,0); |
||||
AudioConnection delayOut(analogDelay, 0, cabFilter, 0); |
||||
AudioConnection leftOut(cabFilter,0, i2sOut, 0); |
||||
AudioConnection rightOut(cabFilter,0, i2sOut, 1); |
||||
//AudioConnection leftOutUSB(cabFilter,0, usb, 0);
|
||||
//AudioConnection rightOutUSB(cabFilter,0, usb, 1);
|
||||
|
||||
int loopCount = 0; |
||||
|
||||
void setup() { |
||||
delay(100); |
||||
Serial.begin(57600); // Start the serial port
|
||||
|
||||
// Disable the codec first
|
||||
codec.disable(); |
||||
delay(100); |
||||
AudioMemory(128); |
||||
delay(5); |
||||
|
||||
// Enable the codec
|
||||
Serial.println("Enabling codec...\n"); |
||||
codec.enable(); |
||||
delay(100); |
||||
|
||||
// If using external memory request request memory from the manager
|
||||
// for the slot
|
||||
#ifdef USE_EXT |
||||
Serial.println("Using EXTERNAL memory"); |
||||
// We have to request memory be allocated to our slot.
|
||||
externalSram.requestMemory(&delaySlot, 500.0f, MemSelect::MEM0, true); |
||||
#else |
||||
Serial.println("Using INTERNAL memory"); |
||||
#endif |
||||
|
||||
// Configure which MIDI CC's will control the effect parameters
|
||||
analogDelay.mapMidiControl(AudioEffectAnalogDelay::BYPASS,16); |
||||
analogDelay.mapMidiControl(AudioEffectAnalogDelay::DELAY,20); |
||||
analogDelay.mapMidiControl(AudioEffectAnalogDelay::FEEDBACK,21); |
||||
analogDelay.mapMidiControl(AudioEffectAnalogDelay::MIX,22); |
||||
analogDelay.mapMidiControl(AudioEffectAnalogDelay::VOLUME,23); |
||||
|
||||
// Besure to enable the delay. When disabled, audio is is completely blocked
|
||||
// to minimize resources to nearly zero.
|
||||
analogDelay.enable();
|
||||
|
||||
// Set some default values.
|
||||
// These can be changed by sending MIDI CC messages over the USB using
|
||||
// the BAMidiTester application.
|
||||
analogDelay.delay(200.0f); // initial delay of 200 ms
|
||||
analogDelay.bypass(false); |
||||
analogDelay.mix(0.5f); |
||||
analogDelay.feedback(0.0f); |
||||
|
||||
// Setup 2-stages of LPF, cutoff 4500 Hz, Q-factor 0.7071 (a 'normal' Q-factor)
|
||||
cabFilter.setLowpass(0, 4500, .7071); |
||||
cabFilter.setLowpass(1, 4500, .7071); |
||||
} |
||||
|
||||
void OnControlChange(byte channel, byte control, byte value) { |
||||
analogDelay.processMidi(channel, control, value); |
||||
#ifdef MIDI_DEBUG |
||||
Serial.print("Control Change, ch="); |
||||
Serial.print(channel, DEC); |
||||
Serial.print(", control="); |
||||
Serial.print(control, DEC); |
||||
Serial.print(", value="); |
||||
Serial.print(value, DEC); |
||||
Serial.println(); |
||||
#endif |
||||
} |
||||
|
||||
void loop() { |
||||
// usbMIDI.read() needs to be called rapidly from loop(). When
|
||||
// each MIDI messages arrives, it return true. The message must
|
||||
// be fully processed before usbMIDI.read() is called again.
|
||||
|
||||
if (loopCount % 524288 == 0) { |
||||
Serial.print("Processor Usage, Total: "); Serial.print(AudioProcessorUsage()); |
||||
Serial.print("% "); |
||||
Serial.print(" analogDelay: "); Serial.print(analogDelay.processorUsage()); |
||||
Serial.println("%"); |
||||
} |
||||
loopCount++; |
||||
|
||||
// check for new MIDI from USB
|
||||
if (usbMIDI.read()) { |
||||
// this code entered only if new MIDI received
|
||||
byte type, channel, data1, data2, cable; |
||||
type = usbMIDI.getType(); // which MIDI message, 128-255
|
||||
channel = usbMIDI.getChannel(); // which MIDI channel, 1-16
|
||||
data1 = usbMIDI.getData1(); // first data byte of message, 0-127
|
||||
data2 = usbMIDI.getData2(); // second data byte of message, 0-127
|
||||
if (type == 3) { |
||||
// if type is 3, it's a CC MIDI Message
|
||||
// Note: the Arduino MIDI library encodes channels as 1-16 instead
|
||||
// of 0 to 15 as it should, so we must subtract one.
|
||||
OnControlChange(channel-1, data1, data2); |
||||
} |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
// To give your project a unique name, this code must be
|
||||
// placed into a .c file (its own tab). It can not be in
|
||||
// a .cpp file or your main sketch (the .ino file).
|
||||
|
||||
#include "usb_names.h" |
||||
|
||||
// Edit these lines to create your own name. The length must
|
||||
// match the number of characters in your custom name.
|
||||
|
||||
#define MIDI_NAME {'B','l','a','c','k','a','d','d','r',' ','A','u','d','i','o',' ','T','G','A',' ','P','r','o'} |
||||
#define MIDI_NAME_LEN 23 |
||||
|
||||
// Do not change this part. This exact format is required by USB.
|
||||
|
||||
struct usb_string_descriptor_struct usb_string_product_name = { |
||||
2 + MIDI_NAME_LEN * 2, |
||||
3, |
||||
MIDI_NAME |
||||
}; |
||||
@ -0,0 +1,316 @@ |
||||
/*************************************************************************
|
||||
* This demo uses the BAGuitar library to provide enhanced control of |
||||
* the TGA Pro board. |
||||
*
|
||||
* The latest copy of the BA Guitar library can be obtained from |
||||
* https://github.com/Blackaddr/BAGuitar
|
||||
*
|
||||
* This demo will perform a DMA memory test on MEM0 attached |
||||
* to SPI. |
||||
*
|
||||
* NOTE: SPI MEM0 can be used by a Teensy 3.2/3.5/3.6. |
||||
* pins. |
||||
*
|
||||
*/ |
||||
#include <Wire.h> |
||||
#include "BAGuitar.h" |
||||
|
||||
using namespace BAGuitar; |
||||
|
||||
//#define SANITY
|
||||
#define DMA_SIZE 256 |
||||
|
||||
#define SPI_WRITE_CMD 0x2 |
||||
#define SPI_READ_CMD 0x3 |
||||
#define SPI_ADDR_2_MASK 0xFF0000 |
||||
#define SPI_ADDR_2_SHIFT 16 |
||||
#define SPI_ADDR_1_MASK 0x00FF00 |
||||
#define SPI_ADDR_1_SHIFT 8 |
||||
#define SPI_ADDR_0_MASK 0x0000FF |
||||
SPISettings memSettings(20000000, MSBFIRST, SPI_MODE0); |
||||
const int cs0pin = 15; |
||||
|
||||
BAGpio gpio; // access to User LED
|
||||
BASpiMemoryDMA spiMem0(SpiDeviceId::SPI_DEVICE0); |
||||
|
||||
|
||||
|
||||
bool compareBuffers(uint8_t *a, uint8_t *b, size_t numBytes) |
||||
{ |
||||
bool pass=true; |
||||
int errorCount = 0; |
||||
for (size_t i=0; i<numBytes; i++) { |
||||
if (a[i] != b[i]) { |
||||
if (errorCount < 10) { |
||||
Serial.print(i); Serial.print(":: a:"); Serial.print(a[i]); Serial.print(" does not match b:"); Serial.println(b[i]); |
||||
pass=false; |
||||
errorCount++; |
||||
} else { return false; } |
||||
} |
||||
} |
||||
return pass; |
||||
} |
||||
|
||||
bool compareBuffers16(uint16_t *a, uint16_t *b, size_t numWords) |
||||
{ |
||||
return compareBuffers(reinterpret_cast<uint8_t *>(a), reinterpret_cast<uint8_t*>(b), sizeof(uint16_t)*numWords); |
||||
} |
||||
|
||||
constexpr size_t TEST_END = SPI_MAX_ADDR; |
||||
|
||||
void setup() { |
||||
|
||||
Serial.begin(57600); |
||||
while (!Serial) {} |
||||
delay(5); |
||||
|
||||
Serial.println("Enabling SPI"); |
||||
spiMem0.begin(); |
||||
} |
||||
|
||||
|
||||
bool spi8BitTest(void) { |
||||
|
||||
size_t spiAddress = 0; |
||||
int spiPhase = 0; |
||||
constexpr uint8_t MASK80 = 0xaa; |
||||
constexpr uint8_t MASK81 = 0x55; |
||||
|
||||
uint8_t src8[DMA_SIZE]; |
||||
uint8_t dest8[DMA_SIZE]; |
||||
|
||||
// Write to the memory using 8-bit transfers
|
||||
Serial.println("\nStarting 8-bit test Write/Read"); |
||||
while (spiPhase < 4) { |
||||
spiAddress = 0; |
||||
while (spiAddress < TEST_END) { |
||||
|
||||
// fill the write data buffer
|
||||
switch (spiPhase) { |
||||
case 0 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ( (spiAddress+i) & 0xff) ^ MASK80; |
||||
} |
||||
break; |
||||
case 1 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ MASK81; |
||||
} |
||||
break; |
||||
case 2 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ (!MASK80); |
||||
} |
||||
break; |
||||
case 3 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ (!MASK81); |
||||
} |
||||
break; |
||||
}
|
||||
|
||||
// Send the DMA transfer
|
||||
spiMem0.write(spiAddress, src8, DMA_SIZE); |
||||
// wait until write is done
|
||||
while (spiMem0.isWriteBusy()) {} |
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
|
||||
// Read back the data using 8-bit transfers
|
||||
spiAddress = 0; |
||||
while (spiAddress < TEST_END) { |
||||
// generate the golden data
|
||||
switch (spiPhase) { |
||||
case 0 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ( (spiAddress+i) & 0xff) ^ MASK80; |
||||
} |
||||
break; |
||||
case 1 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ MASK81; |
||||
} |
||||
break; |
||||
case 2 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ (!MASK80); |
||||
} |
||||
break; |
||||
case 3 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ (!MASK81); |
||||
} |
||||
break; |
||||
} |
||||
|
||||
// Read back the DMA data
|
||||
spiMem0.read(spiAddress, dest8, DMA_SIZE); |
||||
// wait until read is done
|
||||
while (spiMem0.isReadBusy()) {} |
||||
if (!compareBuffers(src8, dest8, DMA_SIZE)) {
|
||||
Serial.println(String("ERROR @") + spiAddress); |
||||
return false; } // stop the test
|
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
Serial.println(String("Phase ") + spiPhase + String(": 8-bit Write/Read test passed!")); |
||||
spiPhase++; |
||||
} |
||||
|
||||
#ifdef SANITY |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
Serial.print(src8[i], HEX); Serial.print("="); Serial.println(dest8[i],HEX); |
||||
} |
||||
#endif |
||||
|
||||
Serial.println("\nStarting 8-bit test Zero/Read"); |
||||
// Clear the memory
|
||||
spiAddress = 0; |
||||
memset(src8, 0, DMA_SIZE); |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// Send the DMA transfer
|
||||
spiMem0.zero(spiAddress, DMA_SIZE); |
||||
// wait until write is done
|
||||
while (spiMem0.isWriteBusy()) {} |
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
|
||||
// Check the memory is clear
|
||||
spiAddress = 0; |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// Read back the DMA data
|
||||
spiMem0.read(spiAddress, dest8, DMA_SIZE); |
||||
// wait until read is done
|
||||
while (spiMem0.isReadBusy()) {} |
||||
if (!compareBuffers(src8, dest8, DMA_SIZE)) { return false; } // stop the test
|
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
Serial.println(String(": 8-bit Zero/Read test passed!")); |
||||
return true; |
||||
} |
||||
|
||||
bool spi16BitTest(void) { |
||||
size_t spiAddress = 0; |
||||
int spiPhase = 0; |
||||
constexpr uint16_t MASK160 = 0xaaaa; |
||||
constexpr uint16_t MASK161 = 0x5555; |
||||
constexpr int NUM_DATA = DMA_SIZE / sizeof(uint16_t); |
||||
|
||||
uint16_t src16[NUM_DATA]; |
||||
uint16_t dest16[NUM_DATA]; |
||||
|
||||
// Write to the memory using 16-bit transfers
|
||||
Serial.println("\nStarting 16-bit test"); |
||||
while (spiPhase < 4) { |
||||
spiAddress = 0; |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
|
||||
// fill the write data buffer
|
||||
switch (spiPhase) { |
||||
case 0 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ( (spiAddress+i) & 0xffff) ^ MASK160; |
||||
} |
||||
break; |
||||
case 1 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ MASK161; |
||||
} |
||||
break; |
||||
case 2 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ (!MASK160); |
||||
} |
||||
break; |
||||
case 3 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ (!MASK161); |
||||
} |
||||
break; |
||||
} |
||||
|
||||
// Send the DMA transfer
|
||||
spiMem0.write16(spiAddress, src16, NUM_DATA); |
||||
// wait until write is done
|
||||
while (spiMem0.isWriteBusy()) {} |
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
|
||||
// Read back the data using 8-bit transfers
|
||||
spiAddress = 0; |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// generate the golden data
|
||||
switch (spiPhase) { |
||||
case 0 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ( (spiAddress+i) & 0xffff) ^ MASK160; |
||||
} |
||||
break; |
||||
case 1 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ MASK161; |
||||
} |
||||
break; |
||||
case 2 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ (!MASK160); |
||||
} |
||||
break; |
||||
case 3 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ (!MASK161); |
||||
} |
||||
break; |
||||
} |
||||
|
||||
// Read back the DMA data
|
||||
spiMem0.read16(spiAddress, dest16, NUM_DATA); |
||||
// wait until read is done
|
||||
while (spiMem0.isReadBusy()) {} |
||||
if (!compareBuffers16(src16, dest16, NUM_DATA)) {
|
||||
Serial.print("ERROR @"); Serial.println(spiAddress, HEX); |
||||
return false; } // stop the test
|
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
Serial.println(String("Phase ") + spiPhase + String(": 16-bit test passed!")); |
||||
spiPhase++; |
||||
} |
||||
#ifdef SANITY |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
Serial.print(src16[i], HEX); Serial.print("="); Serial.println(dest16[i],HEX); |
||||
} |
||||
#endif |
||||
|
||||
Serial.println("\nStarting 16-bit test Zero/Read"); |
||||
// Clear the memory
|
||||
spiAddress = 0; |
||||
memset(src16, 0, DMA_SIZE); |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// Send the DMA transfer
|
||||
spiMem0.zero16(spiAddress, NUM_DATA); |
||||
// wait until write is done
|
||||
while (spiMem0.isWriteBusy()) {} |
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
|
||||
// Check the memory is clear
|
||||
spiAddress = 0; |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// Read back the DMA data
|
||||
spiMem0.read16(spiAddress, dest16, NUM_DATA); |
||||
// wait until read is done
|
||||
while (spiMem0.isReadBusy()) {} |
||||
if (!compareBuffers16(src16, dest16, NUM_DATA)) { return false; } // stop the test
|
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
Serial.println(String(": 16-bit Zero/Read test passed!")); |
||||
return true; |
||||
} |
||||
|
||||
void loop() { |
||||
|
||||
spi8BitTest(); |
||||
spi16BitTest(); |
||||
while(true) {} |
||||
|
||||
} |
||||
|
||||
@ -0,0 +1,316 @@ |
||||
/*************************************************************************
|
||||
* This demo uses the BAGuitar library to provide enhanced control of |
||||
* the TGA Pro board. |
||||
*
|
||||
* The latest copy of the BA Guitar library can be obtained from |
||||
* https://github.com/Blackaddr/BAGuitar
|
||||
*
|
||||
* This demo will perform a DMA memory test on MEM1 attached |
||||
* to SPI1. |
||||
*
|
||||
* NOTE: SPI MEM1 can be used by a Teensy 3.5/3.6. |
||||
* pins. |
||||
*
|
||||
*/ |
||||
#include <Wire.h> |
||||
#include "BAGuitar.h" |
||||
|
||||
using namespace BAGuitar; |
||||
|
||||
//#define SANITY
|
||||
#define DMA_SIZE 256 |
||||
|
||||
#define SPI_WRITE_CMD 0x2 |
||||
#define SPI_READ_CMD 0x3 |
||||
#define SPI_ADDR_2_MASK 0xFF0000 |
||||
#define SPI_ADDR_2_SHIFT 16 |
||||
#define SPI_ADDR_1_MASK 0x00FF00 |
||||
#define SPI_ADDR_1_SHIFT 8 |
||||
#define SPI_ADDR_0_MASK 0x0000FF |
||||
SPISettings memSettings(20000000, MSBFIRST, SPI_MODE0); |
||||
const int cs0pin = 15; |
||||
|
||||
BAGpio gpio; // access to User LED
|
||||
BASpiMemoryDMA spiMem1(SpiDeviceId::SPI_DEVICE1); |
||||
|
||||
|
||||
|
||||
bool compareBuffers(uint8_t *a, uint8_t *b, size_t numBytes) |
||||
{ |
||||
bool pass=true; |
||||
int errorCount = 0; |
||||
for (size_t i=0; i<numBytes; i++) { |
||||
if (a[i] != b[i]) { |
||||
if (errorCount < 10) { |
||||
Serial.print(i); Serial.print(":: a:"); Serial.print(a[i]); Serial.print(" does not match b:"); Serial.println(b[i]); |
||||
pass=false; |
||||
errorCount++; |
||||
} else { return false; } |
||||
} |
||||
} |
||||
return pass; |
||||
} |
||||
|
||||
bool compareBuffers16(uint16_t *a, uint16_t *b, size_t numWords) |
||||
{ |
||||
return compareBuffers(reinterpret_cast<uint8_t *>(a), reinterpret_cast<uint8_t*>(b), sizeof(uint16_t)*numWords); |
||||
} |
||||
|
||||
constexpr size_t TEST_END = SPI_MAX_ADDR; |
||||
|
||||
void setup() { |
||||
|
||||
Serial.begin(57600); |
||||
while (!Serial) {} |
||||
delay(5); |
||||
|
||||
Serial.println("Enabling SPI"); |
||||
spiMem1.begin(); |
||||
} |
||||
|
||||
|
||||
bool spi8BitTest(void) { |
||||
|
||||
size_t spiAddress = 0; |
||||
int spiPhase = 0; |
||||
constexpr uint8_t MASK80 = 0xaa; |
||||
constexpr uint8_t MASK81 = 0x55; |
||||
|
||||
uint8_t src8[DMA_SIZE]; |
||||
uint8_t dest8[DMA_SIZE]; |
||||
|
||||
// Write to the memory using 8-bit transfers
|
||||
Serial.println("\nStarting 8-bit test Write/Read"); |
||||
while (spiPhase < 4) { |
||||
spiAddress = 0; |
||||
while (spiAddress < TEST_END) { |
||||
|
||||
// fill the write data buffer
|
||||
switch (spiPhase) { |
||||
case 0 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ( (spiAddress+i) & 0xff) ^ MASK80; |
||||
} |
||||
break; |
||||
case 1 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ MASK81; |
||||
} |
||||
break; |
||||
case 2 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ (!MASK80); |
||||
} |
||||
break; |
||||
case 3 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ (!MASK81); |
||||
} |
||||
break; |
||||
}
|
||||
|
||||
// Send the DMA transfer
|
||||
spiMem1.write(spiAddress, src8, DMA_SIZE); |
||||
// wait until write is done
|
||||
while (spiMem1.isWriteBusy()) {} |
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
|
||||
// Read back the data using 8-bit transfers
|
||||
spiAddress = 0; |
||||
while (spiAddress < TEST_END) { |
||||
// generate the golden data
|
||||
switch (spiPhase) { |
||||
case 0 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ( (spiAddress+i) & 0xff) ^ MASK80; |
||||
} |
||||
break; |
||||
case 1 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ MASK81; |
||||
} |
||||
break; |
||||
case 2 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ (!MASK80); |
||||
} |
||||
break; |
||||
case 3 : |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
src8[i] = ((spiAddress+i) & 0xff) ^ (!MASK81); |
||||
} |
||||
break; |
||||
} |
||||
|
||||
// Read back the DMA data
|
||||
spiMem1.read(spiAddress, dest8, DMA_SIZE); |
||||
// wait until read is done
|
||||
while (spiMem1.isReadBusy()) {} |
||||
if (!compareBuffers(src8, dest8, DMA_SIZE)) {
|
||||
Serial.println(String("ERROR @") + spiAddress); |
||||
return false; } // stop the test
|
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
Serial.println(String("Phase ") + spiPhase + String(": 8-bit Write/Read test passed!")); |
||||
spiPhase++; |
||||
} |
||||
|
||||
#ifdef SANITY |
||||
for (int i=0; i<DMA_SIZE; i++) { |
||||
Serial.print(src8[i], HEX); Serial.print("="); Serial.println(dest8[i],HEX); |
||||
} |
||||
#endif |
||||
|
||||
Serial.println("\nStarting 8-bit test Zero/Read"); |
||||
// Clear the memory
|
||||
spiAddress = 0; |
||||
memset(src8, 0, DMA_SIZE); |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// Send the DMA transfer
|
||||
spiMem1.zero(spiAddress, DMA_SIZE); |
||||
// wait until write is done
|
||||
while (spiMem1.isWriteBusy()) {} |
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
|
||||
// Check the memory is clear
|
||||
spiAddress = 0; |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// Read back the DMA data
|
||||
spiMem1.read(spiAddress, dest8, DMA_SIZE); |
||||
// wait until read is done
|
||||
while (spiMem1.isReadBusy()) {} |
||||
if (!compareBuffers(src8, dest8, DMA_SIZE)) { return false; } // stop the test
|
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
Serial.println(String(": 8-bit Zero/Read test passed!")); |
||||
return true; |
||||
} |
||||
|
||||
bool spi16BitTest(void) { |
||||
size_t spiAddress = 0; |
||||
int spiPhase = 0; |
||||
constexpr uint16_t MASK160 = 0xaaaa; |
||||
constexpr uint16_t MASK161 = 0x5555; |
||||
constexpr int NUM_DATA = DMA_SIZE / sizeof(uint16_t); |
||||
|
||||
uint16_t src16[NUM_DATA]; |
||||
uint16_t dest16[NUM_DATA]; |
||||
|
||||
// Write to the memory using 16-bit transfers
|
||||
Serial.println("\nStarting 16-bit test"); |
||||
while (spiPhase < 4) { |
||||
spiAddress = 0; |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
|
||||
// fill the write data buffer
|
||||
switch (spiPhase) { |
||||
case 0 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ( (spiAddress+i) & 0xffff) ^ MASK160; |
||||
} |
||||
break; |
||||
case 1 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ MASK161; |
||||
} |
||||
break; |
||||
case 2 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ (!MASK160); |
||||
} |
||||
break; |
||||
case 3 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ (!MASK161); |
||||
} |
||||
break; |
||||
} |
||||
|
||||
// Send the DMA transfer
|
||||
spiMem1.write16(spiAddress, src16, NUM_DATA); |
||||
// wait until write is done
|
||||
while (spiMem1.isWriteBusy()) {} |
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
|
||||
// Read back the data using 8-bit transfers
|
||||
spiAddress = 0; |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// generate the golden data
|
||||
switch (spiPhase) { |
||||
case 0 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ( (spiAddress+i) & 0xffff) ^ MASK160; |
||||
} |
||||
break; |
||||
case 1 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ MASK161; |
||||
} |
||||
break; |
||||
case 2 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ (!MASK160); |
||||
} |
||||
break; |
||||
case 3 : |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
src16[i] = ((spiAddress+i) & 0xffff) ^ (!MASK161); |
||||
} |
||||
break; |
||||
} |
||||
|
||||
// Read back the DMA data
|
||||
spiMem1.read16(spiAddress, dest16, NUM_DATA); |
||||
// wait until read is done
|
||||
while (spiMem1.isReadBusy()) {} |
||||
if (!compareBuffers16(src16, dest16, NUM_DATA)) {
|
||||
Serial.print("ERROR @"); Serial.println(spiAddress, HEX); |
||||
return false; } // stop the test
|
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
Serial.println(String("Phase ") + spiPhase + String(": 16-bit test passed!")); |
||||
spiPhase++; |
||||
} |
||||
#ifdef SANITY |
||||
for (int i=0; i<NUM_DATA; i++) { |
||||
Serial.print(src16[i], HEX); Serial.print("="); Serial.println(dest16[i],HEX); |
||||
} |
||||
#endif |
||||
|
||||
Serial.println("\nStarting 16-bit test Zero/Read"); |
||||
// Clear the memory
|
||||
spiAddress = 0; |
||||
memset(src16, 0, DMA_SIZE); |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// Send the DMA transfer
|
||||
spiMem1.zero16(spiAddress, NUM_DATA); |
||||
// wait until write is done
|
||||
while (spiMem1.isWriteBusy()) {} |
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
|
||||
// Check the memory is clear
|
||||
spiAddress = 0; |
||||
while (spiAddress < SPI_MAX_ADDR) { |
||||
// Read back the DMA data
|
||||
spiMem1.read16(spiAddress, dest16, NUM_DATA); |
||||
// wait until read is done
|
||||
while (spiMem1.isReadBusy()) {} |
||||
if (!compareBuffers16(src16, dest16, NUM_DATA)) { return false; } // stop the test
|
||||
spiAddress += DMA_SIZE;
|
||||
} |
||||
Serial.println(String(": 16-bit Zero/Read test passed!")); |
||||
return true; |
||||
} |
||||
|
||||
void loop() { |
||||
|
||||
spi8BitTest(); |
||||
spi16BitTest(); |
||||
while(true) {} |
||||
|
||||
} |
||||
|
||||
@ -0,0 +1,162 @@ |
||||
/**************************************************************************//**
|
||||
* @file |
||||
* @author Steve Lascos |
||||
* @company Blackaddr Audio |
||||
* |
||||
* AudioEffectAnalogDelay is a class for simulating a classic BBD based delay |
||||
* like the Boss DM-2. This class works with either internal RAM, or external |
||||
* SPI RAM for longer delays. The exteranl ram uses DMA to minimize load on the |
||||
* CPU. |
||||
* |
||||
* @copyright This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*****************************************************************************/ |
||||
|
||||
#ifndef __BAGUITAR_BAAUDIOEFFECTANALOGDELAY_H |
||||
#define __BAGUITAR_BAAUDIOEFFECTANALOGDELAY_H |
||||
|
||||
#include <Audio.h> |
||||
#include "LibBasicFunctions.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
/**************************************************************************//**
|
||||
* AudioEffectAnalogDelay models BBD based analog delays. It provides controls |
||||
* for delay, feedback (or regen), mix and output level. All parameters can be |
||||
* controlled by MIDI. The class supports internal memory, or external SPI |
||||
* memory by providing an ExtMemSlot. External memory access uses DMA to reduce |
||||
* process load. |
||||
*****************************************************************************/ |
||||
class AudioEffectAnalogDelay : public AudioStream { |
||||
public: |
||||
|
||||
///< List of AudioEffectAnalogDelay MIDI controllable parameters
|
||||
enum { |
||||
BYPASS = 0, ///< controls effect bypass
|
||||
DELAY, ///< controls the amount of delay
|
||||
FEEDBACK, ///< controls the amount of echo feedback (regen)
|
||||
MIX, ///< controls the the mix of input and echo signals
|
||||
VOLUME, ///< controls the output volume level
|
||||
NUM_CONTROLS ///< this can be used as an alias for the number of MIDI controls
|
||||
}; |
||||
|
||||
AudioEffectAnalogDelay() = delete; |
||||
|
||||
// *** CONSTRUCTORS ***
|
||||
|
||||
/// Construct an analog delay using internal memory by specifying the maximum
|
||||
/// delay in milliseconds.
|
||||
/// @param maxDelayMs maximum delay in milliseconds. Larger delays use more memory.
|
||||
AudioEffectAnalogDelay(float maxDelayMs); |
||||
|
||||
/// Construct an analog delay using internal memory by specifying the maximum
|
||||
/// delay in audio samples.
|
||||
/// @param numSamples maximum delay in audio samples. Larger delays use more memory.
|
||||
AudioEffectAnalogDelay(size_t numSamples); |
||||
|
||||
/// Construct an analog delay using external SPI via an ExtMemSlot. The amount of
|
||||
/// delay will be determined by the amount of memory in the slot.
|
||||
/// @param slot A pointer to the ExtMemSlot to use for the delay.
|
||||
AudioEffectAnalogDelay(ExtMemSlot *slot); // requires sufficiently sized pre-allocated memory
|
||||
|
||||
virtual ~AudioEffectAnalogDelay(); ///< Destructor
|
||||
|
||||
// *** PARAMETERS ***
|
||||
|
||||
/// Set the delay in milliseconds.
|
||||
/// @param milliseconds the request delay in milliseconds. Must be less than max delay.
|
||||
void delay(float milliseconds); |
||||
|
||||
/// Set the delay in number of audio samples.
|
||||
/// @param delaySamples the request delay in audio samples. Must be less than max delay.
|
||||
void delay(size_t delaySamples); |
||||
|
||||
/// Bypass the effect.
|
||||
/// @param byp when true, bypass wil disable the effect, when false, effect is enabled.
|
||||
/// Note that audio still passes through when bypass is enabled.
|
||||
void bypass(bool byp) { m_bypass = byp; } |
||||
|
||||
/// Set the amount of echo feedback (a.k.a regeneration).
|
||||
/// @param feedback a floating point number between 0.0 and 1.0.
|
||||
void feedback(float feedback) { m_feedback = feedback; } |
||||
|
||||
/// Set the amount of blending between dry and wet (echo) at the output.
|
||||
/// @param mix When 0.0, output is 100% dry, when 1.0, output is 100% wet. When
|
||||
/// 0.5, output is 50% Dry, 50% Wet.
|
||||
void mix(float mix) { m_mix = mix; } |
||||
|
||||
/// Set the output volume. This affect both the wet and dry signals.
|
||||
/// @details The default is 1.0.
|
||||
/// @param vol Sets the output volume between -1.0 and +1.0
|
||||
void volume(float vol) {m_volume = vol; } |
||||
|
||||
// ** ENABLE / DISABLE **
|
||||
|
||||
/// Enables audio processing. Note: when not enabled, CPU load is nearly zero.
|
||||
void enable() { m_enable = true; } |
||||
|
||||
/// Disables audio process. When disabled, CPU load is nearly zero.
|
||||
void disable() { m_enable = false; } |
||||
|
||||
// ** MIDI **
|
||||
|
||||
/// Sets whether MIDI OMNI channel is processig on or off. When on,
|
||||
/// all midi channels are used for matching CCs.
|
||||
/// @param isOmni when true, all channels are processed, when false, channel
|
||||
/// must match configured value.
|
||||
void setMidiOmni(bool isOmni) { m_isOmni = isOmni; } |
||||
|
||||
/// Configure an effect parameter to be controlled by a MIDI CC
|
||||
/// number on a particular channel.
|
||||
/// @param parameter one of the parameter names in the class enum
|
||||
/// @param midiCC the CC number from 0 to 127
|
||||
/// @param midiChannel the effect will only response to the CC on this channel
|
||||
/// when OMNI mode is off.
|
||||
void mapMidiControl(int parameter, int midiCC, int midiChannel = 0); |
||||
|
||||
/// process a MIDI Continous-Controller (CC) message
|
||||
/// @param channel the MIDI channel from 0 to 15)
|
||||
/// @param midiCC the CC number from 0 to 127
|
||||
/// @param value the CC value from 0 to 127
|
||||
void processMidi(int channel, int midiCC, int value); |
||||
|
||||
virtual void update(void); ///< update automatically called by the Teesny Audio Library
|
||||
|
||||
private: |
||||
audio_block_t *m_inputQueueArray[1]; |
||||
bool m_isOmni = false; |
||||
bool m_bypass = true; |
||||
bool m_enable = false; |
||||
bool m_externalMemory = false; |
||||
AudioDelay *m_memory = nullptr; |
||||
size_t m_maxDelaySamples = 0; |
||||
audio_block_t *m_previousBlock = nullptr; |
||||
audio_block_t *m_blockToRelease = nullptr; |
||||
IirBiQuadFilterHQ *m_iir = nullptr; |
||||
|
||||
// Controls
|
||||
int m_midiConfig[NUM_CONTROLS][2]; // stores the midi parameter mapping
|
||||
size_t m_delaySamples = 0; |
||||
float m_feedback = 0.0f; |
||||
float m_mix = 0.0f; |
||||
float m_volume = 1.0f; |
||||
|
||||
void m_preProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet); |
||||
void m_postProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet); |
||||
|
||||
size_t m_callCount = 0; |
||||
}; |
||||
|
||||
} |
||||
|
||||
#endif /* __BAGUITAR_BAAUDIOEFFECTANALOGDELAY_H */ |
||||
@ -1,155 +0,0 @@ |
||||
/*
|
||||
* BASpiMemory.cpp |
||||
* |
||||
* Created on: May 22, 2017 |
||||
* Author: slascos |
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "Arduino.h" |
||||
#include "BASpiMemory.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
// MEM0 Settings
|
||||
constexpr int SPI_CS_MEM0 = 15; |
||||
constexpr int SPI_MOSI_MEM0 = 7; |
||||
constexpr int SPI_MISO_MEM0 = 8; |
||||
constexpr int SPI_SCK_MEM0 = 14; |
||||
|
||||
// MEM1 Settings
|
||||
constexpr int SPI_CS_MEM1 = 31; |
||||
constexpr int SPI_MOSI_MEM1 = 21; |
||||
constexpr int SPI_MISO_MEM1 = 5; |
||||
constexpr int SPI_SCK_MEM1 = 20; |
||||
|
||||
// SPI Constants
|
||||
constexpr int SPI_WRITE_CMD = 0x2; |
||||
constexpr int SPI_READ_CMD = 0x3; |
||||
constexpr int SPI_ADDR_2_MASK = 0xFF0000; |
||||
constexpr int SPI_ADDR_2_SHIFT = 16; |
||||
constexpr int SPI_ADDR_1_MASK = 0x00FF00; |
||||
constexpr int SPI_ADDR_1_SHIFT = 8; |
||||
constexpr int SPI_ADDR_0_MASK = 0x0000FF; |
||||
|
||||
|
||||
BASpiMemory::BASpiMemory(SpiDeviceId memDeviceId) |
||||
{ |
||||
m_memDeviceId = memDeviceId; |
||||
m_settings = {20000000, MSBFIRST, SPI_MODE0}; |
||||
} |
||||
|
||||
BASpiMemory::BASpiMemory(SpiDeviceId memDeviceId, uint32_t speedHz) |
||||
{ |
||||
m_memDeviceId = memDeviceId; |
||||
m_settings = {speedHz, MSBFIRST, SPI_MODE0}; |
||||
} |
||||
|
||||
// Intitialize the correct Arduino SPI interface
|
||||
void BASpiMemory::begin() |
||||
{ |
||||
|
||||
switch (m_memDeviceId) { |
||||
case SpiDeviceId::SPI_DEVICE0 : |
||||
m_csPin = SPI_CS_MEM0; |
||||
m_spi = &SPI; |
||||
m_spi->setMOSI(SPI_MOSI_MEM0); |
||||
m_spi->setMISO(SPI_MISO_MEM0); |
||||
m_spi->setSCK(SPI_SCK_MEM0); |
||||
m_spi->begin(); |
||||
break; |
||||
|
||||
#if defined(__MK64FX512__) || defined(__MK66FX1M0__) |
||||
case SpiDeviceId::SPI_DEVICE1 : |
||||
m_csPin = SPI_CS_MEM1; |
||||
m_spi = &SPI1; |
||||
m_spi->setMOSI(SPI_MOSI_MEM1); |
||||
m_spi->setMISO(SPI_MISO_MEM1); |
||||
m_spi->setSCK(SPI_SCK_MEM1); |
||||
m_spi->begin(); |
||||
break; |
||||
#endif |
||||
|
||||
default : |
||||
// unreachable since memDeviceId is an enumerated class
|
||||
return; |
||||
} |
||||
|
||||
pinMode(m_csPin, OUTPUT); |
||||
digitalWrite(m_csPin, HIGH); |
||||
|
||||
} |
||||
|
||||
BASpiMemory::~BASpiMemory() { |
||||
} |
||||
|
||||
// Single address write
|
||||
void BASpiMemory::write(int address, int data) |
||||
{ |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer(SPI_WRITE_CMD); |
||||
m_spi->transfer((address & SPI_ADDR_2_MASK) >> SPI_ADDR_2_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_1_MASK) >> SPI_ADDR_1_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_0_MASK)); |
||||
m_spi->transfer(data); |
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
void BASpiMemory::write16(int address, uint16_t data) |
||||
{ |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer16((SPI_WRITE_CMD << 8) | (address >> 16) ); |
||||
m_spi->transfer16(address & 0xFFFF); |
||||
m_spi->transfer16(data); |
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
// single address read
|
||||
int BASpiMemory::read(int address) |
||||
{ |
||||
int data; |
||||
|
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer(SPI_READ_CMD); |
||||
m_spi->transfer((address & SPI_ADDR_2_MASK) >> SPI_ADDR_2_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_1_MASK) >> SPI_ADDR_1_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_0_MASK)); |
||||
data = m_spi->transfer(0); |
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
return data; |
||||
} |
||||
|
||||
uint16_t BASpiMemory::read16(int address) |
||||
{ |
||||
|
||||
uint16_t data; |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer16((SPI_READ_CMD << 8) | (address >> 16) ); |
||||
m_spi->transfer16(address & 0xFFFF); |
||||
data = m_spi->transfer16(0); |
||||
m_spi->endTransaction(); |
||||
|
||||
digitalWrite(m_csPin, HIGH); |
||||
return data; |
||||
} |
||||
|
||||
} /* namespace BAGuitar */ |
||||
@ -0,0 +1,158 @@ |
||||
/**************************************************************************//**
|
||||
* @file |
||||
* @author Steve Lascos |
||||
* @company Blackaddr Audio |
||||
* |
||||
* This file contains some custom types used by the rest of the BAGuitar library. |
||||
* |
||||
* @copyright This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*****************************************************************************/ |
||||
|
||||
#ifndef __BAGUITAR_BATYPES_H |
||||
#define __BAGUITAR_BATYPES_H |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
#define UNUSED(x) (void)(x) |
||||
|
||||
/**************************************************************************//**
|
||||
* Customer RingBuffer with random access |
||||
*****************************************************************************/ |
||||
template <class T> |
||||
class RingBuffer { |
||||
public: |
||||
RingBuffer() = delete; |
||||
|
||||
/// Construct a RingBuffer of specified max size
|
||||
/// @param maxSize number of entries in ring buffer
|
||||
RingBuffer(const size_t maxSize) : m_maxSize(maxSize) { |
||||
m_buffer = new T[maxSize](); |
||||
} |
||||
virtual ~RingBuffer(){ |
||||
if (m_buffer) delete [] m_buffer; |
||||
} |
||||
|
||||
/// Add an element to the back of the queue
|
||||
/// @param element element to add to queue
|
||||
/// returns 0 if success, otherwise error
|
||||
int push_back(T element) { |
||||
|
||||
//Serial.println(String("RingBuffer::push_back...") + m_head + String(":") + m_tail + String(":") + m_size);
|
||||
if ( (m_head == m_tail) && (m_size > 0) ) { |
||||
// overflow
|
||||
Serial.println("RingBuffer::push_back: overflow"); |
||||
return -1; |
||||
} |
||||
|
||||
m_buffer[m_head] = element; |
||||
if (m_head < (m_maxSize-1) ) { |
||||
m_head++; |
||||
} else { |
||||
m_head = 0; |
||||
} |
||||
m_size++; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/// Remove the element at teh front of the queue
|
||||
/// @returns 0 if success, otherwise error
|
||||
int pop_front() { |
||||
|
||||
if (m_size == 0) { |
||||
// buffer is empty
|
||||
//Serial.println("RingBuffer::pop_front: buffer is empty\n");
|
||||
return -1; |
||||
} |
||||
if (m_tail < m_maxSize-1) { |
||||
m_tail++; |
||||
} else { |
||||
m_tail = 0; |
||||
} |
||||
m_size--; |
||||
//Serial.println(String("RingBuffer::pop_front: ") + m_head + String(":") + m_tail + String(":") + m_size);
|
||||
return 0; |
||||
} |
||||
|
||||
/// Get the element at the front of the queue
|
||||
/// @returns element at front of queue
|
||||
T front() const { |
||||
return m_buffer[m_tail]; |
||||
} |
||||
|
||||
/// get the element at the back of the queue
|
||||
/// @returns element at the back of the queue
|
||||
T back() const { |
||||
return m_buffer[m_head-1]; |
||||
} |
||||
|
||||
/// Get a previously pushed elememt
|
||||
/// @param offset zero is last pushed, 1 is second last, etc.
|
||||
/// @returns the absolute index corresponding to the requested offset.
|
||||
size_t get_index_from_back(size_t offset = 0) const { |
||||
// the target at m_head - 1 - offset or m_maxSize + m_head -1 - offset;
|
||||
size_t idx = (m_maxSize + m_head -1 - offset); |
||||
|
||||
if ( idx >= m_maxSize) { |
||||
idx -= m_maxSize; |
||||
} |
||||
|
||||
return idx; |
||||
} |
||||
|
||||
/// get the current size of the queue
|
||||
/// @returns size of the queue
|
||||
size_t size() const { |
||||
return m_size; |
||||
} |
||||
|
||||
/// get the maximum size the queue can hold
|
||||
/// @returns maximum size of the queue
|
||||
size_t max_size() const { |
||||
return m_maxSize; |
||||
} |
||||
|
||||
/// get the element at the specified absolute index
|
||||
/// @param index element to retrieve from absolute queue position
|
||||
/// @returns the request element
|
||||
T& operator[] (size_t index) { |
||||
return m_buffer[index]; |
||||
} |
||||
|
||||
/// get the element at the specified absolute index
|
||||
/// @param index element to retrieve from absolute queue position
|
||||
/// @returns the request element
|
||||
T at(size_t index) const { |
||||
return m_buffer[index]; |
||||
} |
||||
|
||||
/// DEBUG: Prints the status of the Ringbuffer. NOte using this much printing will usually cause audio glitches
|
||||
void print() const { |
||||
for (int idx=0; idx<m_maxSize; idx++) { |
||||
Serial.print(idx + String(" address: ")); Serial.print((uint32_t)m_buffer[idx], HEX); |
||||
Serial.print(" data: "); Serial.println((uint32_t)m_buffer[idx]->data, HEX); |
||||
} |
||||
} |
||||
private: |
||||
size_t m_head=0; ///< back of the queue
|
||||
size_t m_tail=0; ///< front of the queue
|
||||
size_t m_size=0; ///< current size of the qeueu
|
||||
T *m_buffer = nullptr; ///< pointer to the allocated buffer array
|
||||
const size_t m_maxSize; ///< maximum size of the queue
|
||||
}; |
||||
|
||||
} // BAGuitar
|
||||
|
||||
|
||||
#endif /* __BAGUITAR_BATYPES_H */ |
||||
@ -0,0 +1,283 @@ |
||||
/**************************************************************************//**
|
||||
* @file |
||||
* @author Steve Lascos |
||||
* @company Blackaddr Audio |
||||
* |
||||
* LibBasicFunctions is a collection of helpful functions and classes that make |
||||
* it easier to perform common tasks in Audio applications. |
||||
* |
||||
* @copyright This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*****************************************************************************/ |
||||
|
||||
#include <cstddef> |
||||
#include <new> |
||||
|
||||
#include <arm_math.h> |
||||
#include "Arduino.h" |
||||
#include "Audio.h" |
||||
|
||||
#include "BATypes.h" |
||||
#include "LibMemoryManagement.h" |
||||
|
||||
#ifndef __BAGUITAR_LIBBASICFUNCTIONS_H |
||||
#define __BAGUITAR_LIBBASICFUNCTIONS_H |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
/**************************************************************************//**
|
||||
* QueuePosition is used for storing the index (in an array of queues) and the |
||||
* offset within an audio_block_t data buffer. Useful for dealing with large |
||||
* windows of audio spread across multiple audio data blocks. |
||||
*****************************************************************************/ |
||||
struct QueuePosition { |
||||
int offset; ///< offset in samples within an audio_block_t data buffer
|
||||
int index; ///< index in an array of audio data blocks
|
||||
}; |
||||
|
||||
/// Calculate the exact sample position in an array of audio blocks that corresponds
|
||||
/// to a particular offset given as time.
|
||||
/// @param milliseconds length of the interval in milliseconds
|
||||
/// @returns a struct containing the index and offset
|
||||
QueuePosition calcQueuePosition(float milliseconds); |
||||
|
||||
/// Calculate the exact sample position in an array of audio blocks that corresponds
|
||||
/// to a particular offset given as a number of samples
|
||||
/// @param milliseconds length of the interval in milliseconds
|
||||
/// @returns a struct containing the index and offset
|
||||
QueuePosition calcQueuePosition(size_t numSamples); |
||||
|
||||
/// Calculate the number of audio samples (rounded up) that correspond to a
|
||||
/// given length of time.
|
||||
/// @param milliseconds length of the interval in milliseconds
|
||||
/// @returns the number of corresonding audio samples.
|
||||
size_t calcAudioSamples(float milliseconds); |
||||
|
||||
/// Calculate a length of time in milliseconds from the number of audio samples.
|
||||
/// @param numSamples Number of audio samples to convert to time
|
||||
/// @return the equivalent time in milliseconds.
|
||||
float calcAudioTimeMs(size_t numSamples); |
||||
|
||||
/// Calculate the number of audio samples (usually an offset) from
|
||||
/// a queue position.
|
||||
/// @param position specifies the index and offset within a queue
|
||||
/// @returns the number of samples from the start of the queue array to the
|
||||
/// specified position.
|
||||
size_t calcOffset(QueuePosition position); |
||||
|
||||
/// Clear the contents of an audio block to zero
|
||||
/// @param block pointer to the audio block to clear
|
||||
void clearAudioBlock(audio_block_t *block); |
||||
|
||||
/// Perform an alpha blend between to audio blocks. Performs <br>
|
||||
/// out = dry*(1-mix) + wet*(mix)
|
||||
/// @param out pointer to the destination audio block
|
||||
/// @param dry pointer to the dry audio
|
||||
/// @param wet pointer to the wet audio
|
||||
/// @param mix float between 0.0 and 1.0.
|
||||
void alphaBlend(audio_block_t *out, audio_block_t *dry, audio_block_t* wet, float mix); |
||||
|
||||
/// Applies a gain to the audio via fixed-point scaling accoring to <br>
|
||||
/// out = int * (vol * 2^coeffShift)
|
||||
/// @param out pointer to output audio block
|
||||
/// @param in pointer to input audio block
|
||||
/// @param vol volume cofficient between -1.0 and +1.0
|
||||
/// @param coeffShift number of bits to shiftt the coefficient
|
||||
void gainAdjust(audio_block_t *out, audio_block_t *in, float vol, int coeffShift = 0); |
||||
|
||||
|
||||
template <class T> |
||||
class RingBuffer; // forward declare so AudioDelay can use it.
|
||||
|
||||
|
||||
/**************************************************************************//**
|
||||
* Audio delays are a very common function in audio processing. In addition to |
||||
* being used for simply create a delay effect, it can also be used for buffering |
||||
* a sliding window in time of audio samples. This is useful when combining |
||||
* several audio_block_t data buffers together to form one large buffer for |
||||
* FFTs, etc. |
||||
* @details The buffer works like a queue. You add new audio_block_t when available, |
||||
* and the class will return an old buffer when it is to be discarded from the queue.<br> |
||||
* Note that using INTERNAL memory means the class will only store a queue |
||||
* of pointers to audio_block_t buffers, since the Teensy Audio uses a shared memory |
||||
* approach. When using EXTERNAL memory, data is actually copyied to/from an external |
||||
* SRAM device. |
||||
*****************************************************************************/ |
||||
constexpr size_t AUDIO_BLOCK_SIZE = sizeof(int16_t)*AUDIO_BLOCK_SAMPLES; |
||||
class AudioDelay { |
||||
public: |
||||
AudioDelay() = delete; |
||||
|
||||
/// Construct an audio buffer using INTERNAL memory by specifying the max number
|
||||
/// of audio samples you will want.
|
||||
/// @param maxSamples equal or greater than your longest delay requirement
|
||||
AudioDelay(size_t maxSamples); |
||||
|
||||
/// Construct an audio buffer using INTERNAL memory by specifying the max amount of
|
||||
/// time you will want available in the buffer.
|
||||
/// @param maxDelayTimeMs max length of time you want in the buffer specified in milliseconds
|
||||
AudioDelay(float maxDelayTimeMs); |
||||
|
||||
/// Construct an audio buffer using a slot configured with the BAGuitar::ExternalSramManager
|
||||
/// @param slot a pointer to the slot representing the memory you wish to use for the buffer.
|
||||
AudioDelay(ExtMemSlot *slot); |
||||
|
||||
~AudioDelay(); |
||||
|
||||
/// Add a new audio block into the buffer. When the buffer is filled,
|
||||
/// adding a new block will push out the oldest once which is returned.
|
||||
/// @param blockIn pointer to the most recent block of audio
|
||||
/// @returns the buffer to be discarded, or nullptr if not filled (INTERNAL), or
|
||||
/// not applicable (EXTERNAL).
|
||||
audio_block_t *addBlock(audio_block_t *blockIn); |
||||
|
||||
/// When using INTERNAL memory, returns the pointer for the specified index into buffer.
|
||||
/// @details, the most recent block is 0, 2nd most recent is 1, ..., etc.
|
||||
/// @param index the specifies how many buffers older than the current to retrieve
|
||||
/// @returns a pointer to the requested audio_block_t
|
||||
audio_block_t *getBlock(size_t index); |
||||
|
||||
/// Retrieve an audio block (or samples) from the buffer.
|
||||
/// @details when using INTERNAL memory, only supported size is AUDIO_BLOCK_SAMPLES. When using
|
||||
/// EXTERNAL, a size smaller than AUDIO_BLOCK_SAMPLES can be requested.
|
||||
/// @param dest pointer to the target audio block to write the samples to.
|
||||
/// @param offsetSamples data will start being transferred offset samples from the start of the audio buffer
|
||||
/// @param numSamples default value is AUDIO_BLOCK_SAMPLES, so typically you don't have to specify this parameter.
|
||||
/// @returns true on success, false on error.
|
||||
bool getSamples(audio_block_t *dest, size_t offsetSamples, size_t numSamples = AUDIO_BLOCK_SAMPLES); |
||||
|
||||
/// When using EXTERNAL memory, this function can return a pointer to the underlying ExtMemSlot object associated
|
||||
/// with the buffer.
|
||||
/// @returns pointer to the underlying ExtMemSlot.
|
||||
ExtMemSlot *getSlot() const { return m_slot; } |
||||
|
||||
/// Ween using INTERNAL memory, thsi function can return a pointer to the underlying RingBuffer that contains
|
||||
/// audio_block_t * pointers.
|
||||
/// @returns pointer to the underlying RingBuffer
|
||||
RingBuffer<audio_block_t*> *getRingBuffer() const { return m_ringBuffer; } |
||||
|
||||
private: |
||||
|
||||
/// enumerates whether the underlying memory buffer uses INTERNAL or EXTERNAL memory
|
||||
enum class MemType : unsigned { |
||||
MEM_INTERNAL = 0, ///< internal audio_block_t from the Teensy Audio Library is used
|
||||
MEM_EXTERNAL ///< external SPI based ram is used
|
||||
}; |
||||
|
||||
MemType m_type; ///< when 0, INTERNAL memory, when 1, external MEMORY.
|
||||
RingBuffer<audio_block_t *> *m_ringBuffer = nullptr; ///< When using INTERNAL memory, a RingBuffer will be created.
|
||||
ExtMemSlot *m_slot = nullptr; ///< When using EXTERNAL memory, an ExtMemSlot must be provided.
|
||||
}; |
||||
|
||||
/**************************************************************************//**
|
||||
* IIR BiQuad Filter - Direct Form I <br> |
||||
* y[n] = b0 * x[n] + b1 * x[n-1] + b2 * x[n-2] + a1 * y[n-1] + a2 * y[n-2]<br> |
||||
* Some design tools (like Matlab assume the feedback coefficients 'a' are negated. You |
||||
* may have to negate your 'a' coefficients. |
||||
* @details Note that the ARM CMSIS-DSP library requires an extra zero between first |
||||
* and second 'b' coefficients. E.g. <br> |
||||
* {b10, 0, b11, b12, a11, a12, b20, 0, b21, b22, a21, a22, ...} |
||||
*****************************************************************************/ |
||||
class IirBiQuadFilter { |
||||
public: |
||||
IirBiQuadFilter() = delete; |
||||
/// Construct a Biquad filter with specified number of stages, coefficients and scaling.
|
||||
/// @details See CMSIS-DSP documentation for more details
|
||||
/// @param numStages number of biquad stages. Each stage has 5 coefficients.
|
||||
/// @param coeffs pointer to an array of Q31 fixed-point coefficients (range -1 to +0.999...)
|
||||
/// @param coeffShift coeffs are multiplied by 2^coeffShift to support coefficient range scaling
|
||||
IirBiQuadFilter(unsigned numStages, const int32_t *coeffs, int coeffShift = 0); |
||||
virtual ~IirBiQuadFilter(); |
||||
|
||||
/// Process the data using the configured IIR filter
|
||||
/// @details output and input can be the same pointer if in-place modification is desired
|
||||
/// @param output pointer to where the output results will be written
|
||||
/// @param input pointer to where the input data will be read from
|
||||
/// @param numSampmles number of samples to process
|
||||
bool process(int16_t *output, int16_t *input, size_t numSamples); |
||||
private: |
||||
const unsigned NUM_STAGES; |
||||
int32_t *m_coeffs = nullptr; |
||||
|
||||
// ARM DSP Math library filter instance
|
||||
arm_biquad_casd_df1_inst_q31 m_iirCfg; |
||||
int32_t *m_state = nullptr; |
||||
}; |
||||
|
||||
/**************************************************************************//**
|
||||
* A High-precision version of IirBiQuadFilter often necessary for complex, multistage |
||||
* filters. This class uses CMSIS-DSP biquads with 64-bit internal precision instead |
||||
* of 32-bit. |
||||
*****************************************************************************/ |
||||
class IirBiQuadFilterHQ { |
||||
public: |
||||
IirBiQuadFilterHQ() = delete; |
||||
/// Construct a Biquad filter with specified number of stages, coefficients and scaling.
|
||||
/// @details See CMSIS-DSP documentation for more details
|
||||
/// @param numStages number of biquad stages. Each stage has 5 coefficients.
|
||||
/// @param coeffs pointer to an array of Q31 fixed-point coefficients (range -1 to +0.999...)
|
||||
/// @param coeffShift coeffs are multiplied by 2^coeffShift to support coefficient range scaling
|
||||
IirBiQuadFilterHQ(unsigned numStages, const int32_t *coeffs, int coeffShift = 0); |
||||
virtual ~IirBiQuadFilterHQ(); |
||||
|
||||
/// Process the data using the configured IIR filter
|
||||
/// @details output and input can be the same pointer if in-place modification is desired
|
||||
/// @param output pointer to where the output results will be written
|
||||
/// @param input pointer to where the input data will be read from
|
||||
/// @param numSampmles number of samples to process
|
||||
bool process(int16_t *output, int16_t *input, size_t numSamples); |
||||
private: |
||||
const unsigned NUM_STAGES; |
||||
int32_t *m_coeffs = nullptr; |
||||
|
||||
// ARM DSP Math library filter instance
|
||||
arm_biquad_cas_df1_32x64_ins_q31 m_iirCfg; |
||||
int64_t *m_state = nullptr; |
||||
}; |
||||
|
||||
/**************************************************************************//**
|
||||
* A single-precision floating-point biquad using CMSIS-DSP hardware instructions. |
||||
* @details Use this when IirBiQuadFilterHQ is insufficient, since that version |
||||
* is still faster with 64-bit fixed-point arithmetic. |
||||
*****************************************************************************/ |
||||
class IirBiQuadFilterFloat { |
||||
public: |
||||
IirBiQuadFilterFloat() = delete; |
||||
|
||||
/// Construct a Biquad filter with specified number of stages and coefficients
|
||||
/// @details See CMSIS-DSP documentation for more details
|
||||
/// @param numStages number of biquad stages. Each stage has 5 coefficients.
|
||||
/// @param coeffs pointer to an array of Q31 fixed-point coefficients (range -1 to +0.999...)
|
||||
IirBiQuadFilterFloat(unsigned numStages, const float *coeffs); |
||||
virtual ~IirBiQuadFilterFloat(); |
||||
|
||||
/// Process the data using the configured IIR filter
|
||||
/// @details output and input can be the same pointer if in-place modification is desired
|
||||
/// @param output pointer to where the output results will be written
|
||||
/// @param input pointer to where the input data will be read from
|
||||
/// @param numberSampmles number of samples to process
|
||||
bool process(float *output, float *input, size_t numSamples); |
||||
private: |
||||
const unsigned NUM_STAGES; |
||||
float *m_coeffs = nullptr; |
||||
|
||||
// ARM DSP Math library filter instance
|
||||
arm_biquad_cascade_df2T_instance_f32 m_iirCfg; |
||||
float *m_state = nullptr; |
||||
|
||||
}; |
||||
|
||||
} |
||||
|
||||
|
||||
#endif /* __BAGUITAR_LIBBASICFUNCTIONS_H */ |
||||
@ -0,0 +1,212 @@ |
||||
/**************************************************************************//**
|
||||
* @file |
||||
* @author Steve Lascos |
||||
* @company Blackaddr Audio |
||||
* |
||||
* LibMemoryManagment is a class for providing access to external SPI based |
||||
* SRAM with the optional convience of breaking it up into 'slots' which are smaller |
||||
* memory entities. |
||||
* @details This class treats an external memory as a pool from which the user requests |
||||
* a block. When using that block, the user need not be concerned with where the pool |
||||
* it came from, they only deal with offsets from the start of their memory block. Ie. |
||||
* Your particular slot of memory appears to you to start at 0 and end at whatever size |
||||
* was requested. |
||||
* |
||||
* @copyright This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*****************************************************************************/ |
||||
|
||||
#ifndef __BAGUITAR_LIBMEMORYMANAGEMENT_H |
||||
#define __BAGUITAR_LIBMEMORYMANAGEMENT_H |
||||
|
||||
#include <cstddef> |
||||
|
||||
#include "BAHardware.h" |
||||
#include "BASpiMemory.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
/**************************************************************************//**
|
||||
* MemConfig contains the configuration information associated with a particular |
||||
* SPI interface. |
||||
*****************************************************************************/ |
||||
struct MemConfig { |
||||
size_t size; ///< the total size of the external SPI memory
|
||||
size_t totalAvailable; ///< the number of bytes available (remaining)
|
||||
size_t nextAvailable; ///< the starting point for the next available slot
|
||||
BASpiMemory *m_spi = nullptr; ///< handle to the SPI interface
|
||||
}; |
||||
|
||||
class ExternalSramManager; // forward declare so ExtMemSlot can declared friendship with it
|
||||
|
||||
/**************************************************************************//**
|
||||
* ExtMemSlot provides a convenient interface to a particular slot of an |
||||
* external memory. |
||||
* @details the memory can be access randomly, as a single word, as a block of |
||||
* data, or as circular queue. |
||||
*****************************************************************************/ |
||||
class ExtMemSlot { |
||||
public: |
||||
|
||||
/// clear the entire contents of the slot by writing zeros
|
||||
/// @returns true on success
|
||||
bool clear(); |
||||
|
||||
/// set a new write position (in bytes) for circular operation
|
||||
/// @param offsetBytes moves the write pointer to the specified offset from the slot start
|
||||
/// @returns true on success, else false if offset is beyond slot boundaries.
|
||||
bool setWritePosition(size_t offsetBytes); |
||||
|
||||
/// returns the currently set write pointer pointer
|
||||
/// @returns the write position value
|
||||
size_t getWritePosition() const { return m_currentWrPosition-m_start; } |
||||
|
||||
/// set a new read position (in bytes) for circular operation
|
||||
/// @param offsetBytes moves the read pointer to the specified offset from the slot start
|
||||
/// @returns true on success, else false if offset is beyond slot boundaries.
|
||||
bool setReadPosition(size_t offsetBytes); |
||||
|
||||
/// returns the currently set read pointer pointer
|
||||
/// @returns the read position value
|
||||
size_t getReadPosition() const { return m_currentRdPosition-m_start; } |
||||
|
||||
/// Write a block of 16-bit data to the memory at the specified offset
|
||||
/// @param offsetWords offset in 16-bit words from start of slot
|
||||
/// @param src pointer to start of block of 16-bit data
|
||||
/// @param numWords number of 16-bit words to transfer
|
||||
/// @returns true on success, else false on error
|
||||
bool write16(size_t offsetWords, int16_t *src, size_t numWords); |
||||
|
||||
/// Write a block of zeros (16-bit) to the memory at the specified offset
|
||||
/// @param offsetWords offset in 16-bit words from start of slot
|
||||
/// @param numWords number of 16-bit words to transfer
|
||||
/// @returns true on success, else false on error
|
||||
bool zero16(size_t offsetWords, size_t numWords); |
||||
|
||||
/// Read a block of 16-bit data from the memory at the specified location
|
||||
/// @param offsetWords offset in 16-bit words from start of slot
|
||||
/// @param dest pointer to destination for the read data
|
||||
/// @param numWords number of 16-bit words to transfer
|
||||
/// @returns true on success, else false on error
|
||||
bool read16(size_t offsetWords, int16_t *dest, size_t numWords); |
||||
|
||||
/// Read the next in memory during circular operation
|
||||
/// @returns the next 16-bit data word in memory
|
||||
uint16_t readAdvance16(); |
||||
|
||||
|
||||
/// Read the next block of numWords during circular operation
|
||||
/// @details, dest is ignored when using DMA
|
||||
/// @param dest pointer to the destination of the read.
|
||||
/// @param numWords number of 16-bit words to transfer
|
||||
/// @returns true on success, else false on error
|
||||
bool readAdvance16(int16_t *dest, size_t numWords); |
||||
|
||||
/// Write a block of 16-bit data from the specified location in circular operation
|
||||
/// @param src pointer to the start of the block of data to write to memory
|
||||
/// @param numWords number of 16-bit words to transfer
|
||||
/// @returns true on success, else false on error
|
||||
bool writeAdvance16(int16_t *src, size_t numWords); |
||||
|
||||
/// Write a single 16-bit data to the next location in circular operation
|
||||
/// @param data the 16-bit word to transfer
|
||||
/// @returns true on success, else false on error
|
||||
bool writeAdvance16(int16_t data); // write just one data
|
||||
|
||||
/// Write a block of 16-bit data zeros in circular operation
|
||||
/// @param numWords number of 16-bit words to transfer
|
||||
/// @returns true on success, else false on error
|
||||
bool zeroAdvance16(size_t numWords); |
||||
|
||||
/// Get the size of the memory slot
|
||||
/// @returns size of the slot in bytes
|
||||
size_t size() const { return m_size; } |
||||
|
||||
/// Ensures the underlying SPI interface is enabled
|
||||
/// @returns true on success, false on error
|
||||
bool enable() const; |
||||
|
||||
/// Checks whether underlying SPI interface is enabled
|
||||
/// @returns true if enabled, false if not enabled
|
||||
bool isEnabled() const; |
||||
|
||||
bool isUseDma() const { return m_useDma; } |
||||
|
||||
bool isWriteBusy() const; |
||||
|
||||
bool isReadBusy() const; |
||||
|
||||
/// DEBUG USE: prints out the slot member variables
|
||||
void printStatus(void) const; |
||||
|
||||
private: |
||||
friend ExternalSramManager; ///< gives the manager access to the private variables
|
||||
bool m_valid = false; ///< After a slot is successfully configured by the manager it becomes valid
|
||||
size_t m_start = 0; ///< the external memory address in bytes where this slot starts
|
||||
size_t m_end = 0; ///< the external memory address in bytes where this slot ends (inclusive)
|
||||
size_t m_currentWrPosition = 0; ///< current write pointer for circular operation
|
||||
size_t m_currentRdPosition = 0; ///< current read pointer for circular operation
|
||||
size_t m_size = 0; ///< size of this slot in bytes
|
||||
bool m_useDma = false; ///< when TRUE, BASpiMemoryDMA will be used.
|
||||
SpiDeviceId m_spiId; ///< the SPI Device ID
|
||||
BASpiMemory *m_spi = nullptr; ///< pointer to an instance of the BASpiMemory interface class
|
||||
}; |
||||
|
||||
|
||||
/**************************************************************************//**
|
||||
* ExternalSramManager provides a class to handle dividing an external SPI RAM |
||||
* into independent slots for general use. |
||||
* @details the class does not support deallocated memory because this would cause |
||||
* fragmentation. |
||||
*****************************************************************************/ |
||||
class ExternalSramManager final { |
||||
public: |
||||
ExternalSramManager(); |
||||
|
||||
/// The manager is constructed by specifying how many external memories to handle allocations for
|
||||
/// @param numMemories the number of external memories
|
||||
ExternalSramManager(unsigned numMemories); |
||||
virtual ~ExternalSramManager(); |
||||
|
||||
/// Query the amount of available (unallocated) memory
|
||||
/// @details note that currently, memory cannot be allocated.
|
||||
/// @param mem specifies which memory to query, default is memory 0
|
||||
/// @returns the available memory in bytes
|
||||
size_t availableMemory(BAGuitar::MemSelect mem = BAGuitar::MemSelect::MEM0); |
||||
|
||||
/// Request memory be allocated for the provided slot
|
||||
/// @param slot a pointer to the global slot object to which memory will be allocated
|
||||
/// @param delayMilliseconds request the amount of memory based on required time for audio samples, rather than number of bytes.
|
||||
/// @param mem specify which external memory to allocate from
|
||||
/// @param useDma when true, DMA is used for SPI port, else transfers block until complete
|
||||
/// @returns true on success, otherwise false on error
|
||||
bool requestMemory(ExtMemSlot *slot, float delayMilliseconds, BAGuitar::MemSelect mem = BAGuitar::MemSelect::MEM0, bool useDma = false); |
||||
|
||||
/// Request memory be allocated for the provided slot
|
||||
/// @param slot a pointer to the global slot object to which memory will be allocated
|
||||
/// @param sizeBytes request the amount of memory in bytes to request
|
||||
/// @param mem specify which external memory to allocate from
|
||||
/// @param useDma when true, DMA is used for SPI port, else transfers block until complete
|
||||
/// @returns true on success, otherwise false on error
|
||||
bool requestMemory(ExtMemSlot *slot, size_t sizeBytes, BAGuitar::MemSelect mem = BAGuitar::MemSelect::MEM0, bool useDma = false); |
||||
|
||||
private: |
||||
static bool m_configured; ///< there should only be one instance of ExternalSramManager in the whole project
|
||||
static MemConfig m_memConfig[BAGuitar::NUM_MEM_SLOTS]; ///< store the configuration information for each external memory
|
||||
|
||||
}; |
||||
|
||||
|
||||
} |
||||
|
||||
#endif /* __LIBMEMORYMANAGEMENT_H */ |
||||
@ -0,0 +1,171 @@ |
||||
/*
|
||||
* AudioDelay.cpp |
||||
* |
||||
* Created on: January 1, 2018 |
||||
* Author: slascos |
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "Audio.h" |
||||
#include "LibBasicFunctions.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
////////////////////////////////////////////////////
|
||||
// AudioDelay
|
||||
////////////////////////////////////////////////////
|
||||
AudioDelay::AudioDelay(size_t maxSamples) |
||||
: m_slot(nullptr) |
||||
{ |
||||
m_type = (MemType::MEM_INTERNAL); |
||||
|
||||
// INTERNAL memory consisting of audio_block_t data structures.
|
||||
QueuePosition pos = calcQueuePosition(maxSamples); |
||||
m_ringBuffer = new RingBuffer<audio_block_t *>(pos.index+2); // If the delay is in queue x, we need to overflow into x+1, thus x+2 total buffers.
|
||||
} |
||||
|
||||
AudioDelay::AudioDelay(float maxDelayTimeMs) |
||||
: AudioDelay(calcAudioSamples(maxDelayTimeMs)) |
||||
{ |
||||
|
||||
} |
||||
|
||||
AudioDelay::AudioDelay(ExtMemSlot *slot) |
||||
{ |
||||
m_type = (MemType::MEM_EXTERNAL); |
||||
m_slot = slot; |
||||
} |
||||
|
||||
AudioDelay::~AudioDelay() |
||||
{ |
||||
if (m_ringBuffer) delete m_ringBuffer; |
||||
} |
||||
|
||||
audio_block_t* AudioDelay::addBlock(audio_block_t *block) |
||||
{ |
||||
audio_block_t *blockToRelease = nullptr; |
||||
|
||||
if (m_type == (MemType::MEM_INTERNAL)) { |
||||
// INTERNAL memory
|
||||
|
||||
// purposefully don't check if block is valid, the ringBuffer can support nullptrs
|
||||
if ( m_ringBuffer->size() >= m_ringBuffer->max_size() ) { |
||||
// pop before adding
|
||||
blockToRelease = m_ringBuffer->front(); |
||||
m_ringBuffer->pop_front(); |
||||
} |
||||
|
||||
// add the new buffer
|
||||
m_ringBuffer->push_back(block); |
||||
return blockToRelease; |
||||
|
||||
} else { |
||||
// EXTERNAL memory
|
||||
if (!m_slot) { Serial.println("addBlock(): m_slot is not valid"); } |
||||
|
||||
if (block) { |
||||
// this causes pops
|
||||
m_slot->writeAdvance16(block->data, AUDIO_BLOCK_SAMPLES); |
||||
} |
||||
blockToRelease = block; |
||||
} |
||||
return blockToRelease; |
||||
} |
||||
|
||||
audio_block_t* AudioDelay::getBlock(size_t index) |
||||
{ |
||||
audio_block_t *ret = nullptr; |
||||
if (m_type == (MemType::MEM_INTERNAL)) { |
||||
ret = m_ringBuffer->at(m_ringBuffer->get_index_from_back(index)); |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
bool AudioDelay::getSamples(audio_block_t *dest, size_t offsetSamples, size_t numSamples) |
||||
{ |
||||
if (!dest) { |
||||
Serial.println("getSamples(): dest is invalid"); |
||||
return false; |
||||
} |
||||
|
||||
if (m_type == (MemType::MEM_INTERNAL)) { |
||||
QueuePosition position = calcQueuePosition(offsetSamples); |
||||
size_t index = position.index; |
||||
|
||||
audio_block_t *currentQueue0 = m_ringBuffer->at(m_ringBuffer->get_index_from_back(index)); |
||||
// The latest buffer is at the back. We need index+1 counting from the back.
|
||||
audio_block_t *currentQueue1 = m_ringBuffer->at(m_ringBuffer->get_index_from_back(index+1)); |
||||
|
||||
// check if either queue is invalid, if so just zero the destination buffer
|
||||
if ( (!currentQueue0) || (!currentQueue0) ) { |
||||
// a valid entry is not in all queue positions while it is filling, use zeros
|
||||
memset(static_cast<void*>(dest->data), 0, numSamples * sizeof(int16_t)); |
||||
return true; |
||||
} |
||||
|
||||
if (position.offset == 0) { |
||||
// single transfer
|
||||
memcpy(static_cast<void*>(dest->data), static_cast<void*>(currentQueue0->data), numSamples * sizeof(int16_t)); |
||||
return true; |
||||
} |
||||
|
||||
// Otherwise we need to break the transfer into two memcpy because it will go across two source queues.
|
||||
// Audio is stored in reverse order. That means the first sample (in time) goes in the last location in the audio block.
|
||||
int16_t *destStart = dest->data; |
||||
int16_t *srcStart; |
||||
|
||||
// Break the transfer into two. Copy the 'older' data first then the 'newer' data with respect to current time.
|
||||
//currentQueue = m_ringBuffer->at(m_ringBuffer->get_index_from_back(index+1)); // The latest buffer is at the back. We need index+1 counting from the back.
|
||||
srcStart = (currentQueue1->data + AUDIO_BLOCK_SAMPLES - position.offset); |
||||
size_t numData = position.offset; |
||||
memcpy(static_cast<void*>(destStart), static_cast<void*>(srcStart), numData * sizeof(int16_t)); |
||||
|
||||
//currentQueue = m_ringBuffer->at(m_ringBuffer->get_index_from_back(index)); // now grab the queue where the 'first' data sample was
|
||||
destStart += numData; // we already wrote numData so advance by this much.
|
||||
srcStart = (currentQueue0->data); |
||||
numData = AUDIO_BLOCK_SAMPLES - numData; |
||||
memcpy(static_cast<void*>(destStart), static_cast<void*>(srcStart), numData * sizeof(int16_t)); |
||||
|
||||
return true; |
||||
|
||||
} else { |
||||
// EXTERNAL Memory
|
||||
if (numSamples*sizeof(int16_t) <= m_slot->size() ) { |
||||
int currentPositionBytes = (int)m_slot->getWritePosition() - (int)(AUDIO_BLOCK_SAMPLES*sizeof(int16_t)); |
||||
size_t offsetBytes = offsetSamples * sizeof(int16_t); |
||||
|
||||
if ((int)offsetBytes <= currentPositionBytes) { |
||||
m_slot->setReadPosition(currentPositionBytes - offsetBytes); |
||||
} else { |
||||
// It's going to wrap around to the end of the slot
|
||||
int readPosition = (int)m_slot->size() + currentPositionBytes - offsetBytes; |
||||
m_slot->setReadPosition((size_t)readPosition); |
||||
} |
||||
|
||||
// This causes pops
|
||||
m_slot->readAdvance16(dest->data, AUDIO_BLOCK_SAMPLES); |
||||
|
||||
return true; |
||||
} else { |
||||
// numSampmles is > than total slot size
|
||||
Serial.println("getSamples(): ERROR numSamples > total slot size"); |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
} |
||||
|
||||
} |
||||
|
||||
@ -0,0 +1,78 @@ |
||||
/*
|
||||
* AudioHelpers.cpp |
||||
* |
||||
* Created on: January 1, 2018 |
||||
* Author: slascos |
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "Audio.h" |
||||
#include "LibBasicFunctions.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
size_t calcAudioSamples(float milliseconds) |
||||
{ |
||||
return (size_t)((milliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0f))+0.5f); |
||||
} |
||||
|
||||
float calcAudioTimeMs(size_t numSamples) |
||||
{ |
||||
return ((float)(numSamples) / AUDIO_SAMPLE_RATE_EXACT) * 1000.0f; |
||||
} |
||||
|
||||
QueuePosition calcQueuePosition(size_t numSamples) |
||||
{ |
||||
QueuePosition queuePosition; |
||||
queuePosition.index = (int)(numSamples / AUDIO_BLOCK_SAMPLES); |
||||
queuePosition.offset = numSamples % AUDIO_BLOCK_SAMPLES; |
||||
return queuePosition; |
||||
} |
||||
QueuePosition calcQueuePosition(float milliseconds) { |
||||
size_t numSamples = (int)((milliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0f))+0.5f); |
||||
return calcQueuePosition(numSamples); |
||||
} |
||||
|
||||
size_t calcOffset(QueuePosition position) |
||||
{ |
||||
return (position.index*AUDIO_BLOCK_SAMPLES) + position.offset; |
||||
} |
||||
|
||||
void alphaBlend(audio_block_t *out, audio_block_t *dry, audio_block_t* wet, float mix) |
||||
{ |
||||
// ARM DSP optimized
|
||||
int16_t wetBuffer[AUDIO_BLOCK_SAMPLES]; |
||||
int16_t dryBuffer[AUDIO_BLOCK_SAMPLES]; |
||||
int16_t scaleFractWet = (int16_t)(mix * 32767.0f); |
||||
int16_t scaleFractDry = 32767-scaleFractWet; |
||||
|
||||
arm_scale_q15(dry->data, scaleFractDry, 0, dryBuffer, AUDIO_BLOCK_SAMPLES); |
||||
arm_scale_q15(wet->data, scaleFractWet, 0, wetBuffer, AUDIO_BLOCK_SAMPLES); |
||||
arm_add_q15(wetBuffer, dryBuffer, out->data, AUDIO_BLOCK_SAMPLES); |
||||
} |
||||
|
||||
void gainAdjust(audio_block_t *out, audio_block_t *in, float vol, int coeffShift) |
||||
{ |
||||
int16_t scale = (int16_t)(vol * 32767.0f); |
||||
arm_scale_q15(in->data, scale, coeffShift, out->data, AUDIO_BLOCK_SAMPLES); |
||||
} |
||||
|
||||
void clearAudioBlock(audio_block_t *block) |
||||
{ |
||||
memset(block->data, 0, sizeof(int16_t)*AUDIO_BLOCK_SAMPLES); |
||||
} |
||||
|
||||
} |
||||
|
||||
@ -0,0 +1,235 @@ |
||||
/*
|
||||
* ExtMemSlot.cpp |
||||
* |
||||
* Created on: Jan 19, 2018 |
||||
* Author: slascos |
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
#include <cstring> |
||||
#include <new> |
||||
|
||||
#include "Audio.h" |
||||
#include "LibMemoryManagement.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// MEM SLOT
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
bool ExtMemSlot::clear() |
||||
{ |
||||
if (!m_valid) { return false; } |
||||
m_spi->zero16(m_start, m_size); |
||||
return true; |
||||
} |
||||
|
||||
bool ExtMemSlot::setWritePosition(size_t offsetBytes) |
||||
{ |
||||
if (m_start + offsetBytes <= m_end) { |
||||
m_currentWrPosition = m_start + offsetBytes; |
||||
return true; |
||||
} else { return false; } |
||||
} |
||||
|
||||
bool ExtMemSlot::write16(size_t offsetWords, int16_t *src, size_t numWords) |
||||
{ |
||||
if (!m_valid) { return false; } |
||||
size_t writeStart = m_start + sizeof(int16_t)*offsetWords; // 2x because int16 is two bytes per data
|
||||
size_t numBytes = sizeof(int16_t)*numWords; |
||||
if ((writeStart + numBytes-1) <= m_end) { |
||||
m_spi->write16(writeStart, reinterpret_cast<uint16_t*>(src), numWords); // cast audio data to uint
|
||||
return true; |
||||
} else { |
||||
// this would go past the end of the memory slot, do not perform the write
|
||||
return false; |
||||
} |
||||
} |
||||
|
||||
bool ExtMemSlot::setReadPosition(size_t offsetBytes) |
||||
{ |
||||
if (m_start + offsetBytes <= m_end) { |
||||
m_currentRdPosition = m_start + offsetBytes; |
||||
return true; |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
bool ExtMemSlot::zero16(size_t offsetWords, size_t numWords) |
||||
{ |
||||
if (!m_valid) { return false; } |
||||
size_t writeStart = m_start + sizeof(int16_t)*offsetWords; |
||||
size_t numBytes = sizeof(int16_t)*numWords; |
||||
if ((writeStart + numBytes-1) <= m_end) { |
||||
m_spi->zero16(writeStart, numWords); // cast audio data to uint
|
||||
return true; |
||||
} else { |
||||
// this would go past the end of the memory slot, do not perform the write
|
||||
return false; |
||||
} |
||||
} |
||||
|
||||
bool ExtMemSlot::read16(size_t offsetWords, int16_t *dest, size_t numWords) |
||||
{ |
||||
if (!dest) return false; // invalid destination
|
||||
size_t readOffset = m_start + sizeof(int16_t)*offsetWords; |
||||
size_t numBytes = sizeof(int16_t)*numWords; |
||||
|
||||
if ((readOffset + numBytes-1) <= m_end) { |
||||
m_spi->read16(readOffset, reinterpret_cast<uint16_t*>(dest), numWords); |
||||
return true; |
||||
} else { |
||||
// this would go past the end of the memory slot, do not perform the read
|
||||
return false; |
||||
} |
||||
} |
||||
|
||||
uint16_t ExtMemSlot::readAdvance16() |
||||
{ |
||||
uint16_t val = m_spi->read16(m_currentRdPosition); |
||||
if (m_currentRdPosition < m_end-1) { |
||||
m_currentRdPosition +=2; // position is in bytes and we read two
|
||||
} else { |
||||
m_currentRdPosition = m_start; |
||||
} |
||||
return val; |
||||
} |
||||
|
||||
bool ExtMemSlot::readAdvance16(int16_t *dest, size_t numWords) |
||||
{ |
||||
if (!m_valid) { return false; } |
||||
size_t numBytes = sizeof(int16_t)*numWords; |
||||
|
||||
if (m_currentRdPosition + numBytes-1 <= m_end) { |
||||
// entire block fits in memory slot without wrapping
|
||||
m_spi->read16(m_currentRdPosition, reinterpret_cast<uint16_t*>(dest), numWords); // cast audio data to uint.
|
||||
m_currentRdPosition += numBytes; |
||||
|
||||
} else { |
||||
// this read will wrap the memory slot
|
||||
size_t rdBytes = m_end - m_currentRdPosition + 1; |
||||
size_t rdDataNum = rdBytes >> 1; // divide by two to get the number of data
|
||||
m_spi->read16(m_currentRdPosition, reinterpret_cast<uint16_t*>(dest), rdDataNum); |
||||
size_t remainingData = numWords - rdDataNum; |
||||
m_spi->read16(m_start, reinterpret_cast<uint16_t*>(dest + rdDataNum), remainingData); // write remaining bytes are start
|
||||
m_currentRdPosition = m_start + (remainingData*sizeof(int16_t)); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
|
||||
bool ExtMemSlot::writeAdvance16(int16_t *src, size_t numWords) |
||||
{ |
||||
if (!m_valid) { return false; } |
||||
size_t numBytes = sizeof(int16_t)*numWords; |
||||
|
||||
if (m_currentWrPosition + numBytes-1 <= m_end) { |
||||
// entire block fits in memory slot without wrapping
|
||||
m_spi->write16(m_currentWrPosition, reinterpret_cast<uint16_t*>(src), numWords); // cast audio data to uint.
|
||||
m_currentWrPosition += numBytes; |
||||
|
||||
} else { |
||||
// this write will wrap the memory slot
|
||||
size_t wrBytes = m_end - m_currentWrPosition + 1; |
||||
size_t wrDataNum = wrBytes >> 1; // divide by two to get the number of data
|
||||
m_spi->write16(m_currentWrPosition, reinterpret_cast<uint16_t*>(src), wrDataNum); |
||||
size_t remainingData = numWords - wrDataNum; |
||||
m_spi->write16(m_start, reinterpret_cast<uint16_t*>(src + wrDataNum), remainingData); // write remaining bytes are start
|
||||
m_currentWrPosition = m_start + (remainingData*sizeof(int16_t)); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
|
||||
bool ExtMemSlot::zeroAdvance16(size_t numWords) |
||||
{ |
||||
if (!m_valid) { return false; } |
||||
size_t numBytes = 2*numWords; |
||||
if (m_currentWrPosition + numBytes-1 <= m_end) { |
||||
// entire block fits in memory slot without wrapping
|
||||
m_spi->zero16(m_currentWrPosition, numWords); // cast audio data to uint.
|
||||
m_currentWrPosition += numBytes; |
||||
|
||||
} else { |
||||
// this write will wrap the memory slot
|
||||
size_t wrBytes = m_end - m_currentWrPosition + 1; |
||||
size_t wrDataNum = wrBytes >> 1; |
||||
m_spi->zero16(m_currentWrPosition, wrDataNum); |
||||
size_t remainingWords = numWords - wrDataNum; // calculate the remaining bytes
|
||||
m_spi->zero16(m_start, remainingWords); // write remaining bytes are start
|
||||
m_currentWrPosition = m_start + remainingWords*sizeof(int16_t); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
|
||||
bool ExtMemSlot::writeAdvance16(int16_t data) |
||||
{ |
||||
if (!m_valid) { return false; } |
||||
|
||||
m_spi->write16(m_currentWrPosition, static_cast<uint16_t>(data)); |
||||
if (m_currentWrPosition < m_end-1) { |
||||
m_currentWrPosition+=2; // wrote two bytes
|
||||
} else { |
||||
m_currentWrPosition = m_start; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
|
||||
bool ExtMemSlot::enable() const |
||||
{ |
||||
if (m_spi) { |
||||
Serial.println("ExtMemSlot::enable()"); |
||||
m_spi->begin(); |
||||
return true; |
||||
} |
||||
else { |
||||
Serial.println("ExtMemSlot m_spi is nullptr"); |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
bool ExtMemSlot::isEnabled() const |
||||
{ |
||||
if (m_spi) { return m_spi->isStarted(); } |
||||
else return false; |
||||
} |
||||
|
||||
bool ExtMemSlot::isWriteBusy() const |
||||
{ |
||||
if (m_useDma) { |
||||
return (static_cast<BASpiMemoryDMA*>(m_spi))->isWriteBusy(); |
||||
} else { return false; } |
||||
} |
||||
|
||||
bool ExtMemSlot::isReadBusy() const |
||||
{ |
||||
if (m_useDma) { |
||||
return (static_cast<BASpiMemoryDMA*>(m_spi))->isReadBusy(); |
||||
} else { return false; } |
||||
} |
||||
|
||||
|
||||
void ExtMemSlot::printStatus(void) const |
||||
{ |
||||
Serial.println(String("valid:") + m_valid + String(" m_start:") + m_start + \
|
||||
String(" m_end:") + m_end + String(" m_currentWrPosition: ") + m_currentWrPosition + \
|
||||
String(" m_currentRdPosition: ") + m_currentRdPosition + \
|
||||
String(" m_size:") + m_size); |
||||
} |
||||
|
||||
} |
||||
|
||||
@ -0,0 +1,120 @@ |
||||
/*
|
||||
* LibMemoryManagement.cpp |
||||
* |
||||
* Created on: Jan 19, 2018 |
||||
* Author: slascos |
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
#include <cstring> |
||||
#include <new> |
||||
|
||||
#include "Audio.h" |
||||
#include "LibMemoryManagement.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// EXTERNAL SRAM MANAGER
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
bool ExternalSramManager::m_configured = false; |
||||
MemConfig ExternalSramManager::m_memConfig[BAGuitar::NUM_MEM_SLOTS]; |
||||
|
||||
|
||||
ExternalSramManager::ExternalSramManager(unsigned numMemories) |
||||
{ |
||||
// Initialize the static memory configuration structs
|
||||
if (!m_configured) { |
||||
for (unsigned i=0; i < NUM_MEM_SLOTS; i++) { |
||||
m_memConfig[i].size = MEM_MAX_ADDR[i]; |
||||
m_memConfig[i].totalAvailable = MEM_MAX_ADDR[i]; |
||||
m_memConfig[i].nextAvailable = 0; |
||||
|
||||
m_memConfig[i].m_spi = nullptr; |
||||
} |
||||
m_configured = true; |
||||
} |
||||
} |
||||
|
||||
ExternalSramManager::ExternalSramManager() |
||||
: ExternalSramManager(1) |
||||
{ |
||||
|
||||
} |
||||
|
||||
ExternalSramManager::~ExternalSramManager() |
||||
{ |
||||
for (unsigned i=0; i < NUM_MEM_SLOTS; i++) { |
||||
if (m_memConfig[i].m_spi) { delete m_memConfig[i].m_spi; } |
||||
} |
||||
} |
||||
|
||||
size_t ExternalSramManager::availableMemory(BAGuitar::MemSelect mem) |
||||
{ |
||||
return m_memConfig[mem].totalAvailable; |
||||
} |
||||
|
||||
bool ExternalSramManager::requestMemory(ExtMemSlot *slot, float delayMilliseconds, BAGuitar::MemSelect mem, bool useDma) |
||||
{ |
||||
// convert the time to numer of samples
|
||||
size_t delayLengthInt = (size_t)((delayMilliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0f))+0.5f); |
||||
return requestMemory(slot, delayLengthInt * sizeof(int16_t), mem, useDma); |
||||
} |
||||
|
||||
bool ExternalSramManager::requestMemory(ExtMemSlot *slot, size_t sizeBytes, BAGuitar::MemSelect mem, bool useDma) |
||||
{ |
||||
|
||||
if (m_memConfig[mem].totalAvailable >= sizeBytes) { |
||||
Serial.println(String("Configuring a slot for mem ") + mem); |
||||
// there is enough available memory for this request
|
||||
slot->m_start = m_memConfig[mem].nextAvailable; |
||||
slot->m_end = slot->m_start + sizeBytes -1; |
||||
slot->m_currentWrPosition = slot->m_start; // init to start of slot
|
||||
slot->m_currentRdPosition = slot->m_start; // init to start of slot
|
||||
slot->m_size = sizeBytes; |
||||
|
||||
if (!m_memConfig[mem].m_spi) { |
||||
if (useDma) { |
||||
m_memConfig[mem].m_spi = new BAGuitar::BASpiMemoryDMA(static_cast<BAGuitar::SpiDeviceId>(mem)); |
||||
slot->m_useDma = true; |
||||
} else { |
||||
m_memConfig[mem].m_spi = new BAGuitar::BASpiMemory(static_cast<BAGuitar::SpiDeviceId>(mem)); |
||||
slot->m_useDma = false; |
||||
} |
||||
if (!m_memConfig[mem].m_spi) { |
||||
} else { |
||||
Serial.println("Calling spi begin()"); |
||||
m_memConfig[mem].m_spi->begin(); |
||||
} |
||||
} |
||||
slot->m_spi = m_memConfig[mem].m_spi; |
||||
|
||||
// Update the mem config
|
||||
m_memConfig[mem].nextAvailable = slot->m_end+1; |
||||
m_memConfig[mem].totalAvailable -= sizeBytes; |
||||
slot->m_valid = true; |
||||
if (!slot->isEnabled()) { slot->enable(); } |
||||
Serial.println("Clear the memory\n"); Serial.flush(); |
||||
slot->clear(); |
||||
Serial.println("Done Request memory\n"); Serial.flush(); |
||||
return true; |
||||
} else { |
||||
// there is not enough memory available for the request
|
||||
|
||||
return false; |
||||
} |
||||
} |
||||
|
||||
} |
||||
|
||||
@ -0,0 +1,145 @@ |
||||
/*
|
||||
* IirBiquadFilter.cpp |
||||
* |
||||
* Created on: January 1, 2018 |
||||
* Author: slascos |
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "Audio.h" |
||||
#include "LibBasicFunctions.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
////////////////////////////////////////////////////
|
||||
// IirBiQuadFilter
|
||||
////////////////////////////////////////////////////
|
||||
IirBiQuadFilter::IirBiQuadFilter(unsigned numStages, const int32_t *coeffs, int coeffShift) |
||||
: NUM_STAGES(numStages) |
||||
{ |
||||
m_coeffs = new int32_t[5*numStages]; |
||||
memcpy(m_coeffs, coeffs, 5*numStages * sizeof(int32_t)); |
||||
|
||||
m_state = new int32_t[4*numStages]; |
||||
arm_biquad_cascade_df1_init_q31(&m_iirCfg, numStages, m_coeffs, m_state, coeffShift); |
||||
} |
||||
|
||||
IirBiQuadFilter::~IirBiQuadFilter() |
||||
{ |
||||
if (m_coeffs) delete [] m_coeffs; |
||||
if (m_state) delete [] m_state; |
||||
} |
||||
|
||||
|
||||
bool IirBiQuadFilter::process(int16_t *output, int16_t *input, size_t numSamples) |
||||
{ |
||||
if (!output) return false; |
||||
if (!input) { |
||||
// send zeros
|
||||
memset(output, 0, numSamples * sizeof(int16_t)); |
||||
} else { |
||||
|
||||
// create convertion buffers on teh stack
|
||||
int32_t input32[numSamples]; |
||||
int32_t output32[numSamples]; |
||||
for (size_t i=0; i<numSamples; i++) { |
||||
input32[i] = (int32_t)(input[i]); |
||||
} |
||||
|
||||
arm_biquad_cascade_df1_fast_q31(&m_iirCfg, input32, output32, numSamples); |
||||
|
||||
for (size_t i=0; i<numSamples; i++) { |
||||
output[i] = (int16_t)(output32[i] & 0xffff); |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
// HIGH QUALITY
|
||||
IirBiQuadFilterHQ::IirBiQuadFilterHQ(unsigned numStages, const int32_t *coeffs, int coeffShift) |
||||
: NUM_STAGES(numStages) |
||||
{ |
||||
m_coeffs = new int32_t[5*numStages]; |
||||
memcpy(m_coeffs, coeffs, 5*numStages * sizeof(int32_t)); |
||||
|
||||
m_state = new int64_t[4*numStages];; |
||||
arm_biquad_cas_df1_32x64_init_q31(&m_iirCfg, numStages, m_coeffs, m_state, coeffShift); |
||||
} |
||||
|
||||
IirBiQuadFilterHQ::~IirBiQuadFilterHQ() |
||||
{ |
||||
if (m_coeffs) delete [] m_coeffs; |
||||
if (m_state) delete [] m_state; |
||||
} |
||||
|
||||
|
||||
bool IirBiQuadFilterHQ::process(int16_t *output, int16_t *input, size_t numSamples) |
||||
{ |
||||
if (!output) return false; |
||||
if (!input) { |
||||
// send zeros
|
||||
memset(output, 0, numSamples * sizeof(int16_t)); |
||||
} else { |
||||
|
||||
// create convertion buffers on teh stack
|
||||
int32_t input32[numSamples]; |
||||
int32_t output32[numSamples]; |
||||
for (size_t i=0; i<numSamples; i++) { |
||||
input32[i] = (int32_t)(input[i]); |
||||
} |
||||
|
||||
arm_biquad_cas_df1_32x64_q31(&m_iirCfg, input32, output32, numSamples); |
||||
|
||||
for (size_t i=0; i<numSamples; i++) { |
||||
output[i] = (int16_t)(output32[i] & 0xffff); |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
// FLOAT
|
||||
IirBiQuadFilterFloat::IirBiQuadFilterFloat(unsigned numStages, const float *coeffs) |
||||
: NUM_STAGES(numStages) |
||||
{ |
||||
m_coeffs = new float[5*numStages]; |
||||
memcpy(m_coeffs, coeffs, 5*numStages * sizeof(float)); |
||||
|
||||
m_state = new float[4*numStages];; |
||||
arm_biquad_cascade_df2T_init_f32(&m_iirCfg, numStages, m_coeffs, m_state); |
||||
} |
||||
|
||||
IirBiQuadFilterFloat::~IirBiQuadFilterFloat() |
||||
{ |
||||
if (m_coeffs) delete [] m_coeffs; |
||||
if (m_state) delete [] m_state; |
||||
} |
||||
|
||||
|
||||
bool IirBiQuadFilterFloat::process(float *output, float *input, size_t numSamples) |
||||
{ |
||||
if (!output) return false; |
||||
if (!input) { |
||||
// send zeros
|
||||
memset(output, 0, numSamples * sizeof(float)); |
||||
} else { |
||||
|
||||
arm_biquad_cascade_df2T_f32(&m_iirCfg, input, output, numSamples); |
||||
|
||||
} |
||||
return true; |
||||
} |
||||
|
||||
} |
||||
|
||||
@ -0,0 +1,279 @@ |
||||
/*
|
||||
* AudioEffectAnalogDelay.cpp |
||||
* |
||||
* Created on: Jan 7, 2018 |
||||
* Author: slascos |
||||
*/ |
||||
#include <new> |
||||
#include "AudioEffectAnalogDelay.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
constexpr int MIDI_CHANNEL = 0; |
||||
constexpr int MIDI_CONTROL = 1; |
||||
|
||||
// BOSS DM-3 Filters
|
||||
constexpr unsigned NUM_IIR_STAGES = 4; |
||||
constexpr unsigned IIR_COEFF_SHIFT = 2; |
||||
constexpr int32_t DEFAULT_COEFFS[5*NUM_IIR_STAGES] = { |
||||
536870912, 988616936, 455608573, 834606945, -482959709, |
||||
536870912, 1031466345, 498793368, 965834205, -467402235, |
||||
536870912, 1105821939, 573646688, 928470657, -448083489, |
||||
2339, 5093, 2776, 302068995, 4412722 |
||||
}; |
||||
|
||||
|
||||
AudioEffectAnalogDelay::AudioEffectAnalogDelay(float maxDelayMs) |
||||
: AudioStream(1, m_inputQueueArray) |
||||
{ |
||||
m_memory = new AudioDelay(maxDelayMs); |
||||
m_maxDelaySamples = calcAudioSamples(maxDelayMs); |
||||
m_iir = new IirBiQuadFilterHQ(NUM_IIR_STAGES, reinterpret_cast<const int32_t *>(&DEFAULT_COEFFS), IIR_COEFF_SHIFT); |
||||
} |
||||
|
||||
AudioEffectAnalogDelay::AudioEffectAnalogDelay(size_t numSamples) |
||||
: AudioStream(1, m_inputQueueArray) |
||||
{ |
||||
m_memory = new AudioDelay(numSamples); |
||||
m_maxDelaySamples = numSamples; |
||||
m_iir = new IirBiQuadFilterHQ(NUM_IIR_STAGES, reinterpret_cast<const int32_t *>(&DEFAULT_COEFFS), IIR_COEFF_SHIFT); |
||||
} |
||||
|
||||
// requires preallocated memory large enough
|
||||
AudioEffectAnalogDelay::AudioEffectAnalogDelay(ExtMemSlot *slot) |
||||
: AudioStream(1, m_inputQueueArray) |
||||
{ |
||||
m_memory = new AudioDelay(slot); |
||||
m_maxDelaySamples = (slot->size() / sizeof(int16_t)); |
||||
m_externalMemory = true; |
||||
m_iir = new IirBiQuadFilterHQ(NUM_IIR_STAGES, reinterpret_cast<const int32_t *>(&DEFAULT_COEFFS), IIR_COEFF_SHIFT); |
||||
} |
||||
|
||||
AudioEffectAnalogDelay::~AudioEffectAnalogDelay() |
||||
{ |
||||
if (m_memory) delete m_memory; |
||||
if (m_iir) delete m_iir; |
||||
} |
||||
|
||||
void AudioEffectAnalogDelay::update(void) |
||||
{ |
||||
audio_block_t *inputAudioBlock = receiveReadOnly(); // get the next block of input samples
|
||||
|
||||
// Check is block is disabled
|
||||
if (m_enable == false) { |
||||
// do not transmit or process any audio, return as quickly as possible.
|
||||
if (inputAudioBlock) release(inputAudioBlock); |
||||
|
||||
// release all held memory resources
|
||||
if (m_previousBlock) { |
||||
release(m_previousBlock); m_previousBlock = nullptr; |
||||
} |
||||
if (!m_externalMemory) { |
||||
// when using internal memory we have to release all references in the ring buffer
|
||||
while (m_memory->getRingBuffer()->size() > 0) { |
||||
audio_block_t *releaseBlock = m_memory->getRingBuffer()->front(); |
||||
m_memory->getRingBuffer()->pop_front(); |
||||
if (releaseBlock) release(releaseBlock); |
||||
} |
||||
} |
||||
return; |
||||
} |
||||
|
||||
// Check is block is bypassed, if so either transmit input directly or create silence
|
||||
if (m_bypass == true) { |
||||
// transmit the input directly
|
||||
if (!inputAudioBlock) { |
||||
// create silence
|
||||
inputAudioBlock = allocate(); |
||||
if (!inputAudioBlock) { return; } // failed to allocate
|
||||
else { |
||||
clearAudioBlock(inputAudioBlock); |
||||
} |
||||
} |
||||
transmit(inputAudioBlock, 0); |
||||
release(inputAudioBlock); |
||||
return; |
||||
} |
||||
|
||||
// Otherwise perform normal processing
|
||||
// In order to make use of the SPI DMA, we need to request the read from memory first,
|
||||
// then do other processing while it fills in the back.
|
||||
audio_block_t *blockToOutput = nullptr; // this will hold the output audio
|
||||
blockToOutput = allocate(); |
||||
if (!blockToOutput) return; // skip this update cycle due to failure
|
||||
|
||||
// get the data. If using external memory with DMA, this won't be filled until
|
||||
// later.
|
||||
m_memory->getSamples(blockToOutput, m_delaySamples); |
||||
|
||||
// If using DMA, we need something else to do while that read executes, so
|
||||
// move on to input preprocessing
|
||||
|
||||
// Preprocessing
|
||||
audio_block_t *preProcessed = allocate(); |
||||
// mix the input with the feedback path in the pre-processing stage
|
||||
m_preProcessing(preProcessed, inputAudioBlock, m_previousBlock); |
||||
|
||||
// consider doing the BBD post processing here to use up more time while waiting
|
||||
// for the read data to come back
|
||||
audio_block_t *blockToRelease = m_memory->addBlock(preProcessed); |
||||
|
||||
|
||||
// BACK TO OUTPUT PROCESSING
|
||||
// Check if external DMA, if so, we need to be sure the read is completed
|
||||
if (m_externalMemory && m_memory->getSlot()->isUseDma()) { |
||||
// Using DMA
|
||||
while (m_memory->getSlot()->isReadBusy()) {} |
||||
} |
||||
|
||||
// perform the wet/dry mix mix
|
||||
m_postProcessing(blockToOutput, inputAudioBlock, blockToOutput); |
||||
transmit(blockToOutput); |
||||
|
||||
release(inputAudioBlock); |
||||
release(m_previousBlock); |
||||
m_previousBlock = blockToOutput; |
||||
|
||||
// if (m_externalMemory && m_memory->getSlot()->isUseDma()) {
|
||||
// // Using DMA
|
||||
// if (m_blockToRelease) release(m_blockToRelease);
|
||||
// m_blockToRelease = blockToRelease;
|
||||
// }
|
||||
|
||||
if (m_blockToRelease) release(m_blockToRelease); |
||||
m_blockToRelease = blockToRelease; |
||||
} |
||||
|
||||
void AudioEffectAnalogDelay::delay(float milliseconds) |
||||
{ |
||||
size_t delaySamples = calcAudioSamples(milliseconds); |
||||
|
||||
if (!m_memory) { Serial.println("delay(): m_memory is not valid"); } |
||||
|
||||
if (!m_externalMemory) { |
||||
// internal memory
|
||||
QueuePosition queuePosition = calcQueuePosition(milliseconds); |
||||
Serial.println(String("CONFIG: delay:") + delaySamples + String(" queue position ") + queuePosition.index + String(":") + queuePosition.offset); |
||||
} else { |
||||
// external memory
|
||||
Serial.println(String("CONFIG: delay:") + delaySamples); |
||||
ExtMemSlot *slot = m_memory->getSlot(); |
||||
|
||||
if (!slot) { Serial.println("ERROR: slot ptr is not valid"); } |
||||
if (!slot->isEnabled()) { |
||||
slot->enable(); |
||||
Serial.println("WEIRD: slot was not enabled"); |
||||
} |
||||
} |
||||
|
||||
m_delaySamples = delaySamples; |
||||
} |
||||
|
||||
void AudioEffectAnalogDelay::delay(size_t delaySamples) |
||||
{ |
||||
if (!m_memory) { Serial.println("delay(): m_memory is not valid"); } |
||||
|
||||
if (!m_externalMemory) { |
||||
// internal memory
|
||||
QueuePosition queuePosition = calcQueuePosition(delaySamples); |
||||
Serial.println(String("CONFIG: delay:") + delaySamples + String(" queue position ") + queuePosition.index + String(":") + queuePosition.offset); |
||||
} else { |
||||
// external memory
|
||||
Serial.println(String("CONFIG: delay:") + delaySamples); |
||||
ExtMemSlot *slot = m_memory->getSlot(); |
||||
if (!slot->isEnabled()) { |
||||
slot->enable(); |
||||
} |
||||
} |
||||
m_delaySamples= delaySamples; |
||||
} |
||||
|
||||
void AudioEffectAnalogDelay::m_preProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet) |
||||
{ |
||||
if ( out && dry && wet) { |
||||
alphaBlend(out, dry, wet, m_feedback); |
||||
m_iir->process(out->data, out->data, AUDIO_BLOCK_SAMPLES); |
||||
} else if (dry) { |
||||
memcpy(out->data, dry->data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES); |
||||
} |
||||
} |
||||
|
||||
void AudioEffectAnalogDelay::m_postProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet) |
||||
{ |
||||
if (!out) return; // no valid output buffer
|
||||
|
||||
if ( out && dry && wet) { |
||||
// Simulate the LPF IIR nature of the analog systems
|
||||
//m_iir->process(wet->data, wet->data, AUDIO_BLOCK_SAMPLES);
|
||||
alphaBlend(out, dry, wet, m_mix); |
||||
} else if (dry) { |
||||
memcpy(out->data, dry->data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES); |
||||
} |
||||
// Set the output volume
|
||||
gainAdjust(out, out, m_volume, 1); |
||||
|
||||
} |
||||
|
||||
|
||||
void AudioEffectAnalogDelay::processMidi(int channel, int control, int value) |
||||
{ |
||||
|
||||
float val = (float)value / 127.0f; |
||||
|
||||
if ((m_midiConfig[DELAY][MIDI_CHANNEL] == channel) && |
||||
(m_midiConfig[DELAY][MIDI_CONTROL] == control)) { |
||||
// Delay
|
||||
if (m_externalMemory) { m_maxDelaySamples = m_memory->getSlot()->size() / sizeof(int16_t); } |
||||
size_t delayVal = (size_t)(val * (float)m_maxDelaySamples); |
||||
delay(delayVal); |
||||
Serial.println(String("AudioEffectAnalogDelay::delay (ms): ") + calcAudioTimeMs(delayVal) |
||||
+ String(" (samples): ") + delayVal + String(" out of ") + m_maxDelaySamples); |
||||
return; |
||||
} |
||||
|
||||
if ((m_midiConfig[BYPASS][MIDI_CHANNEL] == channel) && |
||||
(m_midiConfig[BYPASS][MIDI_CONTROL] == control)) { |
||||
// Bypass
|
||||
if (value >= 65) { bypass(false); Serial.println(String("AudioEffectAnalogDelay::not bypassed -> ON") + value); } |
||||
else { bypass(true); Serial.println(String("AudioEffectAnalogDelay::bypassed -> OFF") + value); } |
||||
return; |
||||
} |
||||
|
||||
if ((m_midiConfig[FEEDBACK][MIDI_CHANNEL] == channel) && |
||||
(m_midiConfig[FEEDBACK][MIDI_CONTROL] == control)) { |
||||
// Feedback
|
||||
Serial.println(String("AudioEffectAnalogDelay::feedback: ") + 100*val + String("%")); |
||||
feedback(val); |
||||
return; |
||||
} |
||||
|
||||
if ((m_midiConfig[MIX][MIDI_CHANNEL] == channel) && |
||||
(m_midiConfig[MIX][MIDI_CONTROL] == control)) { |
||||
// Mix
|
||||
Serial.println(String("AudioEffectAnalogDelay::mix: Dry: ") + 100*(1-val) + String("% Wet: ") + 100*val ); |
||||
mix(val); |
||||
return; |
||||
} |
||||
|
||||
if ((m_midiConfig[VOLUME][MIDI_CHANNEL] == channel) && |
||||
(m_midiConfig[VOLUME][MIDI_CONTROL] == control)) { |
||||
// Volume
|
||||
Serial.println(String("AudioEffectAnalogDelay::volume: ") + 100*val + String("%")); |
||||
volume(val); |
||||
return; |
||||
} |
||||
|
||||
} |
||||
|
||||
void AudioEffectAnalogDelay::mapMidiControl(int parameter, int midiCC, int midiChannel) |
||||
{ |
||||
if (parameter >= NUM_CONTROLS) { |
||||
return ; // Invalid midi parameter
|
||||
} |
||||
m_midiConfig[parameter][MIDI_CHANNEL] = midiChannel; |
||||
m_midiConfig[parameter][MIDI_CONTROL] = midiCC; |
||||
} |
||||
|
||||
} |
||||
|
||||
|
||||
@ -0,0 +1,471 @@ |
||||
/*
|
||||
* BASpiMemory.cpp |
||||
* |
||||
* Created on: May 22, 2017 |
||||
* Author: slascos |
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 3 of the License, or |
||||
* (at your option) any later version.* |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "Arduino.h" |
||||
#include "BASpiMemory.h" |
||||
|
||||
namespace BAGuitar { |
||||
|
||||
// MEM0 Settings
|
||||
constexpr int SPI_CS_MEM0 = 15; |
||||
constexpr int SPI_MOSI_MEM0 = 7; |
||||
constexpr int SPI_MISO_MEM0 = 8; |
||||
constexpr int SPI_SCK_MEM0 = 14; |
||||
|
||||
// MEM1 Settings
|
||||
constexpr int SPI_CS_MEM1 = 31; |
||||
constexpr int SPI_MOSI_MEM1 = 21; |
||||
constexpr int SPI_MISO_MEM1 = 5; |
||||
constexpr int SPI_SCK_MEM1 = 20; |
||||
|
||||
// SPI Constants
|
||||
constexpr int SPI_WRITE_MODE_REG = 0x1; |
||||
constexpr int SPI_WRITE_CMD = 0x2; |
||||
constexpr int SPI_READ_CMD = 0x3; |
||||
constexpr int SPI_ADDR_2_MASK = 0xFF0000; |
||||
constexpr int SPI_ADDR_2_SHIFT = 16; |
||||
constexpr int SPI_ADDR_1_MASK = 0x00FF00; |
||||
constexpr int SPI_ADDR_1_SHIFT = 8; |
||||
constexpr int SPI_ADDR_0_MASK = 0x0000FF; |
||||
|
||||
constexpr int CMD_ADDRESS_SIZE = 4; |
||||
constexpr int MAX_DMA_XFER_SIZE = 0x4000; |
||||
|
||||
BASpiMemory::BASpiMemory(SpiDeviceId memDeviceId) |
||||
{ |
||||
m_memDeviceId = memDeviceId; |
||||
m_settings = {20000000, MSBFIRST, SPI_MODE0}; |
||||
} |
||||
|
||||
BASpiMemory::BASpiMemory(SpiDeviceId memDeviceId, uint32_t speedHz) |
||||
{ |
||||
m_memDeviceId = memDeviceId; |
||||
m_settings = {speedHz, MSBFIRST, SPI_MODE0}; |
||||
} |
||||
|
||||
// Intitialize the correct Arduino SPI interface
|
||||
void BASpiMemory::begin() |
||||
{ |
||||
switch (m_memDeviceId) { |
||||
case SpiDeviceId::SPI_DEVICE0 : |
||||
m_csPin = SPI_CS_MEM0; |
||||
m_spi = &SPI; |
||||
m_spi->setMOSI(SPI_MOSI_MEM0); |
||||
m_spi->setMISO(SPI_MISO_MEM0); |
||||
m_spi->setSCK(SPI_SCK_MEM0); |
||||
m_spi->begin(); |
||||
break; |
||||
|
||||
#if defined(__MK64FX512__) || defined(__MK66FX1M0__) |
||||
case SpiDeviceId::SPI_DEVICE1 : |
||||
m_csPin = SPI_CS_MEM1; |
||||
m_spi = &SPI1; |
||||
m_spi->setMOSI(SPI_MOSI_MEM1); |
||||
m_spi->setMISO(SPI_MISO_MEM1); |
||||
m_spi->setSCK(SPI_SCK_MEM1); |
||||
m_spi->begin(); |
||||
break; |
||||
#endif |
||||
|
||||
default : |
||||
// unreachable since memDeviceId is an enumerated class
|
||||
return; |
||||
} |
||||
|
||||
pinMode(m_csPin, OUTPUT); |
||||
digitalWrite(m_csPin, HIGH); |
||||
m_started = true; |
||||
|
||||
} |
||||
|
||||
BASpiMemory::~BASpiMemory() { |
||||
} |
||||
|
||||
// Single address write
|
||||
void BASpiMemory::write(size_t address, uint8_t data) |
||||
{ |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer(SPI_WRITE_CMD); |
||||
m_spi->transfer((address & SPI_ADDR_2_MASK) >> SPI_ADDR_2_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_1_MASK) >> SPI_ADDR_1_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_0_MASK)); |
||||
m_spi->transfer(data); |
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
// Single address write
|
||||
void BASpiMemory::write(size_t address, uint8_t *src, size_t numBytes) |
||||
{ |
||||
uint8_t *dataPtr = src; |
||||
|
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer(SPI_WRITE_CMD); |
||||
m_spi->transfer((address & SPI_ADDR_2_MASK) >> SPI_ADDR_2_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_1_MASK) >> SPI_ADDR_1_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_0_MASK)); |
||||
|
||||
for (size_t i=0; i < numBytes; i++) { |
||||
m_spi->transfer(*dataPtr++); |
||||
} |
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
|
||||
void BASpiMemory::zero(size_t address, size_t numBytes) |
||||
{ |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer(SPI_WRITE_CMD); |
||||
m_spi->transfer((address & SPI_ADDR_2_MASK) >> SPI_ADDR_2_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_1_MASK) >> SPI_ADDR_1_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_0_MASK)); |
||||
|
||||
for (size_t i=0; i < numBytes; i++) { |
||||
m_spi->transfer(0); |
||||
} |
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
void BASpiMemory::write16(size_t address, uint16_t data) |
||||
{ |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer16((SPI_WRITE_CMD << 8) | (address >> 16) ); |
||||
m_spi->transfer16(address & 0xFFFF); |
||||
m_spi->transfer16(data); |
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
void BASpiMemory::write16(size_t address, uint16_t *src, size_t numWords) |
||||
{ |
||||
uint16_t *dataPtr = src; |
||||
|
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer16((SPI_WRITE_CMD << 8) | (address >> 16) ); |
||||
m_spi->transfer16(address & 0xFFFF); |
||||
|
||||
for (size_t i=0; i<numWords; i++) { |
||||
m_spi->transfer16(*dataPtr++); |
||||
} |
||||
|
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
void BASpiMemory::zero16(size_t address, size_t numWords) |
||||
{ |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer16((SPI_WRITE_CMD << 8) | (address >> 16) ); |
||||
m_spi->transfer16(address & 0xFFFF); |
||||
|
||||
for (size_t i=0; i<numWords; i++) { |
||||
m_spi->transfer16(0); |
||||
} |
||||
|
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
Serial.println("DONE!"); |
||||
} |
||||
|
||||
// single address read
|
||||
uint8_t BASpiMemory::read(size_t address) |
||||
{ |
||||
int data; |
||||
|
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer(SPI_READ_CMD); |
||||
m_spi->transfer((address & SPI_ADDR_2_MASK) >> SPI_ADDR_2_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_1_MASK) >> SPI_ADDR_1_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_0_MASK)); |
||||
data = m_spi->transfer(0); |
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
return data; |
||||
} |
||||
|
||||
|
||||
void BASpiMemory::read(size_t address, uint8_t *dest, size_t numBytes) |
||||
{ |
||||
uint8_t *dataPtr = dest; |
||||
|
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer(SPI_READ_CMD); |
||||
m_spi->transfer((address & SPI_ADDR_2_MASK) >> SPI_ADDR_2_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_1_MASK) >> SPI_ADDR_1_SHIFT); |
||||
m_spi->transfer((address & SPI_ADDR_0_MASK)); |
||||
|
||||
for (size_t i=0; i<numBytes; i++) { |
||||
*dataPtr++ = m_spi->transfer(0); |
||||
} |
||||
|
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
uint16_t BASpiMemory::read16(size_t address) |
||||
{ |
||||
|
||||
uint16_t data; |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer16((SPI_READ_CMD << 8) | (address >> 16) ); |
||||
m_spi->transfer16(address & 0xFFFF); |
||||
data = m_spi->transfer16(0); |
||||
m_spi->endTransaction(); |
||||
|
||||
digitalWrite(m_csPin, HIGH); |
||||
return data; |
||||
} |
||||
|
||||
void BASpiMemory::read16(size_t address, uint16_t *dest, size_t numWords) |
||||
{ |
||||
|
||||
uint16_t *dataPtr = dest; |
||||
m_spi->beginTransaction(m_settings); |
||||
digitalWrite(m_csPin, LOW); |
||||
m_spi->transfer16((SPI_READ_CMD << 8) | (address >> 16) ); |
||||
m_spi->transfer16(address & 0xFFFF); |
||||
|
||||
for (size_t i=0; i<numWords; i++) { |
||||
*dataPtr++ = m_spi->transfer16(0); |
||||
} |
||||
|
||||
m_spi->endTransaction(); |
||||
digitalWrite(m_csPin, HIGH); |
||||
} |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// BASpiMemoryDMA
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
BASpiMemoryDMA::BASpiMemoryDMA(SpiDeviceId memDeviceId) |
||||
: BASpiMemory(memDeviceId) |
||||
{ |
||||
int cs; |
||||
switch (memDeviceId) { |
||||
case SpiDeviceId::SPI_DEVICE0 : |
||||
cs = SPI_CS_MEM0; |
||||
m_cs = new ActiveLowChipSelect(cs, m_settings); |
||||
break; |
||||
#if defined(__MK64FX512__) || defined(__MK66FX1M0__) |
||||
case SpiDeviceId::SPI_DEVICE1 : |
||||
cs = SPI_CS_MEM1; |
||||
m_cs = new ActiveLowChipSelect1(cs, m_settings); |
||||
break; |
||||
#endif |
||||
default : |
||||
cs = SPI_CS_MEM0; |
||||
} |
||||
|
||||
// add 4 bytes to buffer for SPI CMD and 3 bytes of address
|
||||
m_txCommandBuffer = new uint8_t[CMD_ADDRESS_SIZE]; |
||||
m_rxCommandBuffer = new uint8_t[CMD_ADDRESS_SIZE]; |
||||
m_txTransfer = new DmaSpi::Transfer[2]; |
||||
m_rxTransfer = new DmaSpi::Transfer[2]; |
||||
} |
||||
|
||||
BASpiMemoryDMA::BASpiMemoryDMA(SpiDeviceId memDeviceId, uint32_t speedHz) |
||||
: BASpiMemory(memDeviceId, speedHz) |
||||
{ |
||||
int cs; |
||||
switch (memDeviceId) { |
||||
case SpiDeviceId::SPI_DEVICE0 : |
||||
cs = SPI_CS_MEM0; |
||||
m_cs = new ActiveLowChipSelect(cs, m_settings); |
||||
break; |
||||
#if defined(__MK64FX512__) || defined(__MK66FX1M0__) |
||||
case SpiDeviceId::SPI_DEVICE1 : |
||||
cs = SPI_CS_MEM1; |
||||
m_cs = new ActiveLowChipSelect1(cs, m_settings); |
||||
break; |
||||
#endif |
||||
default : |
||||
cs = SPI_CS_MEM0; |
||||
} |
||||
|
||||
m_txCommandBuffer = new uint8_t[CMD_ADDRESS_SIZE]; |
||||
m_rxCommandBuffer = new uint8_t[CMD_ADDRESS_SIZE]; |
||||
m_txTransfer = new DmaSpi::Transfer[2]; |
||||
m_rxTransfer = new DmaSpi::Transfer[2]; |
||||
} |
||||
|
||||
BASpiMemoryDMA::~BASpiMemoryDMA() |
||||
{ |
||||
delete m_cs; |
||||
if (m_txTransfer) delete [] m_txTransfer; |
||||
if (m_rxTransfer) delete [] m_rxTransfer; |
||||
if (m_txCommandBuffer) delete [] m_txCommandBuffer; |
||||
if (m_rxCommandBuffer) delete [] m_txCommandBuffer; |
||||
} |
||||
|
||||
void BASpiMemoryDMA::m_setSpiCmdAddr(int command, size_t address, uint8_t *dest) |
||||
{ |
||||
dest[0] = command; |
||||
dest[1] = ((address & SPI_ADDR_2_MASK) >> SPI_ADDR_2_SHIFT); |
||||
dest[2] = ((address & SPI_ADDR_1_MASK) >> SPI_ADDR_1_SHIFT); |
||||
dest[3] = ((address & SPI_ADDR_0_MASK)); |
||||
} |
||||
|
||||
void BASpiMemoryDMA::begin(void) |
||||
{ |
||||
switch (m_memDeviceId) { |
||||
case SpiDeviceId::SPI_DEVICE0 : |
||||
m_csPin = SPI_CS_MEM0; |
||||
m_spi = &SPI; |
||||
m_spi->setMOSI(SPI_MOSI_MEM0); |
||||
m_spi->setMISO(SPI_MISO_MEM0); |
||||
m_spi->setSCK(SPI_SCK_MEM0); |
||||
m_spi->begin(); |
||||
//m_spiDma = &DMASPI0;
|
||||
m_spiDma = new DmaSpiGeneric(); |
||||
break; |
||||
|
||||
#if defined(__MK64FX512__) || defined(__MK66FX1M0__) |
||||
case SpiDeviceId::SPI_DEVICE1 : |
||||
m_csPin = SPI_CS_MEM1; |
||||
m_spi = &SPI1; |
||||
m_spi->setMOSI(SPI_MOSI_MEM1); |
||||
m_spi->setMISO(SPI_MISO_MEM1); |
||||
m_spi->setSCK(SPI_SCK_MEM1); |
||||
m_spi->begin(); |
||||
m_spiDma = new DmaSpiGeneric(1); |
||||
//m_spiDma = &DMASPI1;
|
||||
break; |
||||
#endif |
||||
|
||||
default : |
||||
// unreachable since memDeviceId is an enumerated class
|
||||
return; |
||||
} |
||||
|
||||
m_spiDma->begin(); |
||||
m_spiDma->start(); |
||||
|
||||
m_started = true; |
||||
} |
||||
|
||||
|
||||
|
||||
// SPI must build up a payload that starts the teh CMD/Address first. It will cycle
|
||||
// through the payloads in a circular buffer and use the transfer objects to check if they
|
||||
// are done before continuing.
|
||||
void BASpiMemoryDMA::write(size_t address, uint8_t *src, size_t numBytes) |
||||
{ |
||||
size_t bytesRemaining = numBytes; |
||||
uint8_t *srcPtr = src; |
||||
size_t nextAddress = address; |
||||
while (bytesRemaining > 0) { |
||||
m_txXferCount = min(bytesRemaining, MAX_DMA_XFER_SIZE); |
||||
while ( m_txTransfer[1].busy()) {} // wait until not busy
|
||||
m_setSpiCmdAddr(SPI_WRITE_CMD, nextAddress, m_txCommandBuffer); |
||||
m_txTransfer[1] = DmaSpi::Transfer(m_txCommandBuffer, CMD_ADDRESS_SIZE, nullptr, 0, m_cs, TransferType::NO_END_CS); |
||||
m_spiDma->registerTransfer(m_txTransfer[1]); |
||||
|
||||
while ( m_txTransfer[0].busy()) {} // wait until not busy
|
||||
m_txTransfer[0] = DmaSpi::Transfer(srcPtr, m_txXferCount, nullptr, 0, m_cs, TransferType::NO_START_CS); |
||||
m_spiDma->registerTransfer(m_txTransfer[0]); |
||||
bytesRemaining -= m_txXferCount; |
||||
srcPtr += m_txXferCount; |
||||
nextAddress += m_txXferCount; |
||||
} |
||||
} |
||||
|
||||
|
||||
void BASpiMemoryDMA::zero(size_t address, size_t numBytes) |
||||
{ |
||||
size_t bytesRemaining = numBytes; |
||||
size_t nextAddress = address; |
||||
while (bytesRemaining > 0) { |
||||
m_txXferCount = min(bytesRemaining, MAX_DMA_XFER_SIZE); |
||||
while ( m_txTransfer[1].busy()) {} // wait until not busy
|
||||
m_setSpiCmdAddr(SPI_WRITE_CMD, nextAddress, m_txCommandBuffer); |
||||
m_txTransfer[1] = DmaSpi::Transfer(m_txCommandBuffer, CMD_ADDRESS_SIZE, nullptr, 0, m_cs, TransferType::NO_END_CS); |
||||
m_spiDma->registerTransfer(m_txTransfer[1]); |
||||
|
||||
while ( m_txTransfer[0].busy()) {} // wait until not busy
|
||||
m_txTransfer[0] = DmaSpi::Transfer(nullptr, m_txXferCount, nullptr, 0, m_cs, TransferType::NO_START_CS); |
||||
m_spiDma->registerTransfer(m_txTransfer[0]); |
||||
bytesRemaining -= m_txXferCount; |
||||
nextAddress += m_txXferCount; |
||||
} |
||||
} |
||||
|
||||
|
||||
void BASpiMemoryDMA::write16(size_t address, uint16_t *src, size_t numWords) |
||||
{ |
||||
write(address, reinterpret_cast<uint8_t*>(src), sizeof(uint16_t)*numWords); |
||||
} |
||||
|
||||
void BASpiMemoryDMA::zero16(size_t address, size_t numWords) |
||||
{ |
||||
zero(address, sizeof(uint16_t)*numWords); |
||||
} |
||||
|
||||
|
||||
void BASpiMemoryDMA::read(size_t address, uint8_t *dest, size_t numBytes) |
||||
{ |
||||
size_t bytesRemaining = numBytes; |
||||
uint8_t *destPtr = dest; |
||||
size_t nextAddress = address; |
||||
while (bytesRemaining > 0) { |
||||
m_setSpiCmdAddr(SPI_READ_CMD, nextAddress, m_rxCommandBuffer); |
||||
|
||||
while ( m_rxTransfer[1].busy()) {} |
||||
m_rxTransfer[1] = DmaSpi::Transfer(m_rxCommandBuffer, CMD_ADDRESS_SIZE, nullptr, 0, m_cs, TransferType::NO_END_CS); |
||||
m_spiDma->registerTransfer(m_rxTransfer[1]); |
||||
|
||||
m_rxXferCount = min(bytesRemaining, MAX_DMA_XFER_SIZE); |
||||
while ( m_rxTransfer[0].busy()) {} |
||||
m_rxTransfer[0] = DmaSpi::Transfer(nullptr, m_rxXferCount, destPtr, 0, m_cs, TransferType::NO_START_CS); |
||||
m_spiDma->registerTransfer(m_rxTransfer[0]); |
||||
|
||||
bytesRemaining -= m_rxXferCount; |
||||
destPtr += m_rxXferCount; |
||||
nextAddress += m_rxXferCount; |
||||
} |
||||
} |
||||
|
||||
|
||||
void BASpiMemoryDMA::read16(size_t address, uint16_t *dest, size_t numWords) |
||||
{ |
||||
read(address, reinterpret_cast<uint8_t*>(dest), sizeof(uint16_t)*numWords); |
||||
} |
||||
|
||||
|
||||
bool BASpiMemoryDMA::isWriteBusy(void) const |
||||
{ |
||||
return (m_txTransfer[0].busy() or m_txTransfer[1].busy()); |
||||
} |
||||
|
||||
bool BASpiMemoryDMA::isReadBusy(void) const |
||||
{ |
||||
return (m_rxTransfer[0].busy() or m_rxTransfer[1].busy()); |
||||
} |
||||
|
||||
} /* namespace BAGuitar */ |
||||
Loading…
Reference in new issue