main.c

/**

  ******************************************************************************

  * File Name          : main.c

  * Description        : Main program body

  ******************************************************************************

  *

  * COPYRIGHT(c) 2016 STMicroelectronics

  *

  * 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 STMicroelectronics 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 HOLDER 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.

  *

  ******************************************************************************

  */

/* Includes ------------------------------------------------------------------*/

#include "stm32f1xx_hal.h"

/* USER CODE BEGIN Includes */

#include "pcm1774.h"

/* USER CODE END Includes */

/* Private variables ---------------------------------------------------------*/

I2C_HandleTypeDef hi2c1;

I2S_HandleTypeDef hi2s3;

/* USER CODE BEGIN PV */

/* Private variables ---------------------------------------------------------*/

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/

void SystemClock_Config(void);

static void MX_GPIO_Init(void);

static void MX_I2C1_Init(void);

static void MX_I2S3_Init(void);

/* USER CODE BEGIN PFP */

/* Private function prototypes -----------------------------------------------*/

/* USER CODE END PFP */

/* USER CODE BEGIN 0 */

uint16_t pcm_sound[32] = {

0x39,0xFB,0x35,0xFB,0xE2,0xF9,0xE5,0xF9,0xDF,0xFB,0xDE,0xFB,0xDA,0xFF,0xD9,0xFF,

0xEB,0x02,0xEE,0x02,0xF8,0x02,0xF3,0x02,0x33,0x00,0x38,0x00,0x07,0xFD,0x03,0xFD,

};

//! Low level function to send a byte to the PCM1774

//! @param address is the 8-bit address of register to write to

//! @param data is the data to write to register

void pcm1774_sendByte(unsigned char address, unsigned char data)

{

  uint8_t data2[2];

  data2[0] = address;

  data2[1] = data;

  HAL_I2C_Master_Transmit(&hi2c1, (uint16_t)0x46<<1, (uint8_t *)data2, 2, 100);

  data2[0] = 0;

  data2[1] = 0;

}

//! Low level function to read a byte from the PCM1774

//! @param address is the 8-bit address of register to read from

//! @returns the byte read from the register

unsigned char pcm1774_readByte(unsigned char address)

{

  uint8_t data;

  //return i2c_receive_byte(PCM_1774_ADDRESS, address);

  HAL_I2C_Master_Receive(&hi2c1, (uint16_t)address, (uint8_t *)data, 1, 100);

  return data;

}

//! @param  address Address to write to

//!  @param   andOr If 1, then byte will be ORed by value of byte, otherwise byte will be ANDed with value of byte

//! @param  byte The value to AND or OR the register value

//! This is used to retain existing data contents and and/or just specific bits

void pcm1774_bitMask(unsigned char address, unsigned char byte, char andOr)

{

  unsigned char data;

  if(andOr)

    data = pcm1774_readByte(address) | byte;

  else

    data = pcm1774_readByte(address) & (char)(~byte);

  pcm1774_sendByte(address, data);

}

char initialize_pcm1774(void)

