SamdAudio.cpp

/*
 Copyright (c) 2016 Théo Meyer aka AloyseTech. All right reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.

 This library 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/

#include "SamdAudio.h"

//*********************************************************************
//Global variables

File __audioFile[MAX_N_CHANNELS];
volatile bool __audioPlaying[MAX_N_CHANNELS]={false};
volatile bool __audioFileReady[MAX_N_CHANNELS] = {false};
volatile uint32_t __SampleIndex[MAX_N_CHANNELS];
uint8_t __WavSamples[MAX_N_CHANNELS][2][AUDIO_BUFFER_SIZE];
uint8_t rampDivisor[MAX_N_CHANNELS]={1};
uint8_t whichBuffer[MAX_N_CHANNELS]={0};
volatile bool fillNextBuffer[MAX_N_CHANNELS]={true};
volatile uint16_t __audioData;

void (*__onSoundCompletion[MAX_N_CHANNELS])(void); //function pointer to users completion callback function

SdFat* SamdAudioSdFat;

//int __Volume;
bool __criticalSection = false;

int __numOfChannelsUsed = 4;

// unused declarations, commented out
void TC5_Handler (void) __attribute__ ((weak, alias("AudioPlay_Handler")));
void TC3_Handler (void) __attribute__ ((weak, alias("AudioRead_Handler")));

//*********************************************************************

int SamdAudio::begin(uint32_t sampleRate, uint8_t numOfChannels, SdFat* sdfatToUse)
{
 // Initialize pointer back to already initialized sdfat object
	SamdAudioSdFat = sdfatToUse;

	if(numOfChannels == 1 || numOfChannels == 2 || numOfChannels == 4)
	{
		// initialize the global variable with the channels to use
		__numOfChannelsUsed = numOfChannels;
	}
	else
	{
		// bad input passed, assume all channels to be safe
		__numOfChannelsUsed = MAX_N_CHANNELS;
	}
	
	// initialize arrays
 for(uint8_t index=0; index<MAX_N_CHANNELS; index++)
 {
 __audioFileReady[index]=false;
 __SampleIndex[index]=0;

 __onSoundCompletion[index] = NULL;
 }
 
 /*Modules configuration */
 dacConfigure();
 configurePlayerTimer(sampleRate);
 configureReaderTimer();

 return 0;
}

void SamdAudio::end() {
 disablePlayerTimer();
 resetPlayerTimer();
 disableReaderTimer();
 analogWrite(A0, 0);
	
	// disable the DAC so it doesn't leak noise
 DAC->CTRLA.bit.ENABLE = 0x00;
}

//*********************************************************************

void SamdAudio::play(char *fname, uint8_t channel) {
 
	// enable the DAC again here since originally it is
 // just done in dacConfigure
 DAC->CTRLA.bit.ENABLE = 0x01;
	
	//if(channel<0 || channel>=__numOfChannelsUsed)//unsigned, cant be negative
 if(channel>=__numOfChannelsUsed)
 return;
 
 disableReaderTimer();
 
 if(__audioFileReady[channel])
 __audioFile[channel].close();

 __audioFile[channel] = SamdAudioSdFat->open(fname);

 if(!__audioFile[channel])
 {
 //end();
 //SerialUSB.println("Error opening file");
 return;
 }
 
 whichBuffer[channel]=0;
 fillNextBuffer[channel]=1;
 
 __audioFile[channel].read(__WavSamples[channel][whichBuffer[channel]], AUDIO_BUFFER_SIZE);
 
 __SampleIndex[channel]=0;
 __audioFileReady[channel] = true;
 
 rampDivisor[channel]=RAMPIN;
 
 /*once the buffer is filled for the first time the counter can be started*/
 if(alonePlaying(channel))
 {
 enablePlayerTimer();
 }
 __audioPlaying[channel]=true;
 
 enableReaderTimer();
}

void SamdAudio::play(char *fname, uint8_t channel, void (*functionToCallWhenComplete)(void))
{
	// assign the callback function pointer
	__onSoundCompletion[channel] = functionToCallWhenComplete;

	// pass the sound to be played
	// will call callback when done
	play(fname, channel);
}


