SamdAudio.cpp

/*
 * Copyright AloyseTech(c) 2015
 * based on AudioZero library from Arduino Team
 *
 * Audio library for Arduino Zero.
 *
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of either the GNU General Public License version 2
 * or the GNU Lesser General Public License version 2.1, both as
 * published by the Free Software Foundation.
 */
#include "arduino.h"
#include "SamdAudio.h"

#define N_CHANNELS          4      //could be 1,2 or 4
#define AUDIO_BUFFER_SIZE   512
#define RAMPIN              255

/*Global variables*/
File __audioFile[N_CHANNELS];
volatile bool __audioPlaying[N_CHANNELS]={false};
volatile bool __audioLooping[N_CHANNELS][2]={false};
volatile bool __audioFileReady[N_CHANNELS] = {false};
volatile uint32_t __SampleIndex[N_CHANNELS];
uint8_t __WavSamples[N_CHANNELS][2][AUDIO_BUFFER_SIZE];
uint16_t rampDivisor[N_CHANNELS]={1};
uint8_t whichBuffer[N_CHANNELS]={0};
volatile bool fillNextBuffer[N_CHANNELS]={true};
volatile uint16_t __audioData;

uint8_t __AudioPlayerVolume=4; //0 to 3.
bool __criticalSection = false;


void TC5_Handler (void) __attribute__ ((weak, alias("AudioPlay_Handler")));
void TC3_Handler (void) __attribute__ ((weak, alias("AudioRead_Handler")));

/*
 
 for(uint8_t index=0; index<N_CHANNELS; index++)
 {
 
 }
 */

void SamdAudio::begin(uint32_t sampleRate) {
    
    for(uint8_t index=0; index<N_CHANNELS; index++)
    {
        __audioFileReady[index]=false;
        __SampleIndex[index]=0;
    }
    
    /*Modules configuration */
    dacConfigure();
    configurePlayerTimer(sampleRate);
    configureReaderTimer();
}

void SamdAudio::end() {
    disablePlayerTimer();
    resetPlayerTimer();
    disableReaderTimer();
    analogWrite(A0, 0);
}


void SamdAudio::stopChannel(uint8_t c)
{
    if(c>=0 && c<N_CHANNELS)
    {
        __audioFileReady[c]=false;
        __audioFile[c].close();
        __SampleIndex[c]=0;
        __audioPlaying[c]=false;
    }
}

void SamdAudio::loopChannel(uint8_t c, bool loopEnable)
{
    __audioLooping[c][0]=loopEnable;
}

void SamdAudio::setGain(uint8_t v)
{
    __AudioPlayerVolume=constrain(v,0,4);
}

void SamdAudio::gainUp()
{
    if(__AudioPlayerVolume<4)
        __AudioPlayerVolume++;
}

void SamdAudio::gainDown()
{
    if(__AudioPlayerVolume>0)
        __AudioPlayerVolume--;
}



void SamdAudio::play(const char *fname, uint8_t channel) {
    
    if(channel<0 || channel>=N_CHANNELS)
        return;
    
    disableReaderTimer();
    
    
    
    if(__audioFileReady[channel])
        __audioFile[channel].close();
    __audioFile[channel] = SD.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();
}

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

bool SamdAudio::isPlaying(uint8_t c)
{
    return __audioPlaying[c%N_CHANNELS];
}

bool __channelsPlaying()
{
    for(uint8_t index=0; index<N_CHANNELS; index++)
    {
        if(__audioPlaying[index])
            return true;
    }
    return 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::criticalON() {
    __criticalSection = true;
}

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

//SamdAudio AudioPlayer;


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
    
    void AudioPlay_Handler (void)
    {
        __audioData=0;
        
        for(uint8_t index=0; index<N_CHANNELS; 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])
                {
                    /*if(__audioLooping[index][1])
                    {
                        //wait for file rewind
                        //__SampleIndex[index] = 0;
                    }
                    else */
                    if(__audioLooping[index][0])
                    {
                        /*__SampleIndex[index] = 0;
                        __audioLooping[index][1]=true;//__audioFile[index].seek(44); //looping : go back to beginning
                        fillNextBuffer[index]=1;
                        rampDivisor[index]=__WavSamples[index][1-whichBuffer[index]][AUDIO_BUFFER_SIZE - 1];*/
                        __audioFile[index].seek(44);
                        __audioFile[index].read(__WavSamples[index][1-whichBuffer[index]], AUDIO_BUFFER_SIZE);
                        //rampDivisor[index]=__WavSamples[index][1-whichBuffer[index]][AUDIO_BUFFER_SIZE - 1];
                        whichBuffer[index]=1-whichBuffer[index];
                        fillNextBuffer[index]=1;
                        __SampleIndex[index]=0;
                    }
                    else
                    {
                        __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 */
                        }
                        
                    }
                }
            }
        }
        
        
        if(__channelsPlaying())
        {
#if N_CHANNELS > 4
            __audioData>>=1;
#elif N_CHANNELS<=2
            __audioData<<=1;
#endif
            
            
            switch (__AudioPlayerVolume) {
                case 0:
                    __audioData=0;
                    break;
                case 1:
                    __audioData>>=3;
                    break;
                case 2:
                    __audioData>>=2;
                    break;
                case 3:
                    __audioData>>=1;
                    //__audioData/=3;
                    break;
                default:
                    break;
            }
            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<N_CHANNELS; index++)
            {
                if(__audioPlaying[index])
                {
                    if(__audioLooping[index][1])
                    {
                        __audioFile[index].seek(44);
                        __audioLooping[index][1]=false;
                    }
                    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