{

  // Default powerup registers recommended by PCM1774 at page 13/49

  /*

  pcm1774_sendByte(0x40, 0x27);  // L-Channel analog output volume

  pcm1774_sendByte(0x41, 0x27);  // R-Channel analog output volume

  pcm1774_sendByte(0x44, 0x27);  // L-Channel digital output volume

  pcm1774_sendByte(0x45, 0x27);  // R-Channel digital output volume

  pcm1774_sendByte(0x46, 0x20);  // DAC Audio Interface

  pcm1774_sendByte(0x49, 0xE0);  // DAC and analog BIAS power-up

  pcm1774_sendByte(0x56, 0x01);  // Zero-cross detection enable

  pcm1774_sendByte(0x48, 0x03);  // Analog Mixer Power-up

  pcm1774_sendByte(0x58, 0x11);  // Analog mixer input SW2, SW5 select to feed Digital DAC signals to Audio Jack output

  pcm1774_sendByte(0x49, 0xEC);  // Headphone Amplifier Power-up

  pcm1774_sendByte(0x4A, 0x01);  // Vcom power up

  pcm1774_sendByte(0x52, 0x30);  // Analog front-end D2S, MCB, PG1, 2, 5, 6 power-up

  pcm1774_sendByte(0x57, 0x11);  // Analog input select -- (For FM Radio)

  pcm1774_sendByte(0x57, 0x00);  // Analog input select -- We don't want FM Radio's Analog Input by default.

  pcm1774_DigitalVolume(90, 90);  // Digital Volume

  pcm1774_OutputVolume(50, 50);  // 20% overall Output Volume

  */

  pcm1774_sendByte(0x40, 0x27);

  pcm1774_sendByte(0x41, 0x27);

  pcm1774_sendByte(0x44, 0x27);

  pcm1774_sendByte(0x45, 0x27);

  pcm1774_sendByte(0x46, 0x01);

  pcm1774_sendByte(0x49, 0xEC);

  pcm1774_sendByte(0x56, 0x01);

  pcm1774_sendByte(0x48, 0x03);

  pcm1774_sendByte(0x58, 0x11);

  pcm1774_sendByte(0x49, 0xEC);

  pcm1774_sendByte(0x4A, 0x01);

  pcm1774_sendByte(0x52, 0x30);

  pcm1774_sendByte(0x57, 0x11);

  pcm1774_OutputVolume(50, 50);

  return 1;

}

void pcm1774_Reset(void)

{

  volatile int i = 0;

  pcm1774_sendByte(PCM1774_SYSTEM_RESET_SAMPLING_CONTROL, (1<<7));

  //for(i=0; i<5000; i++);

  //initialize_pcm1774();

  pcm1774_LoadDefaultDigitalConfiguration();

}

void pcm1774_LoadDefaultDigitalConfiguration(void)

{

  initialize_pcm1774();

  pcm1774_PowerUpMixer(TRUE, TRUE);

  pcm1774_PowerUpAnalog(TRUE, TRUE);

  pcm1774_PowerUpGainAmplifierAnalog(TRUE, TRUE);

  //pcm1774_selectAnalogInput(FALSE, FALSE);

/*  

  // Direct left input to left output

  pcm1774_redirectAnalogInputToLeftOutput(FALSE, FALSE);

  // Direct right input to right output

  pcm1774_redirectAnalogInputToRightOutput(FALSE, FALSE);

*/

  pcm1774_gainAmplifierAnalogInput(4, 4);

  pcm1774_ConnectDigitalOutputs(1, 1);

  pcm1774_DigitalVolume(40, 40);  // Digital Volume at 80%

  pcm1774_OutputVolume(50, 50);  // 20% Output Volume

}

void pcm1774_OutputVolume(int volumeLeft, int volumeRight)

{

  // Scale 0-100 to 0-63

  volumeLeft = (190*volumeLeft)/300;

  volumeRight= (190*volumeRight)/300;

  pcm1774_sendByte(PCM1774_HPA_L, (0x3f &  volumeLeft));

  pcm1774_sendByte(PCM1774_HPA_R, (0x3f & volumeRight));

}

void pcm1774_ConnectDigitalOutputs(char leftChannel, char rightChannel)

{

  pcm1774_bitMask(PCM1774_ANALOG_MIXER_SWITCH, (1<<0), leftChannel);

  pcm1774_bitMask(PCM1774_ANALOG_MIXER_SWITCH, (1<<4), rightChannel);

}

void pcm1774_DigitalVolume(int volumeLeft, int volumeRight)

{

  // Scale 0-100 to 0-63

  volumeLeft = (190*volumeLeft)/300;

  volumeRight= (190*volumeRight)/300;

  pcm1774_sendByte(PCM1774_DAC_AND_SOFT_MUTE_L, (0x3f &  volumeLeft));

  pcm1774_sendByte(PCM1774_DAC_AND_SOFT_MUTE_R, (0x3f & volumeRight));

}

void pcm1774_DigitalDeEmphasisFilter(char filter)

