visus
/
teensy-audio
Seguir 1
Destacar 0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
Explorar el Código

Add AudioControlTLV320AIC3206

dds
Chip Audette hace 6 años
padre
e06e997fdd
commit
3b6400621b
Se han modificado 4 ficheros con 875 adiciones y 0 borrados
Unificar vista Mostrar estadísticas de diff
  1. +1
    -0
      Audio.h
  2. +745
    -0
      control_tlv320aic3206.cpp
  3. +128
    -0
      control_tlv320aic3206.h
  4. +1
    -0
      keywords.txt

+ 1
- 0
Audio.h Ver fichero

#include "control_ak4558.h" #include "control_ak4558.h"
#include "control_cs4272.h" #include "control_cs4272.h"
#include "control_cs42448.h" #include "control_cs42448.h"
#include "control_tlv320aic3206.h"
#include "effect_bitcrusher.h" #include "effect_bitcrusher.h"
#include "effect_chorus.h" #include "effect_chorus.h"
#include "effect_fade.h" #include "effect_fade.h"

+ 745
- 0
control_tlv320aic3206.cpp Ver fichero

/*
control_tlv320aic3206
Created: Brendan Flynn (http://www.flexvoltbiosensor.com/) for Tympan, Jan-Feb 2017
Purpose: Control module for Texas Instruments TLV320AIC3206 compatible with Teensy Audio Library
License: MIT License. Use at your own risk.
*/

#include "control_tlv320aic3206.h"
#include <Wire.h>

//******************************** Constants *******************************//

#define AIC3206_I2C_ADDR 0x18


#ifndef AIC_FS
# define AIC_FS 44100UL
#endif

//define AIC_BITS 16
#define AIC_BITS 32

#define AIC_I2S_SLAVE 1
#if AIC_I2S_SLAVE
// Direction of BCLK and WCLK (reg 27) is input if a slave:
# define AIC_CLK_DIR 0
#else
// If master, make outputs:
# define AIC_CLK_DIR 0x0C
#endif

//#ifndef AIC_CODEC_CLKIN_BCLK
//# define AIC_CODEC_CLKIN_BCLK 0
//#endif

//**************************** Clock Setup **********************************//

//********************************** 44100 *********************************//
#if AIC_FS == 44100

// MCLK = 180000000 * 16 / 255 = 11.294117 MHz // FROM TEENSY, FIXED

// PLL setup. PLL_OUT = MCLK * R * J.D / P
//// J.D = 7.5264, P = 1, R = 1 => 90.32 MHz // FROM 12MHz CHA AND WHF //
// J.D = 7.9968, P = 1, R = 1 => 90.3168 MHz // For 44.1kHz exact
// J.D = 8.0000000002, P = 1, R = 1 => 9.35294117888MHz // for TEENSY 44.11764706kHz
#define PLL_J 8
#define PLL_D 0

// Bitclock divisor.
// BCLK = DAC_CLK/N = PLL_OUT/NDAC/N = 32*fs or 16*fs
// PLL_OUT = fs*NDAC*MDAC*DOSR
// BLCK = 32*fs = 1411200 = PLL
#if AIC_BITS == 16
#define BCLK_N 8
#elif AIC_BITS == 32
#define BCLK_N 4
#endif

// ADC/DAC FS setup.
// ADC_MOD_CLK = CODEC_CLKIN / (NADC * MADC)
// DAC_MOD_CLK = CODEC_CLKIN / (NDAC * MDAC)
// ADC_FS = PLL_OUT / (NADC*MADC*AOSR)
// DAC_FS = PLL_OUT / (NDAC*MDAC*DOSR)
// FS = 90.3168MHz / (8*2*128) = 44100 Hz.
// MOD = 90.3168MHz / (8*2) = 5644800 Hz

// Actual from Teensy: 44117.64706Hz * 128 => 5647058.82368Hz * 8*2 => 90352941.17888Hz

// DAC clock config.
// Note: MDAC*DOSR/32 >= RC, where RC is 8 for the default filter.
// See Table 2-21
// http://www.ti.com/lit/an/slaa463b/slaa463b.pdf
// PB1 - RC = 8. Use M8, N2
// PB25 - RC = 12. Use M8, N2

#define DOSR 128
#define NDAC 2
#define MDAC 8

#define AOSR 128
#define NADC 2
#define MADC 8

// Signal Processing Modes, Playback and Recording.
#define PRB_P 1
#define PRB_R 1

#endif // end fs if block

//**************************** Chip Setup **********************************//

//******************* INPUT DEFINITIONS *****************************//
// MIC routing registers
#define AIC3206_MICPGA_LEFT_POSITIVE_REG 0x0134 // page 1 register 52
#define AIC3206_MICPGA_LEFT_NEGATIVE_REG 0x0136 // page 1 register 54
#define AIC3206_MICPGA_RIGHT_POSITIVE_REG 0x0137 // page 1 register 55
#define AIC3206_MICPGA_RIGHT_NEGATIVE_REG 0x0139 // page 1 register 57

#define AIC3206_MIC_ROUTING_POSITIVE_IN1 0b11000000 //
#define AIC3206_MIC_ROUTING_POSITIVE_IN2 0b00110000 //
#define AIC3206_MIC_ROUTING_POSITIVE_IN3 0b00001100 //
#define AIC3206_MIC_ROUTING_POSITIVE_REVERSE 0b00000011 //

