400 lines
11 KiB
C++
400 lines
11 KiB
C++
/****************************************************************************
|
|
* Copyright (c) 2011 by Michael Blandford. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the author nor the names of its contributors may
|
|
* be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
* THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
****************************************************************************
|
|
* History:
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "../open9x.h"
|
|
|
|
void start_sound( void ) ;
|
|
void buzzer_on( void ) ;
|
|
void buzzer_off( void ) ;
|
|
void buzzer_sound( uint8_t time ) ;
|
|
void start_timer1( void ) ;
|
|
void init_dac( void ) ;
|
|
extern "C" void DAC_IRQHandler( void ) ;
|
|
void disp_mem( register uint32_t address ) ;
|
|
void end_sound( void ) ;
|
|
void tone_start( register uint32_t time ) ;
|
|
void tone_stop( void ) ;
|
|
void init_twi( void ) ;
|
|
void set_volume( register uint8_t volume ) ;
|
|
extern "C" void TWI0_IRQHandler (void) ;
|
|
void audioDefevent( uint8_t e ) ;
|
|
|
|
extern uint32_t Master_frequency ; // TODO in a .h?
|
|
volatile uint8_t Buzzer_count ;
|
|
|
|
struct t_sound_globals
|
|
{
|
|
uint32_t Freq ;
|
|
uint32_t Sound_time ;
|
|
uint32_t Frequency ;
|
|
volatile uint32_t Tone_timer ; // Modified in interrupt routine
|
|
volatile uint8_t Tone_ms_timer ;
|
|
} Sound_g ;
|
|
|
|
|
|
// Must NOT be in flash, PDC needs a RAM source.
|
|
uint16_t Sine_values[] =
|
|
{
|
|
2048,2173,2298,2422,2545,2666,2784,2899,3011,3119,
|
|
3223,3322,3417,3505,3589,3666,3736,3800,3857,3907,
|
|
3950,3985,4012,4032,4044,4048,4044,4032,4012,3985,
|
|
3950,3907,3857,3800,3736,3666,3589,3505,3417,3322,
|
|
3223,3119,3011,2899,2784,2666,2545,2422,2298,2173,
|
|
2048,1922,1797,1673,1550,1429,1311,1196,1084, 976,
|
|
872, 773, 678, 590, 506, 429, 359, 295, 238, 188,
|
|
145, 110, 83, 63, 51, 48, 51, 63, 83, 110,
|
|
145, 188, 238, 295, 359, 429, 506, 590, 678, 773,
|
|
872, 976,1084,1196,1311,1429,1550,1673,1797,1922
|
|
} ;
|
|
|
|
// Must NOT be in flash, PDC needs a RAM source.
|
|
// We'll use these for higher frequencies
|
|
//uint16_t Sine_values64[] =
|
|
//{
|
|
//2048,2244,2438,2628,2813,2990,3159,3316,
|
|
//3462,3594,3710,3811,3895,3961,4009,4038,
|
|
//4048,4038,4009,3961,3895,3811,3710,3594,
|
|
//3462,3316,3159,2990,2813,2628,2438,2244,
|
|
//2048,1851,1657,1467,1282,1105, 936, 779,
|
|
// 633, 501, 385, 284, 200, 134, 86, 57,
|
|
// 48, 57, 86, 134, 200, 284, 385, 501,
|
|
// 633, 779, 936,1105,1282,1467,1657,1851
|
|
//} ;
|
|
|
|
const uint16_t PianoTones[] =
|
|
{
|
|
28, 29, 31, 33, 35, 37, 39, 41, 44, 46,
|
|
49, 52, 55, 58, 62, 65, 69, 73, 78, 82,
|
|
87, 92, 98, 104, 110, 117, 123, 131, 139, 147,
|
|
156, 165, 175, 185, 196, 208, 220, 233, 247, 262,
|
|
277, 294, 311, 330, 349, 370, 392, 415, 440, 466,
|
|
494, 523, 554, 587, 622, 659, 698, 740, 784, 831,
|
|
880, 932, 988, 1047, 1109, 1175, 1245, 1319, 1397, 1480,
|
|
1568, 1661, 1760, 1865, 1976, 2093, 2217, 2349, 2489, 2637,
|
|
2794, 2960, 3136, 3322, 3520 ,3729, 3951, 4186
|
|
} ;
|
|
|
|
|
|
// Sound routines
|
|
|
|
void start_sound()
|
|
{
|
|
register Pio *pioptr ;
|
|
|
|
start_timer1() ;
|
|
init_dac() ;
|
|
init_twi() ;
|
|
|
|
pioptr = PIOA ;
|
|
#ifdef REVB
|
|
pioptr->PIO_CODR = 0x02000000L ; // Set bit A25 OFF
|
|
pioptr->PIO_PER = 0x02000000L ; // Enable bit A25 (Stock buzzer)
|
|
pioptr->PIO_OER = 0x02000000L ; // Set bit A25 as output
|
|
#else
|
|
pioptr->PIO_CODR = 0x00010000L ; // Set bit A16 OFF
|
|
pioptr->PIO_PER = 0x00010000L ; // Enable bit A16 (Stock buzzer)
|
|
pioptr->PIO_OER = 0x00010000L ; // Set bit A16 as output
|
|
#endif
|
|
}
|
|
|
|
#ifdef REVB
|
|
void buzzer_on()
|
|
{
|
|
PIOA->PIO_SODR = 0x02000000L ; // Set bit A25 ON
|
|
}
|
|
|
|
void buzzer_off()
|
|
{
|
|
PIOA->PIO_CODR = 0x02000000L ; // Set bit A25 ON
|
|
}
|
|
#else
|
|
void buzzer_on()
|
|
{
|
|
PIOA->PIO_SODR = 0x00010000L ; // Set bit A16 ON
|
|
}
|
|
|
|
void buzzer_off()
|
|
{
|
|
PIOA->PIO_CODR = 0x00010000L ; // Set bit A16 ON
|
|
}
|
|
#endif
|
|
|
|
void buzzer_sound( uint8_t time )
|
|
{
|
|
buzzer_on() ;
|
|
Buzzer_count = time ;
|
|
}
|
|
|
|
|
|
void set_frequency( uint32_t frequency )
|
|
{
|
|
register Tc *ptc ;
|
|
register uint32_t timer ;
|
|
|
|
Sound_g.Frequency = frequency ;
|
|
timer = Master_frequency / (800 * frequency) ; // MCK/8 and 100 000 Hz
|
|
if ( timer > 65535 )
|
|
{
|
|
timer = 65535 ;
|
|
}
|
|
if ( timer < 2 )
|
|
{
|
|
timer = 2 ;
|
|
}
|
|
ptc = TC0 ; // Tc block 0 (TC0-2)
|
|
ptc->TC_CHANNEL[1].TC_CCR = TC_CCR0_CLKDIS ; // Stop clock
|
|
ptc->TC_CHANNEL[1].TC_RC = timer ; // 100 000 Hz
|
|
ptc->TC_CHANNEL[1].TC_RA = timer >> 1 ;
|
|
ptc->TC_CHANNEL[1].TC_CCR = 5 ; // Enable clock and trigger it (may only need trigger)
|
|
}
|
|
|
|
|
|
// Start TIMER1 at 100000Hz, used for DACC trigger
|
|
void start_timer1()
|
|
{
|
|
register Tc *ptc ;
|
|
register uint32_t timer ;
|
|
|
|
// Enable peripheral clock TC0 = bit 23 thru TC5 = bit 28
|
|
PMC->PMC_PCER0 |= 0x01000000L ; // Enable peripheral clock to TC1
|
|
|
|
timer = Master_frequency / 800000 ; // MCK/8 and 100 000 Hz
|
|
ptc = TC0 ; // Tc block 0 (TC0-2)
|
|
ptc->TC_BCR = 0 ; // No sync
|
|
ptc->TC_BMR = 0 ;
|
|
ptc->TC_CHANNEL[1].TC_CMR = 0x00008000 ; // Waveform mode
|
|
ptc->TC_CHANNEL[1].TC_RC = timer ; // 100 000 Hz
|
|
ptc->TC_CHANNEL[1].TC_RA = timer >> 1 ;
|
|
ptc->TC_CHANNEL[1].TC_CMR = 0x0009C001 ; // 0000 0000 0000 1001 1100 0000 0000 0001
|
|
// MCK/8, set @ RA, Clear @ RC waveform
|
|
ptc->TC_CHANNEL[1].TC_CCR = 5 ; // Enable clock and trigger it (may only need trigger)
|
|
Sound_g.Frequency = 1000 ;
|
|
}
|
|
|
|
|
|
|
|
// Configure DAC1 (or DAC0 for REVB)
|
|
// Not sure why PB14 has not be allocated to the DAC, although it is an EXTRA function
|
|
// So maybe it is automatically done
|
|
void init_dac()
|
|
{
|
|
register Dacc *dacptr ;
|
|
|
|
PMC->PMC_PCER0 |= 0x40000000L ; // Enable peripheral clock to DAC
|
|
dacptr = DACC ;
|
|
#ifdef REVB
|
|
dacptr->DACC_MR = 0x0B000215L ; // 0000 1011 0000 0001 0000 0010 0001 0101
|
|
#else
|
|
dacptr->DACC_MR = 0x0B010215L ; // 0000 1011 0000 0001 0000 0010 0001 0101
|
|
#endif
|
|
#ifdef REVB
|
|
dacptr->DACC_CHER = 1 ; // Enable channel 0
|
|
#else
|
|
dacptr->DACC_CHER = 2 ; // Enable channel 1
|
|
#endif
|
|
dacptr->DACC_CDR = 2048 ; // Half amplitude
|
|
// Data for PDC must NOT be in flash, PDC needs a RAM source.
|
|
dacptr->DACC_TPR = (uint32_t) Sine_values ;
|
|
dacptr->DACC_TNPR = (uint32_t) Sine_values ;
|
|
dacptr->DACC_TCR = 50 ; // words, 100 16 bit values
|
|
dacptr->DACC_TNCR = 50 ; // words, 100 16 bit values
|
|
dacptr->DACC_PTCR = DACC_PTCR_TXTEN ;
|
|
NVIC_EnableIRQ(DACC_IRQn) ;
|
|
}
|
|
|
|
extern "C" void DAC_IRQHandler()
|
|
{
|
|
// Data for PDC must NOT be in flash, PDC needs a RAM source.
|
|
DACC->DACC_TNPR = (uint32_t) Sine_values ;
|
|
DACC->DACC_TNCR = 50 ; // words, 100 16 bit values
|
|
if ( Sound_g.Tone_timer )
|
|
{
|
|
if ( --Sound_g.Tone_timer == 0 )
|
|
{
|
|
DACC->DACC_IDR = DACC_IDR_ENDTX ;
|
|
}
|
|
}
|
|
// if ( Tone_ms_timer == 0 )
|
|
// {
|
|
// Tone_ms_timer = -1 ;
|
|
// DACC->DACC_IDR = DACC_IDR_ENDTX ;
|
|
// }
|
|
}
|
|
|
|
void end_sound()
|
|
{
|
|
DACC->DACC_IDR = DACC_IDR_ENDTX ;
|
|
NVIC_DisableIRQ(DACC_IRQn) ;
|
|
TWI0->TWI_IDR = TWI_IDR_TXCOMP ;
|
|
NVIC_DisableIRQ(TWI0_IRQn) ;
|
|
PMC->PMC_PCER0 &= ~0x00080000L ; // Disable peripheral clock to TWI0
|
|
PMC->PMC_PCER0 &= ~0x40000000L ; // Disable peripheral clock to DAC
|
|
}
|
|
|
|
// Called every 5mS from interrupt routine
|
|
void sound_5ms()
|
|
{
|
|
if ( Sound_g.Tone_ms_timer > 0 )
|
|
{
|
|
Sound_g.Tone_ms_timer -= 1 ;
|
|
}
|
|
|
|
if ( Sound_g.Tone_ms_timer == 0 )
|
|
{
|
|
if ( Sound_g.Sound_time )
|
|
{
|
|
Sound_g.Tone_ms_timer = ( Sound_g.Sound_time + 4 ) / 5 ;
|
|
if ( Sound_g.Freq ) // 0 => silence for time
|
|
{
|
|
set_frequency( Sound_g.Freq ) ;
|
|
tone_start( 0 ) ;
|
|
}
|
|
Sound_g.Sound_time = 0 ;
|
|
}
|
|
else
|
|
{
|
|
DACC->DACC_IDR = DACC_IDR_ENDTX ; // Disable interrupt
|
|
Sound_g.Tone_timer = 0 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
// frequency in Hz, time in mS
|
|
void playTone( uint32_t frequency, uint32_t time )
|
|
{
|
|
Sound_g.Freq = frequency ;
|
|
Sound_g.Sound_time = time ;
|
|
// set_frequency( frequency ) ;
|
|
// Tone_ms_timer = ( time + 4 ) / 5 ;
|
|
// tone_start( 0 ) ;
|
|
}
|
|
|
|
|
|
// Time is in milliseconds
|
|
void tone_start( register uint32_t time )
|
|
{
|
|
PMC->PMC_PCER0 |= 0x40000000L ; // Enable peripheral clock to DAC
|
|
Sound_g.Tone_timer = Sound_g.Frequency * time / 1000 ;
|
|
DACC->DACC_IER = DACC_IER_ENDTX ;
|
|
}
|
|
|
|
void tone_stop()
|
|
{
|
|
DACC->DACC_IDR = DACC_IDR_ENDTX ; // Disable interrupt
|
|
Sound_g.Tone_timer = 0 ;
|
|
}
|
|
|
|
|
|
// Set up for volume control (TWI0)
|
|
// Need PA3 and PA4 set to peripheral A
|
|
void init_twi()
|
|
{
|
|
register Pio *pioptr ;
|
|
register uint32_t timing ;
|
|
|
|
PMC->PMC_PCER0 |= 0x00080000L ; // Enable peripheral clock to TWI0
|
|
|
|
/* Configure PIO */
|
|
pioptr = PIOA ;
|
|
pioptr->PIO_ABCDSR[0] &= ~0x00000018 ; // Peripheral A
|
|
pioptr->PIO_ABCDSR[1] &= ~0x00000018 ; // Peripheral A
|
|
pioptr->PIO_PDR = 0x00000018 ; // Assign to peripheral
|
|
|
|
timing = Master_frequency * 5 / 1000000 ; // 5uS high and low
|
|
timing += 15 - 4 ;
|
|
timing /= 16 ;
|
|
timing |= timing << 8 ;
|
|
|
|
TWI0->TWI_CWGR = 0x00040000 | timing ; // TWI clock set
|
|
TWI0->TWI_CR = TWI_CR_MSEN | TWI_CR_SVDIS ; // Master mode enable
|
|
TWI0->TWI_MMR = 0x002F0000 ; // Device 5E (>>1) and master is writing
|
|
NVIC_EnableIRQ(TWI0_IRQn) ;
|
|
set_volume( 2 ) ;
|
|
}
|
|
|
|
static int16_t Volume_required ;
|
|
static const uint8_t Volume_scale[NUM_VOL_LEVELS] =
|
|
{
|
|
0, 2, 4, 6, 8, 10, 13, 17, 22, 27, 33, 40,
|
|
64, 82, 96, 105, 112, 117, 120, 122, 124, 125, 126, 127
|
|
} ;
|
|
|
|
void set_volume( register uint8_t volume )
|
|
{
|
|
// PMC->PMC_PCER0 |= 0x00080000L ; // Enable peripheral clock to TWI0
|
|
|
|
if ( volume >= NUM_VOL_LEVELS )
|
|
{
|
|
volume = NUM_VOL_LEVELS - 1 ;
|
|
}
|
|
volume = Volume_scale[volume] ;
|
|
|
|
__disable_irq() ;
|
|
if ( TWI0->TWI_IMR & TWI_IMR_TXCOMP )
|
|
{
|
|
Volume_required = volume ;
|
|
}
|
|
else
|
|
{
|
|
TWI0->TWI_THR = volume ; // Send data
|
|
TWI0->TWI_CR = TWI_CR_STOP ; // Stop Tx
|
|
TWI0->TWI_IER = TWI_IER_TXCOMP ;
|
|
|
|
}
|
|
__enable_irq() ;
|
|
}
|
|
|
|
extern "C" void TWI0_IRQHandler()
|
|
{
|
|
if ( Volume_required >= 0 )
|
|
{
|
|
TWI0->TWI_THR = Volume_required ; // Send data
|
|
Volume_required = -1 ;
|
|
TWI0->TWI_CR = TWI_CR_STOP ; // Stop Tx
|
|
}
|
|
else
|
|
{
|
|
TWI0->TWI_IDR = TWI_IDR_TXCOMP ;
|
|
}
|
|
}
|
|
|
|
|
|
void audioDefevent(uint8_t e)
|
|
{
|
|
playTone( 2000, 60 ) ; // 2KHz, 60mS
|
|
// audio.event(e,BEEP_DEFAULT_FREQ);
|
|
}
|
|
|
|
|