{

  // Filter should be:

  // 00:  OFF

  // 01:  32Khz

  // 10:  44.1Khz

  // 11:  48Khz

  // Clear old filter first

  pcm1774_bitMask(PCM1774_DE_EMPHASIS_AUDIO_INTERFACE, 0xC0, 0);

  // set the bits defined by filter to 1

  pcm1774_bitMask(PCM1774_DE_EMPHASIS_AUDIO_INTERFACE, (filter<<6), 1);

}

void pcm1774_DigitalInterfaceSelection(char selection)

{

  // selection should be:

  // 00: I2S Format

  // 01: Right-justified format

  // 10: left-justified format

  // 11: DSP Format

  // Clear old filter first

  pcm1774_bitMask(PCM1774_DE_EMPHASIS_AUDIO_INTERFACE, 0x30, 0);

  // set the bits defined by filter to 1

  pcm1774_bitMask(PCM1774_DE_EMPHASIS_AUDIO_INTERFACE, ((selection&0x03)<<4), 1);

}

void pcm1774_DigitalGainControl(char control)

{

  // control should be:

  // 00: 0db

  // 01: 6db

  // 10: 12db

  // 11: 18db

  // Clear old filter first

  pcm1774_bitMask(PCM1774_DE_EMPHASIS_AUDIO_INTERFACE, 0x0C, 0);

  // set the bits defined by filter to 1

  pcm1774_bitMask(PCM1774_DE_EMPHASIS_AUDIO_INTERFACE, ((control&0x03)<<2), 1);

}

void pcm1774_DigitalOversamplingControl(char control)

{

  pcm1774_bitMask(PCM1774_DE_EMPHASIS_AUDIO_INTERFACE, 0x01, control);

}

void pcm1774_PowerUpMixer(char powerLeft, char powerRight)

{

  pcm1774_bitMask(PCM1774_ANALOG_MIXER_POWER_UP_DOWN, (1<<0), powerLeft);

  pcm1774_bitMask(PCM1774_ANALOG_MIXER_POWER_UP_DOWN, (1<<1), powerRight);

}

void pcm1774_PowerUpAnalogBiasControl(char power)

{

  pcm1774_bitMask(PCM1774_DAC_HPA_POWER_UP_DOWN, (1<<7), power);

}

void pcm1774_PowerUpDAC(char powerLeft, char powerRight)

{

  pcm1774_bitMask(PCM1774_DAC_HPA_POWER_UP_DOWN, (1<<5), powerLeft);

  pcm1774_bitMask(PCM1774_DAC_HPA_POWER_UP_DOWN, (1<<6), powerRight);

}

void pcm1774_PowerUpAnalog(char powerLeft, char powerRight)

{

  pcm1774_bitMask(PCM1774_DAC_HPA_POWER_UP_DOWN, (1<<2), powerLeft);

  pcm1774_bitMask(PCM1774_DAC_HPA_POWER_UP_DOWN, (1<<3), powerRight);

}

void pcm1774_LineOutputConfiguration(char config)

{

  char stereo = 0x00;

  char monaural = 0x04;

  char differential = 0x08;

  pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0x0C, 0);

  switch(config)

  {

    case 1:  pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0xC0, monaural);  break;

    case 2:  pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0xC0, differential); break;

    case 0:

    default:

      pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0xC0, stereo);

  }

}

void pcm1774_PowerUpVcom(char power)

{

  pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0x01, power);

}

void pcm1774_setShortCircuitProtectionLeft(char protection)

{

  // 0 is to enable protection

  if(protection)  pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0x04, 0);

  else      pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0x04, 1);

}

void pcm1774_setShortCircuitProtectionRight(char protection)

{

  // 0 is to enable protection

  if(protection)  pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0x08, 0);

  else      pcm1774_bitMask(PCM1774_ANALOG_OUTPUT_CONFIG_SELECT, 0x08, 1);

}

char pcm1774_readShortCircuitStatusLeft(void)

{

  // 0 means short circuit detected

  return (!(pcm1774_readByte(PCM1774_SHUTDOWN_STATUS_READBACK) & 0x04));

}

char pcm1774_readShortCircuitStatusRight(void)

{

  // 0 means short circuit detected

  return (!(pcm1774_readByte(PCM1774_SHUTDOWN_STATUS_READBACK) & 0x08));

}