void SamdAudio::stopChannel(uint8_t c)
{
	//if(c>=0 && c<__numOfChannelsUsed) //unsigned, cant be less than zero
 if(c<__numOfChannelsUsed)
 {
 __audioFileReady[c]=false;
 __audioFile[c].close();
 __SampleIndex[c]=0;
 __audioPlaying[c]=false;
 }
}

//*********************************************************************

bool SamdAudio::alonePlaying(uint8_t channel)
{
 for(uint8_t index=0; index<__numOfChannelsUsed; index++)
 {
 if(index!=channel && __audioPlaying[index])
 return false;
 }
 return true;
}

bool __channelsPlaying()
{
 for(uint8_t index=0; index<__numOfChannelsUsed; index++)
 {
 if(__audioPlaying[index])
 return true;
 }
 return false;
}

//*********************************************************************

void SamdAudio::criticalON() {
 __criticalSection = true;
}

void SamdAudio::criticalOFF() {
 __criticalSection = false;
}

//*********************************************************************

/**
 * Configures the DAC in event triggered mode.
 *
 * Configures the DAC to use the module's default configuration, with output
 * channel mode configured for event triggered conversions.
 */
void SamdAudio::dacConfigure(void){
 analogWriteResolution(10);
 // analogWrite(A0, 0);
 
 DAC->CTRLA.bit.ENABLE = 0x01;
 DAC->DATA.reg = 0;
 while (DAC->STATUS.bit.SYNCBUSY == 1);
}

/**
 * Configures the TC to generate output events at the sample frequency.
 *
 * Configures the TC in Frequency Generation mode, with an event output once
 * each time the audio sample frequency period expires.
 */
void SamdAudio::configurePlayerTimer(uint32_t sampleRate)
{
 // Enable GCLK for TCC2 and TC5 (timer counter input clock)
 GCLK->CLKCTRL.reg = (uint16_t) (GCLK_CLKCTRL_CLKEN | GCLK_CLKCTRL_GEN_GCLK0 | GCLK_CLKCTRL_ID(GCM_TC4_TC5)) ;
 while (GCLK->STATUS.bit.SYNCBUSY);
 
 resetPlayerTimer();
 
 // Set Timer counter Mode to 16 bits
 TC5->COUNT16.CTRLA.reg |= TC_CTRLA_MODE_COUNT16;
 
 // Set TC5 mode as match frequency
 TC5->COUNT16.CTRLA.reg |= TC_CTRLA_WAVEGEN_MFRQ;
 
 TC5->COUNT16.CTRLA.reg |= TC_CTRLA_PRESCALER_DIV1 | TC_CTRLA_ENABLE;
 
 TC5->COUNT16.CC[0].reg = (uint16_t) (SystemCoreClock / sampleRate - 1);
 while (syncPlayerTimer());
 
 // Configure interrupt request
 NVIC_DisableIRQ(TC5_IRQn);
 NVIC_ClearPendingIRQ(TC5_IRQn);
 NVIC_SetPriority(TC5_IRQn, 0);
 NVIC_EnableIRQ(TC5_IRQn);
 
 // Enable the TC5 interrupt request
 TC5->COUNT16.INTENSET.bit.MC0 = 1;
 while (syncPlayerTimer());
}


bool SamdAudio::syncPlayerTimer()
{
 return TC5->COUNT16.STATUS.reg & TC_STATUS_SYNCBUSY;
}

void SamdAudio::enablePlayerTimer()
{
 // Enable TC
 TC5->COUNT16.CTRLA.reg |= TC_CTRLA_ENABLE;
 while (syncPlayerTimer());
}

void SamdAudio::resetPlayerTimer()
{
 // Reset TCx
 TC5->COUNT16.CTRLA.reg = TC_CTRLA_SWRST;
 while (syncPlayerTimer());
 while (TC5->COUNT16.CTRLA.bit.SWRST);
}

void SamdAudio::disablePlayerTimer()
{
 // Disable TC5
 TC5->COUNT16.CTRLA.reg &= ~TC_CTRLA_ENABLE;
 while (syncPlayerTimer());
}