#define AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L 0b11000000 //
#define AIC3206_MIC_ROUTING_NEGATIVE_IN2_REVERSE 0b00110000 //
#define AIC3206_MIC_ROUTING_NEGATIVE_IN3_REVERSE 0b00001100 //
#define AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM2L 0b00000011 //

#define AIC3206_MIC_ROUTING_RESISTANCE_10k 0b01010101
#define AIC3206_MIC_ROUTING_RESISTANCE_20k 0b10101010
#define AIC3206_MIC_ROUTING_RESISTANCE_40k 0b11111111
#define AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT AIC3206_MIC_ROUTING_RESISTANCE_10k //datasheet (application notes) defaults to 20K...why?

#define AIC3206_MICPGA_LEFT_VOLUME_REG 0x013B // page 1 register 59 // 0 to 47.5dB in 0.5dB steps
#define AIC3206_MICPGA_RIGHT_VOLUME_REG 0x013C // page 1 register 60 // 0 to 47.5dB in 0.5dB steps

#define AIC3206_MICPGA_VOLUME_ENABLE 0x00 // default is 0b11000000 - clear to 0 to enable

#define AIC3206_MIC_BIAS_REG 0x0133 // page 1 reg 51
#define AIC3206_MIC_BIAS_POWER_ON 0x40
#define AIC3206_MIC_BIAS_POWER_OFF 0x00
#define AIC3206_MIC_BIAS_OUTPUT_VOLTAGE_1_25 0x00
#define AIC3206_MIC_BIAS_OUTPUT_VOLTAGE_1_7 0x01
#define AIC3206_MIC_BIAS_OUTPUT_VOLTAGE_2_5 0x10
#define AIC3206_MIC_BIAS_OUTPUT_VOLTAGE_VSUPPLY 0x11

#define AIC3206_ADC_PROCESSING_BLOCK_REG 0x003d // page 0 register 61

#define AIC3206_ADC_CHANNEL_POWER_REG 0x0051 // page 0 register81
#define AIC3206_ADC_CHANNELS_ON 0b11000000 // power up left and right

#define AIC3206_ADC_MUTE_REG 0x0052 // page 0, register 82
#define AIC3206_ADC_UNMUTE 0x00

bool AudioControlTLV320AIC3206::enable(void)
{
delay(100);

// Setup for Master mode, pins 18/19, external pullups, 400kHz, 200ms default timeout
Wire.begin();
delay(5);

//hard reset the AIC
//Serial.println("Hardware reset of AIC...");
//define RESET_PIN 21
#define RESET_PIN (resetPinAIC)
pinMode(RESET_PIN,OUTPUT);
digitalWrite(RESET_PIN,HIGH);delay(50); //not reset
digitalWrite(RESET_PIN,LOW);delay(50); //reset
digitalWrite(RESET_PIN,HIGH);delay(50);//not reset
aic_reset(); delay(100); //soft reset
aic_init(); delay(100);
aic_initADC(); delay(100);
aic_initDAC(); delay(100);

aic_readPage(0, 27); // check a specific register - a register read test

if (debugToSerial) Serial.println("TLV320 enable done");

return true;

}

bool AudioControlTLV320AIC3206::disable(void) {
return true;
}

//dummy function to keep compatible with Teensy Audio Library
bool AudioControlTLV320AIC3206::inputLevel(float volume) {
return false;
}