void pcm1774_PowerUpGainAmplifierAnalog(char powerLeft, char powerRight)

{

  pcm1774_bitMask(PCM1774_PG_1_2_5_6_POWER_UP_DOWN, (1<<4), powerLeft);

  pcm1774_bitMask(PCM1774_PG_1_2_5_6_POWER_UP_DOWN, (1<<5), powerRight);

}

void pcm1774_selectAnalogInput(char selectLeft, char selectRight)

{

  pcm1774_bitMask(PCM1774_ANALOG_INPUT_SELECT, (1<<0), selectLeft);  

  pcm1774_bitMask(PCM1774_ANALOG_INPUT_SELECT, (1<<4), selectRight);

}

void pcm1774_gainAmplifierAnalogInput(char leftGain, char rightGain)

{

  /* leftGain and rightGain are 3-bit values as follows:

  0 –21 dB (default)

  1 –18 dB

  2 –15 dB

  3 –12 dB

  4 –9 dB

  5 –6 dB

  6 –3 dB

  7 –0 dB

  */

  leftGain &= 0x07;

  rightGain &= 0x07;

  pcm1774_bitMask(PCM1774_ANALOG_TO_ANALOG_PATH_GAIN, 0x77, 0);

  pcm1774_bitMask(PCM1774_ANALOG_TO_ANALOG_PATH_GAIN, ((rightGain<<4)|leftGain), 1);

}

void pcm1774_redirectAnalogInputToLeftOutput(char left, char right)

{

  char bitmask;

  bitmask = (1 << 1) | (1 << 2);

  pcm1774_bitMask(PCM1774_ANALOG_MIXER_SWITCH, bitmask, 0);

  bitmask = (left << 1) | (right << 2);

  pcm1774_bitMask(PCM1774_ANALOG_MIXER_SWITCH, bitmask, 1);

}

void pcm1774_redirectAnalogInputToRightOutput(char left, char right)

{

  char bitmask;

  bitmask = (1 << 6) | (1 << 5);

  pcm1774_bitMask(PCM1774_ANALOG_MIXER_SWITCH, bitmask, 0);

  bitmask = (left << 6) | (right << 5);

  pcm1774_bitMask(PCM1774_ANALOG_MIXER_SWITCH, bitmask, 1);

}

static char pcm1774_getMappedLevel(int level)

{

          // -12,  -11,  -10,   -9,   -8,   -7,   -6,   -5,   -4,   -3,   -2,   -1

  char table[] = { 0x9B, 0x9A, 0x99, 0x98, 0x97, 0x96, 0x95, 0x94, 0x93, 0x92, 0x91, 0x90,

            0x80, // 0

           //   1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12

           0x8E, 0x8D, 0x8C, 0x8B, 0x8A, 0x89, 0x88, 0x87, 0x86, 0x85, 0x84, 0x83

          };

  if(level < -12 || level > 12)

    level = 0;

  level += 12;  // map level to the table

  return table[level];

}

void pcm1774_bassBoost(signed char level)

{

  pcm1774_sendByte(PCM1774_BASS_BOOST, pcm1774_getMappedLevel(level));

}

void pcm1774_middleBoost(signed char level)

{

  pcm1774_sendByte(PCM1774_MIDDLE_BOOST, pcm1774_getMappedLevel(level));

}

void pcm1774_trebleBoost(signed char level)

{

  pcm1774_sendByte(PCM1774_TREBLE_BOOST, pcm1774_getMappedLevel(level));

}

void pcm1774_3dSoundEffect(char narrow_or_wide, char level)

{

  // If not narrow, then set the bit for wide

  char wide = 0;

  if(!narrow_or_wide) wide = 0x10;

  if(level > 10) level = 10;

  if(level==0)  pcm1774_sendByte(PCM1774_SOUND_EFFECT_SOURCE_3D_SOUND, 0);

  else      pcm1774_bitMask(PCM1774_SOUND_EFFECT_SOURCE_3D_SOUND, (level|0x40|wide), 1);

}

/* USER CODE END 0 */

int main(void)