void SamdAudio::configureReaderTimer()
{
 // The GCLK clock provider to use
 // GCLK0, GCLK1 & GCLK3 are used already, see startup.c
 const uint8_t GCLK_SRC = 5;
 
 // Configure the XOSC32K to run in standby
 //SYSCTRL->XOSC32K.bit.RUNSTDBY = 1;
 
 // Setup clock provider GCLK_SRC with a /2 source divider
 // GCLK_GENDIV_ID(X) specifies which GCLK we are configuring
 // GCLK_GENDIV_DIV(Y) specifies the clock prescalar / divider
 // If GENCTRL.DIVSEL is set (see further below) the divider
 // is 2^(Y+1). If GENCTRL.DIVSEL is 0, the divider is simply Y
 // This register has to be written in a single operation
 GCLK->GENDIV.reg = GCLK_GENDIV_ID(GCLK_SRC) | GCLK_GENDIV_DIV(2);
 while ( GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
 
 // Configure the GCLK module
 // GCLK_GENCTRL_GENEN, enable the specific GCLK module
 // GCLK_GENCTRL_SRC_XOSC32K, set the source to the XOSC32K
 // GCLK_GENCTRL_ID(X), specifies which GCLK we are configuring
 // GCLK_GENCTRL_DIVSEL, specify which prescalar mode we are using
 // GCLK_RUNSTDBY, keep the GCLK running when in standby mode
 // Output from this module is 16khz (32khz / 2)
 // This register has to be written in a single operation.
 GCLK->GENCTRL.reg = GCLK_GENCTRL_GENEN |
 GCLK_GENCTRL_SRC_XOSC32K |
 GCLK_GENCTRL_ID(GCLK_SRC);
 while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
 
 // Turn the power to the TC3 module on
 PM->APBCMASK.reg |= PM_APBCMASK_TC3;
 
 // Set TC3 (shared with TCC2) GCLK source to GCLK_SRC
 // GCLK_CLKCTRL_CLKEN, enable the generic clock
 // GCLK_CLKCTRL_GEN(X), specifies the GCLK generator source
 // GCLK_CLKCTRL_ID(X), specifies which generic clock we are configuring
 GCLK->CLKCTRL.reg = GCLK_CLKCTRL_CLKEN |
 GCLK_CLKCTRL_GEN(GCLK_SRC) |
 GCLK_CLKCTRL_ID(GCM_TCC2_TC3);
 while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
 
 // Disable TC3. This is required (if enabled already)
 // before setting certain registers
 TC3->COUNT8.CTRLA.reg &= ~TC_CTRLA_ENABLE;
 while (TC3->COUNT8.STATUS.reg & TC_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
 
 // Set the mode to 8 bit and set it to run in standby
 // TC_CTRLA_MODE_COUNT8, specify 8bit mode
 // TC_CTRLA_RUNSTDBY, keep the module running when in standby
 // TC_CTRLA_PRESCALER_DIVxx, set the prescalar to 64
 // Prescalar options include: DIV1, DIV2, DIV4, DIV8,
 // DIV16, DIV64, DIV256, DIV1024
 TC3->COUNT8.CTRLA.reg = TC_CTRLA_MODE_COUNT8 |
 TC_CTRLA_RUNSTDBY |
 TC_CTRLA_PRESCALER_DIV1;
 while (TC3->COUNT8.STATUS.reg & TC_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
 
 // Enable the TC3 interrupt vector
 // Set the priority to second (less important than feeding the DAC
 NVIC_DisableIRQ(TC3_IRQn);
 NVIC_ClearPendingIRQ(TC3_IRQn);
 NVIC_SetPriority(TC3_IRQn, 0xFFFF);
 NVIC_EnableIRQ(TC3_IRQn);
 
 
 // Enable interrupt on overflow
 // TC_INTENSET_OVF, enable an interrupt on overflow
 TC3->COUNT8.INTENSET.reg = TC_INTENSET_OVF;
 while (TC3->COUNT8.STATUS.reg & TC_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
 
 // Enable TC3
 TC3->COUNT8.CTRLA.reg |= TC_CTRLA_ENABLE;
 while (TC3->COUNT8.STATUS.reg & TC_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
}

void SamdAudio::enableReaderTimer()
{
 NVIC_EnableIRQ(TC3_IRQn);
 TC3->COUNT8.CTRLA.reg |= TC_CTRLA_ENABLE;
 while (TC3->COUNT8.STATUS.reg & TC_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
}

void SamdAudio::disableReaderTimer()
{
 TC3->COUNT8.CTRLA.reg &= ~TC_CTRLA_ENABLE;
 while (TC3->COUNT8.STATUS.reg & TC_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
 NVIC_DisableIRQ(TC3_IRQn);
}


//*********************************************************************

#ifdef __cplusplus
extern "C" {
#endif
 
	// TC5 ISR
 void AudioPlay_Handler (void)
 {
 __audioData=0;
 
 for(uint8_t index=0; index<__numOfChannelsUsed; index++)
 {
 if (__audioPlaying[index])
 {
 if(__audioFile[index].available())
 {
 if (__SampleIndex[index] < AUDIO_BUFFER_SIZE - 1)
 {
 __audioData+=__WavSamples[index][whichBuffer[index]][__SampleIndex[index]++]/rampDivisor[index];
 
 }
 else //last sample from buffer
 {
 __audioData+=__WavSamples[index][whichBuffer[index]][__SampleIndex[index]++]/rampDivisor[index];
 
 __SampleIndex[index] = 0;
 if(!fillNextBuffer[index]) //we have been able to load next buffer : continue; else, loop the buffer...
 whichBuffer[index]=1-whichBuffer[index];
 fillNextBuffer[index]=1;
 }
 
 if(rampDivisor[index]>1)
 rampDivisor[index]--;
 }
 
 //end of file, now play ramp out
 else if (__audioFileReady[index])
 {
 __audioFile[index].close();
 __audioFileReady[index] = false;
 rampDivisor[index]=__WavSamples[index][whichBuffer[index]][__SampleIndex[index]]; //start ramp out from last audio sample
 __audioData+=rampDivisor[index];
 }
 else if(rampDivisor[index]>0)//ramp out finish, end of activity on the channel
 {
 __audioData+=rampDivisor[index]--;
 }
 else
 {
 __audioPlaying[index]=false;
 
 if(!__channelsPlaying())
 {
 //tc disable
 TC5->COUNT16.CTRLA.reg &= ~TC_CTRLA_ENABLE;
 while (TC5->COUNT16.STATUS.reg & TC_STATUS_SYNCBUSY);
 
 TC3->COUNT8.CTRLA.reg &= ~TC_CTRLA_ENABLE;
 while (TC3->COUNT8.STATUS.reg & TC_STATUS_SYNCBUSY) {
 /* Wait for synchronization */
 }
 
 }

 // call this channels callback function when done if available
 if(__onSoundCompletion[index] != NULL)
 {
 	// call the callback function
 	__onSoundCompletion[index]();

 	// clear the callback function
 	__onSoundCompletion[index] = NULL;
 }
 }
 }
 }
 
 
 if(__channelsPlaying())
 {
			if(__numOfChannelsUsed == 4 || __numOfChannelsUsed == 3)
			{
				__audioData>>=0;
			}
			else if(__numOfChannelsUsed == 2)
			{	
				__audioData<<=1;
			}
			else if(__numOfChannelsUsed == 1)
			{
				__audioData<<=2;
			}

 DAC->DATA.reg = __audioData & 0x3FF; // DAC on 10 bits.
 while (DAC->STATUS.bit.SYNCBUSY == 1);
 }
 
 
 // Clear the interrupt
 TC5->COUNT16.INTFLAG.bit.MC0 = 1;
 
 }
 
 
 
 // TC3 ISR
 void AudioRead_Handler()
 {
 if (TC3->COUNT8.INTFLAG.bit.OVF)
 {
 for(uint8_t index=0; index<__numOfChannelsUsed; index++)
 {
 if(__audioPlaying[index])
 {
 if(__audioFile[index].available() && !__criticalSection && fillNextBuffer[index])
 {
 __audioFile[index].read(__WavSamples[index][1-whichBuffer[index]], AUDIO_BUFFER_SIZE);
 fillNextBuffer[index]=0;
 }
 }
 }
 // Reset interrupt flag
 TC3->COUNT8.INTFLAG.bit.OVF = 1;
 }
 }
 
#ifdef __cplusplus
}
#endif