bool AudioControlTLV320AIC3206::inputSelect(int n) {
if (n == AIC3206_INPUT_IN1) {
aic_writeAddress(AIC3206_MICPGA_LEFT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN1 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_LEFT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN1 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
// BIAS OFF
setMicBias(AIC3206_MIC_BIAS_OFF);

if (debugToSerial) Serial.println("Set Audio Input to IN1");
return true;
} else if (n == AIC3206_INPUT_IN3_MICBIAS) {
aic_writeAddress(AIC3206_MICPGA_LEFT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN3 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_LEFT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN3 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
// BIAS on, using default
setMicBias(AIC3206_DEFAULT_MIC_BIAS);

if (debugToSerial) Serial.println("Set Audio Input to IN3, BIAS SET TO DEFAULT 2.5V");
return true;
} else if (n == AIC3206_INPUT_IN3) {
aic_writeAddress(AIC3206_MICPGA_LEFT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN3 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_LEFT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN3 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
// BIAS Off
setMicBias(AIC3206_MIC_BIAS_OFF);

if (debugToSerial) Serial.println("Set Audio Input to IN3, BIAS OFF");
return true;
} else if (n == AIC3206_INPUT_IN2) {
aic_writeAddress(AIC3206_MICPGA_LEFT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN2 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_LEFT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN2 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
// BIAS Off
setMicBias(AIC3206_MIC_BIAS_OFF);
if (debugToSerial) Serial.println("Set Audio Input to IN2, BIAS OFF");

return true;
}
Serial.print("controlTLV320AIC3206: ERROR: Unable to Select Input - Value not supported: ");
Serial.println(n);
return false;
}

bool AudioControlTLV320AIC3206::setMicBias(int n) {
if (n == AIC3206_MIC_BIAS_1_25) {
aic_writeAddress(AIC3206_MIC_BIAS_REG, AIC3206_MIC_BIAS_POWER_ON | AIC3206_MIC_BIAS_OUTPUT_VOLTAGE_1_25); // power up mic bias
return true;
} else if (n == AIC3206_MIC_BIAS_1_7) {
aic_writeAddress(AIC3206_MIC_BIAS_REG, AIC3206_MIC_BIAS_POWER_ON | AIC3206_MIC_BIAS_OUTPUT_VOLTAGE_1_7); // power up mic bias
return true;
} else if (n == AIC3206_MIC_BIAS_2_5) {
aic_writeAddress(AIC3206_MIC_BIAS_REG, AIC3206_MIC_BIAS_POWER_ON | AIC3206_MIC_BIAS_OUTPUT_VOLTAGE_2_5); // power up mic bias
return true;
} else if (n == AIC3206_MIC_BIAS_VSUPPLY) {
aic_writeAddress(AIC3206_MIC_BIAS_REG, AIC3206_MIC_BIAS_POWER_ON | AIC3206_MIC_BIAS_OUTPUT_VOLTAGE_VSUPPLY); // power up mic bias
return true;
} else if (n == AIC3206_MIC_BIAS_OFF) {
aic_writeAddress(AIC3206_MIC_BIAS_REG, AIC3206_MIC_BIAS_POWER_OFF); // power up mic bias
return true;
}
Serial.print("controlTLV320AIC3206: ERROR: Unable to set MIC BIAS - Value not supported: ");
Serial.println(n);
return false;
}

void AudioControlTLV320AIC3206::aic_reset() {
if (debugToSerial) Serial.println("INFO: Reseting AIC");
aic_writePage(0x00, 0x01, 0x01);
// aic_writeAddress(0x0001, 0x01);

delay(10);
}


// example - turn on IN3 - mic jack, with negatives routed to CM1L and with 10k resistance
// aic_writeAddress(AIC3206_LEFT_MICPGA_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN3 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
// aic_writeAddress(AIC3206_LEFT_MICPGA_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
// aic_writeAddress(AIC3206_RIGHT_MICPGA_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN3 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
// aic_writeAddress(AIC3206_RIGHT_MICPGA_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);

void AudioControlTLV320AIC3206::aic_initADC() {
if (debugToSerial) Serial.println("INFO: Initializing AIC ADC");
aic_writeAddress(AIC3206_ADC_PROCESSING_BLOCK_REG, PRB_R); // processing blocks - ADC
aic_writePage(1, 61, 0); // 0x3D // Select ADC PTM_R4 Power Tune? (this line is from datasheet (application guide, Section 4.2)
aic_writePage(1, 71, 0b00110001); // 0x47 // Set MicPGA startup delay to 3.1ms
aic_writeAddress(AIC3206_MIC_BIAS_REG, AIC3206_MIC_BIAS_POWER_ON | AIC3206_MIC_BIAS_2_5); // power up mic bias

aic_writeAddress(AIC3206_MICPGA_LEFT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN2 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_LEFT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_POSITIVE_REG, AIC3206_MIC_ROUTING_POSITIVE_IN2 & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);
aic_writeAddress(AIC3206_MICPGA_RIGHT_NEGATIVE_REG, AIC3206_MIC_ROUTING_NEGATIVE_CM_TO_CM1L & AIC3206_MIC_ROUTING_RESISTANCE_DEFAULT);

aic_writeAddress(AIC3206_MICPGA_LEFT_VOLUME_REG, AIC3206_MICPGA_VOLUME_ENABLE); // enable Left MicPGA, set gain to 0 dB
aic_writeAddress(AIC3206_MICPGA_RIGHT_VOLUME_REG, AIC3206_MICPGA_VOLUME_ENABLE); // enable Right MicPGA, set gain to 0 dB

aic_writeAddress(AIC3206_ADC_MUTE_REG, AIC3206_ADC_UNMUTE); // Unmute Left and Right ADC Digital Volume Control
aic_writeAddress(AIC3206_ADC_CHANNEL_POWER_REG, AIC3206_ADC_CHANNELS_ON); // Unmute Left and Right ADC Digital Volume Control
}

// set MICPGA volume, 0-47.5dB in 0.5dB setps
bool AudioControlTLV320AIC3206::setInputGain_dB(float volume) {
if (volume < 0.0) {
volume = 0.0; // 0.0 dB
Serial.println("controlTLV320AIC3206: WARNING: Attempting to set MIC volume outside range");
}
if (volume > 47.5) {
volume = 47.5; // 47.5 dB
Serial.println("controlTLV320AIC3206: WARNING: Attempting to set MIC volume outside range");
}

volume = volume * 2.0; // convert to value map (0.5 dB steps)
int8_t volume_int = (int8_t) (round(volume)); // round

if (debugToSerial) {
Serial.print("INFO: Setting MIC volume to ");
Serial.print(volume, 1);
Serial.print(". Converted to volume map => ");
Serial.println(volume_int);
}

aic_writeAddress(AIC3206_MICPGA_LEFT_VOLUME_REG, AIC3206_MICPGA_VOLUME_ENABLE | volume_int); // enable Left MicPGA, set gain to 0 dB
aic_writeAddress(AIC3206_MICPGA_RIGHT_VOLUME_REG, AIC3206_MICPGA_VOLUME_ENABLE | volume_int); // enable Right MicPGA, set gain to 0 dB
return true;
}

//******************* OUTPUT DEFINITIONS *****************************//
#define AIC3206_DAC_PROCESSING_BLOCK_REG 0x003c // page 0 register 60
#define AIC3206_DAC_VOLUME_LEFT_REG 0x0041 // page 0 reg 65
#define AIC3206_DAC_VOLUME_RIGHT_REG 0x0042 // page 0 reg 66


//volume control, similar to Teensy Audio Board
// value between 0.0 and 1.0. Set to span -58 to +15 dB
bool AudioControlTLV320AIC3206::volume(float volume) {
volume = max(0.0, min(1.0, volume));
float vol_dB = -58.f + (15.0 - (-58.0f)) * volume;
volume_dB(vol_dB);
return true;
}

bool AudioControlTLV320AIC3206::enableAutoMuteDAC(bool enable, uint8_t mute_delay_code=7) {
if (enable) {
mute_delay_code = max(0,min(mute_delay_code,7));
if (mute_delay_code == 0) enable = false;
} else {
mute_delay_code = 0; //this disables the auto mute
}
uint8_t val = aic_readPage(0,64);
val = val & 0b10001111; //clear these bits
val = val | (mute_delay_code << 4); //set these bits
aic_writePage(0,64,val);
return enable;
}

// -63.6 to +24 dB in 0.5dB steps. uses signed 8-bit
bool AudioControlTLV320AIC3206::volume_dB(float volume) {

// Constrain to limits
if (volume > 24.0) {
volume = 24.0;
Serial.println("controlTLV320AIC3206: WARNING: Attempting to set DAC Volume outside range");
}
if (volume < -63.5) {
volume = -63.5;
Serial.println("controlTLV320AIC3206: WARNING: Attempting to set DAC Volume outside range");
}

volume = volume * 2.0; // convert to value map (0.5 dB steps)
int8_t volume_int = (int8_t) (round(volume)); // round

if (debugToSerial) {
Serial.print("controlTLV320AIC3206: Setting DAC volume to ");
Serial.print(volume, 1);
Serial.print(". Converted to volume map => ");
Serial.println(volume_int);
}

aic_writeAddress(AIC3206_DAC_VOLUME_RIGHT_REG, volume_int);
aic_writeAddress(AIC3206_DAC_VOLUME_LEFT_REG, volume_int);
return true;
}

void AudioControlTLV320AIC3206::aic_initDAC() {
if (debugToSerial) Serial.println("controlTLV320AIC3206: Initializing AIC DAC");
outputSelect(AIC3206_OUTPUT_HEADPHONE_JACK_OUT); //default
}

bool AudioControlTLV320AIC3206::outputSelect(int n) {
// PLAYBACK SETUP:
// HPL/HPR are headphone output left and right
// LOL/LOR are line output left and right
aic_writeAddress(AIC3206_DAC_PROCESSING_BLOCK_REG, PRB_P); // processing blocks - DAC

//mute, disable, then power-down everything
aic_writePage(1, 16, 0b01000000); // mute HPL Driver, 0 gain
aic_writePage(1, 17, 0b01000000); // mute HPR Driver, 0 gain
aic_writePage(1, 18, 0b01000000); // mute LOL Driver, 0 gain
aic_writePage(1, 19, 0b01000000); // mute LOR Driver, 0 gain
aic_writePage(0, 63, 0); //disable LDAC/RDAC
aic_writePage(1, 9, 0); // Power down HPL/HPR and LOL/LOR drivers
aic_writePage(1,12,0); //unroute from HPL
aic_writePage(1,13,0); //unroute from HPR
aic_writePage(1,14,0); //unroute from LOL
aic_writePage(1,15,0); //unroute from LOR


if (n == AIC3206_OUTPUT_HEADPHONE_JACK_OUT) {

//aic_writePage(1, 20, 0x25); // 0x14 De-Pop
//aic_writePage(1, 12, 8); // route LDAC/RDAC to HPL/HPR
//aic_writePage(1, 13, 8); // route LDAC/RDAC to HPL/HPR
aic_writePage(1, 12, 0b00001000); // route LDAC/RDAC to HPL/HPR
aic_writePage(1, 13, 0b00001000); // route LDAC/RDAC to HPL/HPR
aic_writePage(0, 63, 0xD6); // 0x3F // Power up LDAC/RDAC
aic_writePage(1, 16, 0); // unmute HPL Driver, 0 gain
aic_writePage(1, 17, 0); // unmute HPR Driver, 0 gain
aic_writePage(1, 9, 0x30); // Power up HPL/HPR drivers 0b00110000
delay(100);
aic_writeAddress(AIC3206_DAC_VOLUME_LEFT_REG, 0); // default to 0 dB
aic_writeAddress(AIC3206_DAC_VOLUME_RIGHT_REG, 0); // default to 0 dB
aic_writePage(0, 64, 0); // 0x40 // Unmute LDAC/RDAC

if (debugToSerial) Serial.println("controlTLV320AIC3206: Set Audio Output to Headphone Jack");
return true;
} else if (n == AIC3206_OUTPUT_LINE_OUT) {
//aic_writePage(1, 20, 0x25); // 0x14 De-Pop
aic_writePage(1, 14, 0b00001000); // route LDAC/RDAC to LOL/LOR
aic_writePage(1, 15, 0b00001000); // route LDAC/RDAC to LOL/LOR
aic_writePage(0, 63, 0xD6); // 0x3F // Power up LDAC/RDAC
aic_writePage(1, 18, 0); // unmute LOL Driver, 0 gain
aic_writePage(1, 19, 0); // unmute LOR Driver, 0 gain
aic_writePage(1, 9, 0b00001100); // Power up LOL/LOR drivers
delay(100);
aic_writeAddress(AIC3206_DAC_VOLUME_LEFT_REG, 0); // default to 0 dB
aic_writeAddress(AIC3206_DAC_VOLUME_RIGHT_REG, 0); // default to 0 dB
aic_writePage(0, 64, 0); // 0x40 // Unmute LDAC/RDAC

if (debugToSerial) Serial.println("controlTLV320AIC3206: Set Audio Output to Line Out");
return true;
} else if (n == AIC3206_OUTPUT_HEADPHONE_AND_LINE_OUT) {
aic_writePage(1, 12, 0b00001000); // route LDAC/RDAC to HPL/HPR
aic_writePage(1, 13, 0b00001000); // route LDAC/RDAC to HPL/HPR
aic_writePage(1, 14, 0b00001000); // route LDAC/RDAC to LOL/LOR
aic_writePage(1, 15, 0b00001000); // route LDAC/RDAC to LOL/LOR
aic_writePage(0, 63, 0xD6); // 0x3F // Power up LDAC/RDAC
aic_writePage(1, 18, 0); // unmute LOL Driver, 0 gain
aic_writePage(1, 19, 0); // unmute LOR Driver, 0 gain
aic_writePage(1, 16, 0); // unmute HPL Driver, 0 gain
aic_writePage(1, 17, 0); // unmute HPR Driver, 0 gain

aic_writePage(1, 9, 0b00111100); // Power up both the HPL/HPR and the LOL/LOR drivers
delay(100);
aic_writeAddress(AIC3206_DAC_VOLUME_LEFT_REG, 0); // default to 0 dB
aic_writeAddress(AIC3206_DAC_VOLUME_RIGHT_REG, 0); // default to 0 dB
aic_writePage(0, 64, 0); // 0x40 // Unmute LDAC/RDAC

if (debugToSerial) Serial.println("controlTLV320AIC3206: Set Audio Output to Headphone Jack and Line out");
return true;
}
Serial.print("controlTLV320AIC3206: ERROR: Unable to Select Output - Value not supported: ");
Serial.println(n);
return false;
}


void AudioControlTLV320AIC3206::aic_init() {
if (debugToSerial) Serial.println("controlTLV320AIC3206: Initializing AIC");
// PLL
aic_writePage(0, 4, 3); // 0x04 low PLL clock range, MCLK is PLL input, PLL_OUT is CODEC_CLKIN
aic_writePage(0, 5, (PLL_J != 0 ? 0x91 : 0x11));
aic_writePage(0, 6, PLL_J);
aic_writePage(0, 7, PLL_D >> 8);
aic_writePage(0, 8, PLL_D &0xFF);

// CLOCKS
aic_writePage(0, 11, 0x80 | NDAC); // 0x0B
aic_writePage(0, 12, 0x80 | MDAC); // 0x0C
aic_writePage(0, 13, 0); // 0x0D
aic_writePage(0, 14, DOSR); // 0x0E
// aic_writePage(0, 18, 0); // 0x12 // powered down, ADC_CLK same as DAC_CLK
// aic_writePage(0, 19, 0); // 0x13 // powered down, ADC_MOD_CLK same as DAC_MOD_CLK
aic_writePage(0, 18, 0x80 | NADC); // 0x12
aic_writePage(0, 19, 0x80 | MADC); // 0x13
aic_writePage(0, 20, AOSR);
aic_writePage(0, 30, 0x80 | BCLK_N); // power up BLCK N Divider, default is 128

// POWER
aic_writePage(1, 0x01, 8); // Reg 1, Val = 8 = 0b00001000 = disable weak connection AVDD to DVDD. Keep headphone charge pump disabled.
aic_writePage(1, 0x02, 0); // Reg 2, Val = 0 = 0b00000000 = Enable Master Analog Power Control
aic_writePage(1, 0x7B, 1); // Reg 123, Val = 1 = 0b00000001 = Set reference to power up in 40ms when analog blocks are powered up
aic_writePage(1, 0x7C, 6); // Reg 124, Val = 6 = 0b00000110 = Charge Pump, full peak current (000), clock divider (110) to Div 6 = 333 kHz
aic_writePage(1, 0x01, 10); // Reg 1, Val = 10 = 0x0A = 0b00001010. Activate headphone charge pump.
aic_writePage(1, 0x0A, 0); // Reg 10, Val = 0 = common mode 0.9 for full chip, HP, LO // from WHF/CHA
aic_writePage(1, 0x47, 0x31); // Reg 71, val = 0x31 = 0b00110001 = Set input power-up time to 3.1ms (for ADC)
aic_writePage(1, 0x7D, 0x53); // Reg 125, Val = 0x53 = 0b01010011 = 0 10 1 00 11: HPL is master gain, Enable ground-centered mode, 100% output power, DC offset correction // from WHF/CHA

// !!!!!!!!! The below writes are from WHF/CHA - probably don't need?
// aic_writePage(1, 1, 10); // 10 = 0b00001010 // weakly connect AVDD to DVDD. Activate charge pump
aic_writePage(0, 27, 0x01 | AIC_CLK_DIR | (AIC_BITS == 32 ? 0x30 : 0)); // 0x1B
// aic_writePage(0, 28, 0); // 0x1C
}

unsigned int AudioControlTLV320AIC3206::aic_readPage(uint8_t page, uint8_t reg)
{
unsigned int val;
if (aic_goToPage(page)) {
Wire.beginTransmission(AIC3206_I2C_ADDR);
Wire.write(reg);
unsigned int result = Wire.endTransmission();
if (result != 0) {
Serial.print("controlTLV320AIC3206: ERROR: Read Page. Page: ");Serial.print(page);
Serial.print(" Reg: ");Serial.print(reg);
Serial.print(". Received Error During Read Page: ");
Serial.println(result);
val = 300 + result;
return val;
}
if (Wire.requestFrom(AIC3206_I2C_ADDR, 1) < 1) {
Serial.print("controlTLV320AIC3206: ERROR: Read Page. Page: ");Serial.print(page);
Serial.print(" Reg: ");Serial.print(reg);
Serial.println(". Nothing to return");
val = 400;
return val;
}
if (Wire.available() >= 1) {
uint16_t val = Wire.read();
if (debugToSerial) {
Serial.print("controlTLV320AIC3206: Read Page. Page: ");Serial.print(page);
Serial.print(" Reg: ");Serial.print(reg);
Serial.print(". Received: ");
Serial.println(val, HEX);
}
return val;
}
} else {
Serial.print("controlTLV320AIC3206: INFO: Read Page. Page: ");Serial.print(page);
Serial.print(" Reg: ");Serial.print(reg);
Serial.println(". Failed to go to read page. Could not go there.");
val = 500;
return val;
}
val = 600;
return val;
}

bool AudioControlTLV320AIC3206::aic_writeAddress(uint16_t address, uint8_t val) {
uint8_t reg = (uint8_t) (address & 0xFF);
uint8_t page = (uint8_t) ((address >> 8) & 0xFF);

return aic_writePage(page, reg, val);
}

bool AudioControlTLV320AIC3206::aic_writePage(uint8_t page, uint8_t reg, uint8_t val) {
if (debugToSerial) {
Serial.print("controlTLV320AIC3206: Write Page. Page: ");Serial.print(page);
Serial.print(" Reg: ");Serial.print(reg);
Serial.print(" Val: ");Serial.println(val);
}
if (aic_goToPage(page)) {
Wire.beginTransmission(AIC3206_I2C_ADDR);
Wire.write(reg);delay(10);
Wire.write(val);delay(10);
uint8_t result = Wire.endTransmission();
if (result == 0) return true;
else {
Serial.print("controlTLV320AIC3206: Received Error During writePage(): Error = ");
Serial.println(result);
}
}
return false;
}

bool AudioControlTLV320AIC3206::aic_goToPage(byte page) {
Wire.beginTransmission(AIC3206_I2C_ADDR);
Wire.write(0x00); delay(10);// page register //was delay(10) from BPF
Wire.write(page); delay(10);// go to page //was delay(10) from BPF
byte result = Wire.endTransmission();
if (result != 0) {
Serial.print("controlTLV320AIC3206: Received Error During goToPage(): Error = ");
Serial.println(result);
if (result == 2) {
// failed to transmit address
//return aic_goToPage(page);
} else if (result == 3) {
// failed to transmit data
//return aic_goToPage(page);
}
return false;
}
return true;
}

bool AudioControlTLV320AIC3206::updateInputBasedOnMicDetect(int setting) {
//read current mic detect setting
int curMicDetVal = readMicDetect();
if (curMicDetVal != prevMicDetVal) {
if (curMicDetVal) {
//enable the microphone input jack as our input
inputSelect(setting);
} else {
//switch back to the on-board mics
inputSelect(AIC3206_INPUT_IN2);
}
}
prevMicDetVal = curMicDetVal;
return (bool)curMicDetVal;
}
bool AudioControlTLV320AIC3206::enableMicDetect(bool state) {
//page 0, register 67
byte curVal = aic_readPage(0,67);
byte newVal = curVal;
if (state) {
//enable
newVal = 0b111010111 & newVal; //set bits 4-2 to be 010 to set debounce to 64 msec
newVal = 0b10000000 | curVal; //force bit 1 to 1 to enable headset to detect
aic_writePage(0,67,newVal); //bit 7 (=1) enable headset detect, bits 4-2 (=010) debounce to 64ms
} else {
//disable
newVal = 0b01111111 & newVal; //force bit 7 to zero to disable headset detect
aic_writePage(0,67,newVal); //bit 7 (=1) enable headset detect, bits 4-2 (=010) debounce to 64ms
}
return state;
}
int AudioControlTLV320AIC3206::readMicDetect(void) {
//page 0, register 46, bit D4 (for D7-D0)
byte curVal = aic_readPage(0,46);
curVal = (curVal & 0b00010000);
curVal = (curVal != 0);
return curVal;
}

void computeFirstOrderHPCoeff_F32(float cutoff_Hz, float fs_Hz, float *coeff) {
//cutoff_Hz is the cutoff frequency in Hz
//fs_Hz is the sample rate in Hz
//First-order Butterworth IIR
//From https://www.dsprelated.com/showcode/199.php
const float pi = 3.141592653589793;
float T = 1.0f/fs_Hz; //sample period
float w = cutoff_Hz * 2.0 * pi;
float A = 1.0f / (tan( (w*T) / 2.0));
coeff[0] = A / (1.0 + A); // first b coefficient
coeff[1] = -coeff[0]; // second b coefficient
coeff[2] = (1.0 - A) / (1.0 + A); //second a coefficient (Matlab sign convention)
coeff[2] = -coeff[2]; //flip to be TI sign convention
}
#define CONST_2_31_m1 (2147483647) //2^31 - 1
void computeFirstOrderHPCoeff_i32(float cutoff_Hz, float fs_Hz, int32_t *coeff) {
float coeff_f32[3];
computeFirstOrderHPCoeff_F32(cutoff_Hz,fs_Hz,coeff_f32);
for (int i=0; i<3; i++) {
//scale
coeff_f32[i] *= (float)CONST_2_31_m1;
//truncate
coeff[i] = (int32_t)coeff_f32[i];
}
}
void AudioControlTLV320AIC3206::setHPFonADC(bool enable, float cutoff_Hz, float fs_Hz) { //fs_Hz is sample rate
//see TI application guide Section 2.3.3.1.10.1: http://www.ti.com/lit/an/slaa463b/slaa463b.pdf
uint32_t coeff[3];
if (enable) {
HP_cutoff_Hz = cutoff_Hz;
sample_rate_Hz = fs_Hz;
computeFirstOrderHPCoeff_i32(cutoff_Hz,fs_Hz,(int32_t *)coeff);
//Serial.print("enableHPFonADC: coefficients, Hex: ");
//Serial.print(coeff[0],HEX);
//Serial.print(", ");
//Serial.print(coeff[1],HEX);
//Serial.print(", ");
//Serial.print(coeff[2],HEX);
//Serial.println();
} else {
//disable
HP_cutoff_Hz = cutoff_Hz;
//see Table 5-4 in TI application guide Coeff C4, C5, C6
coeff[0] = 0x7FFFFFFF; coeff[1] = 0; coeff[2]=0;
}
setIIRCoeffOnADC(BOTH_CHAN, coeff); //needs twos-compliment
}


//set first-order IIR filter coefficients on ADC
void AudioControlTLV320AIC3206::setIIRCoeffOnADC(int chan, uint32_t *coeff) {

//power down the AIC to allow change in coefficients
uint32_t prev_state = aic_readPage(0x00,0x51);
aic_writePage(0x00,0x51,prev_state & (0b00111111)); //clear first two bits
if (chan == BOTH_CHAN) {
setIIRCoeffOnADC_Left(coeff);
setIIRCoeffOnADC_Right(coeff);
} else if (chan == LEFT_CHAN) {
setIIRCoeffOnADC_Left(coeff);
} else {
setIIRCoeffOnADC_Right(coeff);
}

//power the ADC back up
aic_writePage(0x00,0x51,prev_state); //clear first two bits
}
void AudioControlTLV320AIC3206::setIIRCoeffOnADC_Left(uint32_t *coeff) {
int page;
uint32_t c;
//See TI AIC3206 Application Guide, Table 2-13: http://www.ti.com/lit/an/slaa463b/slaa463b.pdf
//Coeff N0, Coeff C4
page = 8;
c = coeff[0];
aic_writePage(page,24,(uint8_t)(c>>24));
aic_writePage(page,25,(uint8_t)(c>>16));
aic_writePage(page,26,(uint8_t)(c>>8));
//int foo = aic_readPage(page,24); Serial.print("setIIRCoeffOnADC: first coefficient: "); Serial.println(foo);

//Coeff N1, Coeff C5
c = coeff[1];
aic_writePage(page,28,(uint8_t)(c>>24));
aic_writePage(page,29,(uint8_t)(c>>16));
aic_writePage(page,30,(uint8_t)(c>>8));
//Coeff N2, Coeff C6
c = coeff[2];
aic_writePage(page,32,(uint8_t)(c>>24));
aic_writePage(page,33,(uint8_t)(c>>16));
aic_writePage(page,34,(uint8_t)(c>>9));
}
void AudioControlTLV320AIC3206::setIIRCoeffOnADC_Right(uint32_t *coeff) {
int page;
uint32_t c;
//See TI AIC3206 Application Guide, Table 2-13: http://www.ti.com/lit/an/slaa463b/slaa463b.pdf
//Coeff N0, Coeff C36
page = 9;
c = coeff[0];
aic_writePage(page,32,(uint8_t)(c>>24));
aic_writePage(page,33,(uint8_t)(c>>16));
aic_writePage(page,34,(uint8_t)(c>>8));

//Coeff N1, Coeff C37
c = coeff[1];
aic_writePage(page,36,(uint8_t)(c>>24));
aic_writePage(page,37,(uint8_t)(c>>16));
aic_writePage(page,38,(uint8_t)(c>>8));
//Coeff N2, Coeff C39
c = coeff[2];;
aic_writePage(page,40,(uint8_t)(c>>24));
aic_writePage(page,41,(uint8_t)(c>>16));
aic_writePage(page,42,(uint8_t)(c>>8));

}


+ 128
- 0
control_tlv320aic3206.h Ver fichero

/*
control_tlv320aic3206

Created: Brendan Flynn (http://www.flexvoltbiosensor.com/) for Tympan, Jan-Feb 2017
Modified: Chip Audette (https://openaudio.blogspot.com) for Tympan 2017-2018
Purpose: Control module for Texas Instruments TLV320AIC3206 compatible with Teensy Audio Library

License: MIT License. Use at your own risk.

Note that the TLV320AIC3206 has a reset that should be connected to microcontroller.
This code defaults to Teensy Pin 21, which was used on Tympan Rev C.
You can set the reset pin in the constructor
Example Usage for Teensy:
#include <Audio.h> //Teensy Audio Library
int AIC3206_RESET_PIN 21 //What pin is your AIC3206 reset pin connected to?
AudioControlTLV320AIC3206 audioHardware(AIC3206_RESET_PIN);
AudioInputI2S i2s_in; //Digital audio *from* the AIC.
AudioOutputI2S i2s_out; //Digital audio *to* the AIC.
AudioConnection patchCord1(i2s_in, 0, i2s_out, 0); //connect left input to left output
AudioConnection patchCord2(i2s_in, 1, i2s_out, 1); //connect right input to right output
void setup(void)
{
//begin the serial comms (for debugging)
Serial.begin(115200); delay(500);
Serial.println("AudioPassThru: Starting setup()...");

//allocate the dynamic memory for audio processing blocks
AudioMemory(10);

//Enable the TLV32AIC3206 to start the audio flowing!
audioHardware.enable(); // activate AIC

//Choose the desired input
audioHardware.inputSelect(AIC3206_INPUT_IN1); // use Input 1
//audioHardware.setMicBias(AIC3206_MIC_BIAS_2_5); // set mic bias to 2.5V
//audioHardware.setHPFonADC(20.0); // in the hardware, add a highpass filter at 20Hz to block DC

//Set the desired volume levels
audioHardware.volume_dB(0); // headphone amplifier. -63.6 to +24 dB in 0.5dB steps.
audioHardware.setInputGain_dB(10.0); // set input volume, 0-47.5dB in 0.5dB setps
}

void loop(void)
{
// Nothing to do
}
*/

#ifndef control_tlv320aic3206_h_
#define control_tlv320aic3206_h_

#include "TeensyAudioControl.h"
#include <Arduino.h>

//convenience names to use with inputSelect() to set whnch analog inputs to use
#define AIC3206_INPUT_IN1 1 //uses IN1
#define AIC3206_INPUT_IN2 2 //uses IN2 analog inputs
#define AIC3206_INPUT_IN3 3 //uses IN3 analog inputs
#define AIC3206_INPUT_IN3_MICBIAS 4 //uses IN3 analog inputs *and* enables mic bias

//convenience names to use with outputSelect()
#define AIC3206_OUTPUT_HEADPHONE_JACK_OUT 1
#define AIC3206_OUTPUT_LINE_OUT 2
#define AIC3206_OUTPUT_HEADPHONE_AND_LINE_OUT 3

//names to use with setMicBias() to set the amount of bias voltage to use
#define AIC3206_MIC_BIAS_OFF 0
#define AIC3206_MIC_BIAS_1_25 1
#define AIC3206_MIC_BIAS_1_7 2
#define AIC3206_MIC_BIAS_2_5 3
#define AIC3206_MIC_BIAS_VSUPPLY 4
#define AIC3206_DEFAULT_MIC_BIAS AIC3206_MIC_BIAS_2_5

#define BOTH_CHAN 0
#define LEFT_CHAN 1
#define RIGHT_CHAN 2

class AudioControlTLV320AIC3206: public TeensyAudioControl
{
public:
//GUI: inputs:0, outputs:0 //this line used for automatic generation of GUI node
AudioControlTLV320AIC3206(void) { debugToSerial = false; };
AudioControlTLV320AIC3206(bool _debugToSerial) { debugToSerial = _debugToSerial; };
AudioControlTLV320AIC3206(int _resetPin) { debugToSerial = false; resetPinAIC = _resetPin; }
AudioControlTLV320AIC3206(int _resetPin, bool _debugToSerial) { resetPinAIC = _resetPin; debugToSerial = _debugToSerial; };
bool enable(void);
bool disable(void);
bool outputSelect(int n);
bool volume(float n);
bool volume_dB(float n);
bool inputLevel(float n); //dummy to be compatible with Teensy Audio Library
bool inputSelect(int n);
bool setInputGain_dB(float n);
bool setMicBias(int n);
bool updateInputBasedOnMicDetect(int setting = TYMPAN_INPUT_JACK_AS_MIC);
bool enableMicDetect(bool);
int readMicDetect(void);
bool debugToSerial;
unsigned int aic_readPage(uint8_t page, uint8_t reg);
bool aic_writePage(uint8_t page, uint8_t reg, uint8_t val);
void setHPFonADC(bool enable, float cutoff_Hz, float fs_Hz);
float getHPCutoff_Hz(void) { return HP_cutoff_Hz; }
float getSampleRate_Hz(void) { return sample_rate_Hz; }
void setIIRCoeffOnADC(int chan, uint32_t *coeff);
bool enableAutoMuteDAC(bool, uint8_t);
private:
void aic_reset(void);
void aic_init(void);
void aic_initDAC(void);
void aic_initADC(void);

bool aic_writeAddress(uint16_t address, uint8_t val);
bool aic_goToPage(uint8_t page);
int prevMicDetVal = -1;
int resetPinAIC = 21; //AIC reset pin, Tympan Rev C
float HP_cutoff_Hz = 0.0f;
float sample_rate_Hz = 44100; //only used with HP_cutoff_Hz to design HP filter on ADC, if used
void setIIRCoeffOnADC_Left(uint32_t *coeff);
void setIIRCoeffOnADC_Right(uint32_t *coeff);
};


#endif

+ 1
- 0
keywords.txt Ver fichero

AudioControlAK4558 KEYWORD2 AudioControlAK4558 KEYWORD2
AudioControlCS4272 KEYWORD2 AudioControlCS4272 KEYWORD2
AudioControlCS42448 KEYWORD2 AudioControlCS42448 KEYWORD2
AudioControlTLV320AIC3206 KEYWORD2
AudioMemory KEYWORD2 AudioMemory KEYWORD2


AudioAnalyzeFFT256 KEYWORD2 AudioAnalyzeFFT256 KEYWORD2

Escribir Vista previa
Cargando…
Cancelar
Guardar