{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */

  HAL_Init();

  /* Configure the system clock */

  SystemClock_Config();

  /* Initialize all configured peripherals */

  MX_GPIO_Init();

  MX_I2C1_Init();

  MX_I2S3_Init();

  /* USER CODE BEGIN 2 */

  //SysTick_Init();

  //pcm1774_Reset();

  char dac_init = initialize_pcm1774();

  /* USER CODE END 2 */

  /* Infinite loop */

  /* USER CODE BEGIN WHILE */

  while (1)

  {

    HAL_I2S_Transmit(&hi2s3,pcm_sound,32,1000);

  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */

  }

  /* USER CODE END 3 */

}

/** System Clock Configuration

*/

void SystemClock_Config(void)

{

  RCC_OscInitTypeDef RCC_OscInitStruct;

  RCC_ClkInitTypeDef RCC_ClkInitStruct;

  RCC_PeriphCLKInitTypeDef PeriphClkInit;

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;

  RCC_OscInitStruct.HSEState = RCC_HSE_ON;

  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;

  RCC_OscInitStruct.Prediv1Source = RCC_PREDIV1_SOURCE_HSE;

  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;

  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;

  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;

  RCC_OscInitStruct.PLL2.PLL2State = RCC_PLL_NONE;

  RCC_OscInitStruct.PLL2.HSEPrediv2Value = RCC_HSE_PREDIV2_DIV2;

  HAL_RCC_OscConfig(&RCC_OscInitStruct);

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1;

  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;

  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2);

  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_I2S3;

  PeriphClkInit.I2s3ClockSelection = RCC_I2S3CLKSOURCE_PLLI2S_VCO;

  PeriphClkInit.PLLI2S.PLLI2SMUL = RCC_PLLI2S_MUL16;

  PeriphClkInit.PLLI2S.HSEPrediv2Value = RCC_HSE_PREDIV2_DIV2;

  HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);

  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  __HAL_RCC_PLLI2S_ENABLE();

  /* SysTick_IRQn interrupt configuration */

  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);

}

/* I2C1 init function */

void MX_I2C1_Init(void)

{

  hi2c1.Instance = I2C1;

  hi2c1.Init.ClockSpeed = 100000;

  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_16_9;

  hi2c1.Init.OwnAddress1 = 0;

  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;

  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;

  hi2c1.Init.OwnAddress2 = 0;

  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;

  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;

  HAL_I2C_Init(&hi2c1);

}

/* I2S3 init function */

void MX_I2S3_Init(void)

{

  hi2s3.Instance = SPI3;

  hi2s3.Init.Mode = I2S_MODE_MASTER_TX;

  hi2s3.Init.Standard = I2S_STANDARD_LSB;

  hi2s3.Init.DataFormat = I2S_DATAFORMAT_16B;

  hi2s3.Init.MCLKOutput = I2S_MCLKOUTPUT_ENABLE;

  hi2s3.Init.AudioFreq = I2S_AUDIOFREQ_32K;

  hi2s3.Init.CPOL = I2S_CPOL_LOW;

  HAL_I2S_Init(&hi2s3);

}

/** Configure pins as 

        * Analog 

        * Input 

        * Output

        * EVENT_OUT

        * EXTI

*/

void MX_GPIO_Init(void)

{

  /* GPIO Ports Clock Enable */

  __HAL_RCC_GPIOD_CLK_ENABLE();

  __HAL_RCC_GPIOA_CLK_ENABLE();

  __HAL_RCC_GPIOC_CLK_ENABLE();

  __HAL_RCC_GPIOB_CLK_ENABLE();

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

#ifdef USE_FULL_ASSERT

/**

   * @brief Reports the name of the source file and the source line number

   * where the assert_param error has occurred.

   * @param file: pointer to the source file name

   * @param line: assert_param error line source number

   * @retval None

   */

void assert_failed(uint8_t* file, uint32_t line)

{

  /* USER CODE BEGIN 6 */

  /* User can add his own implementation to report the file name and line number,

    ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* USER CODE END 6 */

}

#endif

/**

  * @}

  */ 

/**

  * @}

*/ 

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/