parent
e894318451
commit
b649550cb3
@ -0,0 +1,114 @@ |
||||
//#include <MIDI.h>
|
||||
#include "BAGuitar.h" |
||||
|
||||
using namespace BAGuitar; |
||||
AudioInputI2S i2sIn; |
||||
AudioOutputI2S i2sOut; |
||||
BAAudioControlWM8731 codec; |
||||
|
||||
#define USE_EXT |
||||
|
||||
#ifdef USE_EXT |
||||
ExternalSramManager externalSram(1); // Manage both SRAMs
|
||||
ExtMemSlot delaySlot; // For the external memory
|
||||
AudioEffectAnalogDelay myDelay(&delaySlot); |
||||
#else |
||||
AudioEffectAnalogDelay myDelay(200.0f); |
||||
#endif |
||||
|
||||
AudioMixer4 mixer; // Used to mix the original dry with the wet (effects) path.
|
||||
|
||||
AudioConnection patch0(i2sIn,0, myDelay,0); |
||||
AudioConnection mixerDry(i2sIn,0, mixer,0); |
||||
AudioConnection mixerWet(myDelay,0, mixer,1); |
||||
AudioConnection leftOut(mixer,0, i2sOut, 0); |
||||
AudioConnection rightOut(mixer,0, i2sOut, 1); |
||||
|
||||
unsigned loopCount = 0; |
||||
|
||||
void setup() { |
||||
delay(100); |
||||
Serial.begin(57600); |
||||
codec.disable(); |
||||
delay(100); |
||||
AudioMemory(128); |
||||
delay(5); |
||||
|
||||
// Setup MIDI
|
||||
//usbMIDI.setHandleControlChange(OnControlChange);
|
||||
Serial.println("Enabling codec...\n"); |
||||
codec.enable(); |
||||
delay(100); |
||||
|
||||
|
||||
#ifdef USE_EXT |
||||
Serial.println("Using EXTERNAL memory"); |
||||
//externalSram.requestMemory(&delaySlot, 1400.0f);
|
||||
//externalSram.requestMemory(&delaySlot, 1400.0f, MemSelect::MEM0, true);
|
||||
externalSram.requestMemory(&delaySlot, 1400.0f, MemSelect::MEM1, true); |
||||
#else |
||||
Serial.println("Using INTERNAL memory"); |
||||
#endif |
||||
|
||||
myDelay.delay(200.0f); |
||||
//myDelay.delay( 128.0f/44100.0f*1000.0f);
|
||||
//myDelay.delay(0, 0.0f);
|
||||
//myDelay.delay((size_t)8192);
|
||||
|
||||
|
||||
|
||||
myDelay.mapMidiBypass(16); |
||||
myDelay.mapMidiDelay(20); |
||||
myDelay.mapMidiFeedback(21); |
||||
myDelay.mapMidiMix(22); |
||||
|
||||
myDelay.enable(); |
||||
myDelay.bypass(false); |
||||
myDelay.mix(1.0f); |
||||
myDelay.feedback(0.0f); |
||||
|
||||
mixer.gain(0, 0.0f); // unity gain on the dry
|
||||
mixer.gain(1, 1.0f); // unity gain on the wet
|
||||
|
||||
} |
||||
|
||||
void OnControlChange(byte channel, byte control, byte value) { |
||||
myDelay.processMidi(channel, control, value); |
||||
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(); |
||||
|
||||
|
||||
} |
||||
|
||||
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.
|
||||
//Serial.println(".");
|
||||
|
||||
if (loopCount % 262144 == 0) { |
||||
Serial.print("Processor Usage: "); Serial.print(AudioProcessorUsage()); |
||||
Serial.print(" "); Serial.print(AudioProcessorUsageMax()); |
||||
Serial.print(" Delay: "); Serial.print(myDelay.processorUsage()); |
||||
Serial.print(" "); Serial.println(myDelay.processorUsageMax()); |
||||
} |
||||
loopCount++; |
||||
|
||||
if (usbMIDI.read()) { |
||||
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
|
||||
//cable = usbMIDI.getCable(); // which virtual cable with MIDIx8, 0-7
|
||||
if (type == 3) { |
||||
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) {} |
||||
|
||||
} |
||||
|
@ -1,356 +0,0 @@ |
||||
/*
|
||||
* LibBasicFunctions.cpp |
||||
* |
||||
* Created on: Dec 23, 2017 |
||||
* Author: slascos |
||||
*/ |
||||
|
||||
#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); |
||||
} |
||||
|
||||
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) |
||||
{ |
||||
//Non-optimized version for illustrative purposes
|
||||
// for (int i=0; i< AUDIO_BLOCK_SAMPLES; i++) {
|
||||
// out->data[i] = (dry->data[i] * (1 - mix)) + (wet->data[i] * mix);
|
||||
// }
|
||||
// return;
|
||||
|
||||
// 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 clearAudioBlock(audio_block_t *block) |
||||
{ |
||||
memset(block->data, 0, sizeof(int16_t)*AUDIO_BLOCK_SAMPLES); |
||||
} |
||||
|
||||
|
||||
////////////////////////////////////////////////////
|
||||
// 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) { |
||||
|
||||
// Audio is stored in reverse in block so we need to write it backwards to external memory
|
||||
// to maintain temporal coherency.
|
||||
// int16_t *srcPtr = block->data + AUDIO_BLOCK_SAMPLES - 1;
|
||||
// for (int i=0; i<AUDIO_BLOCK_SAMPLES; i++) {
|
||||
// m_slot->writeAdvance16(*srcPtr);
|
||||
// srcPtr--;
|
||||
// }
|
||||
|
||||
// this causes pops
|
||||
m_slot->writeAdvance16(block->data, AUDIO_BLOCK_SAMPLES); |
||||
|
||||
// Code below worked
|
||||
// int16_t *srcPtr = block->data;
|
||||
// for (int i=0; i<AUDIO_BLOCK_SAMPLES; i++) {
|
||||
// m_slot->writeAdvance16(*srcPtr);
|
||||
// srcPtr++;
|
||||
// }
|
||||
|
||||
} |
||||
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); |
||||
} |
||||
|
||||
//m_slot->printStatus();
|
||||
|
||||
// write the data to the destination block in reverse
|
||||
// int16_t *destPtr = dest->data + AUDIO_BLOCK_SAMPLES-1;
|
||||
// for (int i=0; i<AUDIO_BLOCK_SAMPLES; i++) {
|
||||
// *destPtr = m_slot->readAdvance16();
|
||||
// destPtr--;
|
||||
// }
|
||||
|
||||
// This causes pops
|
||||
m_slot->readAdvance16(dest->data, AUDIO_BLOCK_SAMPLES); |
||||
|
||||
// Code below worked
|
||||
// int16_t *destPtr = dest->data;
|
||||
// for (int i=0; i<AUDIO_BLOCK_SAMPLES; i++) {
|
||||
// *destPtr = m_slot->readAdvance16();
|
||||
// destPtr++;
|
||||
// }
|
||||
|
||||
return true; |
||||
} else { |
||||
// numSampmles is > than total slot size
|
||||
Serial.println("getSamples(): ERROR numSamples > total slot size"); |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
} |
||||
|
||||
////////////////////////////////////////////////////
|
||||
// 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,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,73 @@ |
||||
/*
|
||||
* 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); |
||||
} |
||||
|
||||
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) |
||||
{ |
||||
//Non-optimized version for illustrative purposes
|
||||
// for (int i=0; i< AUDIO_BLOCK_SAMPLES; i++) {
|
||||
// out->data[i] = (dry->data[i] * (1 - mix)) + (wet->data[i] * mix);
|
||||
// }
|
||||
// return;
|
||||
|
||||
// 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 clearAudioBlock(audio_block_t *block) |
||||
{ |
||||
memset(block->data, 0, sizeof(int16_t)*AUDIO_BLOCK_SAMPLES); |
||||
} |
||||
|
||||
} |
||||
|
@ -0,0 +1,113 @@ |
||||
/*
|
||||
* 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() |
||||
{ |
||||
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,467 @@ |
||||
/*
|
||||
* 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; |
||||
case SpiDeviceId::SPI_DEVICE1 : |
||||
cs = SPI_CS_MEM1; |
||||
m_cs = new ActiveLowChipSelect1(cs, m_settings); |
||||
break; |
||||
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; |
||||
case SpiDeviceId::SPI_DEVICE1 : |
||||
cs = SPI_CS_MEM1; |
||||
m_cs = new ActiveLowChipSelect1(cs, m_settings); |
||||
break; |
||||
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