init486.c

Go to the documentation of this file.

/*!
 * @file
 * 
 * @brief Processor configuration routines to support ECE 486 
 * 
 * @author Don Hummels
 * 
 * @date Jan  2016
 */

/*
 * Contains all of the subroutines to configure various peripherals of the stm32L476,
 * such as RCC, GPIO Ports, DMAs, ADCs, DACs, etc.
 * 
 * Rewrite taken from the STM32F4xx libraries in Jan 2016
 * 
 * Aug 1, 2014: 
 *      Major Revision:
 *      Drop support for the microphone.  
 *      Add support for the STM32F429i-Discovery board
 *      Migrate from the "standard peripheral lib" to the newer "HAL" interface
 * 
 * Dec 31, 2014:
 *      Add UART support for debugging Output
 * 
 * Jan 5, 2015:
 *      Discarded stm32f4xx support.  This version supports the STM32L476-Discovery
 * 
 * Jan 2016 Major rewrite to port to the STM32L476G-Discovery board:
 *      All periferal assignments changed.  
 *      New DMA/Timer interface for the L4xx processors
 * 
 * Dec 2017 Modification to allow HSE Clock reference 
 *      
 * 
 */


#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "stm32l4xx_hal.h"
#include "stm32l476g_discovery.h"
#include "stm32l476g_discovery_glass_lcd.h"

#include "sample486.h"
#include "init486.h"
#include "err486.h"
#include "usart.h"
#include "opamp486.h"

/* Private functions ---------------------------------------------------------*/
static void blinkandwait(void);
static void ece_486_deinit(void);
static void SystemClock_Config_MSI(void);
static void SystemClock_Config_HSE(void);
static void init_dac(uint16_t fs, enum Num_Channels_Out chanout);
static void init_adc(uint16_t fs, enum Num_Channels_In chanin);
static void TIM4_Config(uint16_t fs);
static void config_digital_io(void);
static void config_pushbutton(void);
#ifdef TIM4_TO_PB6
 static void config_clkout(void);
#endif
static HAL_StatusTypeDef Hacked_HAL_DAC_DualStart_DMA(
  DAC_HandleTypeDef* hdac, 
  uint32_t* pData, 
  uint32_t Length);

static DAC_HandleTypeDef    DacHandle;
static ADC_HandleTypeDef    AdcHandle;
static ADC_HandleTypeDef    AdcHandle2;


/*
 * Actual Sample Rate
 */
static float Actual_Sampling_Frequency;

/*
 * Global Variables
 */
JOYState_TypeDef JoyState = JOY_NONE;   // Can be JOY_NONE, JOY_UP, JOY_DOWN, JOY_RIGHT, JOY_LEFT
__IO FlagStatus KeyPressed = RESET;

enum Num_Channels_Out Output_Configuration;
enum Num_Channels_In Input_Configuration;

/*
 * Basic wrapper function to initialize peripherals for ECE 486 labs
 * initialize() provided for backwards compatibility... uses the 
 * internal RC oscillator as the clock source.
 */
void initialize(uint16_t fs, 
                enum Num_Channels_In chanin, 
                enum Num_Channels_Out chanout)
{
  initialize_ece486(fs,chanin,chanout,MSI_INTERNAL_RC);
}

/*
 * Basic wrapper function to initialize peripherals for ECE 486 labs
 */
void initialize_ece486(uint16_t fs, 
                enum Num_Channels_In chanin, 
                enum Num_Channels_Out chanout,
                enum Clock_Reference clkref
                      )
{
  
  Output_Configuration = chanout;
  Input_Configuration = chanin;
  
  // Initialize the HAL library
  HAL_Init();
  
  // Shut down any dma/timer activity
  ece_486_deinit();

  // Set up required LED output pins
  BSP_LED_Init(ERROR_LED);
  BSP_LED_Init(NORMAL_LED);
  
  // Set up the digital i/o pin
  config_digital_io();
  
  // Configure the system clock
  if (clkref == MSI_INTERNAL_RC) {
      SystemClock_Config_MSI();
  } else if (clkref == HSE_EXTERNAL_8MHz) {
      SystemClock_Config_HSE();
  } else {
      flagerror(CLOCK_CONFIG_ERROR);
  }
  
  // Joystick Config
  // BSP_JOY_Init(JOY_MODE_EXTI);
  config_pushbutton();    // SEL (Center) Joystick input does not conflict with DAC/ADC
  
  // PB6 can be configured to show the sampling clock created by Timer4. 
  // (Commented out here to avoid a possible conflict with the I2C1 periferal, which is
  //  used by the CODEC on the discovery board)
#ifdef TIM4_TO_PB6
  config_clkout();
#endif
  
  // LCD Config
  BSP_LCD_GLASS_Init();
  
  // USART2 used to send printf() to the ST-Link serial port
  usart_init();
  

  // Rest until the user button is pressed to allow
  // st-flash to reprogram without errors.
  blinkandwait();       

  // Calculate the actual sampling rate, and save it for access later 
  // through getsamplingfrequency(). (80 MHz clock, divided by the
  // integer "fs" used to program the timers)
  Actual_Sampling_Frequency = 80000000.0f / ((float) fs);
  
  
  // request memory for the ADC and DAC DMA transfer buffers
  // (These integer buffers store the raw ADC and DAC samples.  The values
  //  are converted to float's before being handed to the user.)
  ADC_Input_Buffer = (uint32_t *)malloc(sizeof(uint32_t)*ADC_Buffer_Size);
  DAC_Output_Buffer = (uint32_t *)malloc(sizeof(uint32_t)*ADC_Buffer_Size);
  
  if (ADC_Input_Buffer==NULL || DAC_Output_Buffer==NULL ) {
    flagerror(MEMORY_ALLOCATION_ERROR);
    while(1);
  }
  
  // Error Handler
  initerror(chanout);
  
  // Timer 4 generates the sampling clocks for the ADCs and DACs
  TIM4_Config(fs); 
  
  // DAC Config, including DMA2 Channel 5 to transfer samples to the DACs
  init_dac(fs, chanout);
  
  // ADC Config, including DMA1 Channel 1 to transfer samples from the ADCs
  init_adc(fs, chanin);

}



/**
  * @brief  System Clock Configuration
  * 
  * Hummels Config to give 80 MHz SYSCLK, with PLL48M1CLK=48 MHz
  *         The system Clock is configured as follows :
  *            System Clock source            = PLL (MSI)
  *            SYSCLK(Hz)                     = 80000000
  *            HCLK(Hz)                       = 80000000
  *            AHB Prescaler                  = 1
  *            APB1 Prescaler                 = 1
  *            APB2 Prescaler                 = 1
  *            MSI Frequency(Hz)              = 16000000 (MSI Range=8) 
  *            PLL_M                          = 2
  *            PLL_N                          = 20
  *            PLL_R                          = 2 ( SYSCLK = PLLCLK = (16MHz)*N/M/R = 80 MHz )
  *            PLL_P                          = 7 (No reason for this...)
  *            PLL_Q                          = 5 ( PLL48M1CLK = (16MHz)(N/M/Q) = 32 MHz ?! )
  *            Flash Latency(WS)              = 4
  * 
  * HSE: Not assumed active (xtal not populated on STM32L476G-Discovery)
  * MSI: 16 MHz (multiple speed internal RC Oscillator, configured using Range=8)
  * HSI: 16 MHz (Fixed frequency high speed internal Oscillator)
  * LSI: 32.768 kHz (Low freq internal oscillator)
  *    ( MSI *N/M = 160 MHz )
  * SYSCLK: 80 MHz  (= 160/R)
  * HCLK (AHB Bus, Core, Memory, and DMA): 80 MHz (Max value)
  * PCLK1 (APB1 Periferals, some USARTs and Timers): 80 MHz (Max value)
  * PCLK2 (APB2 Periferals, some USARTs and Timers): 80 MHz (Max value)
  * 
  * (ALTERNATIVE???  Use the HSI as the reference oscillator.  Change N to 15.)
  * 
  * @param  None
  * @retval None
  */
void SystemClock_Config_MSI(void)
{
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  /* MSI is enabled after System reset, activate PLL with MSI as source */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_MSI;
  RCC_OscInitStruct.MSIState = RCC_MSI_ON;
  RCC_OscInitStruct.MSIClockRange = RCC_MSIRANGE_8;
  RCC_OscInitStruct.MSICalibrationValue = RCC_MSICALIBRATION_DEFAULT;
  
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_MSI;
  RCC_OscInitStruct.PLL.PLLM = 2;
  RCC_OscInitStruct.PLL.PLLN = 20; 
  RCC_OscInitStruct.PLL.PLLR = 2;  
  RCC_OscInitStruct.PLL.PLLP = 7;
  RCC_OscInitStruct.PLL.PLLQ = 5;
  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    /* Initialization Error */
    while(1);
  }
  
  /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2 
     clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;  
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;  
  if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    /* Initialization Error */
    while(1);
  }
}

/**
  * @brief  Hummels Config to give 80 MHz SYSCLK, with PLL48M1CLK=48 MHz
  *         The system Clock is configured as follows :
  *            System Clock source            = PLL (HSE)
  *            SYSCLK(Hz)                     = 80000000
  *            HCLK(Hz)                       = 80000000
  *            AHB Prescaler                  = 1
  *            APB1 Prescaler                 = 1
  *            APB2 Prescaler                 = 1
  *            HSE Frequency(Hz)              = 8000000 (8 MHz external reference expected)
  *            PLL_M                          = 1
  *            PLL_N                          = 20
  *            PLL_R                          = 2 ( SYSCLK = PLLCLK = (8MHz)*N/M/R = 80 MHz )
  *            PLL_P                          = 7 (No reason for this...)
  *            PLL_Q                          = 5 ( PLL48M1CLK = (16MHz)(N/M/Q) = 32 MHz !?! )
  *            Flash Latency(WS)              = 4
  *
  * HSE: Driven by 8 MHz ref clock (Requires jumper changes on STM32L476G-Discovery)
  * MSI: Not configured here
  * HSI: 16 MHz (Fixed frequency high speed internal Oscillator)
  * LSI: 32.768 kHz (Low freq internal oscillator)
  *    ( PLL Input = HSE*N/M = 160 MHz )
  * SYSCLK: 80 MHz  (= 160/R)
  * HCLK (AHB Bus, Core, Memory, and DMA): 80 MHz (Max value)
  * PCLK1 (APB1 Periferals, some USARTs and Timers): 80 MHz (Max value)
  * PCLK2 (APB2 Periferals, some USARTs and Timers): 80 MHz (Max value)
  * 
  * @retval None
  */
void SystemClock_Config_HSE(void)
{
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};

  /* Enable HSE Oscillator and activate PLL with HSE as source   */
  /* (Default MSI Oscillator enabled at system reset remains ON) */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 1;
  RCC_OscInitStruct.PLL.PLLN = 20;
  RCC_OscInitStruct.PLL.PLLR = 2;
  RCC_OscInitStruct.PLL.PLLP = 7;
  RCC_OscInitStruct.PLL.PLLQ = 5;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    /* Initialization Error */
    while(1);
  }

  /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
     clocks dividers */
  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    /* Initialization Error */
    while(1);
  }
}

static void ece_486_deinit(void)
{
  static DMA_HandleTypeDef  hdma;
  static TIM_HandleTypeDef htim;
  
  DacHandle.Instance = DAC;
  HAL_DAC_DeInit(&DacHandle);
  
  htim.Instance = TIM4;
  HAL_TIM_Base_DeInit(&htim);
  
  AdcHandle.Instance = ADC1;
  HAL_ADC_DeInit(&AdcHandle);
  AdcHandle2.Instance = ADC2;
  HAL_ADC_DeInit(&AdcHandle);
  
  hdma.Instance = DMA2_Channel5;
  HAL_DMA_DeInit(&hdma);
  hdma.Instance = DMA1_Channel1;
  HAL_DMA_DeInit(&hdma);


}

/**
 * @brief Configure a digital output pin
 * @param None
 * @retval None
 */
static void config_digital_io(void)
{
  GPIO_InitTypeDef  my_io_pin;
  
  DIGITAL_IO_CLK_ENABLE();
  my_io_pin.Pin = DIGITAL_IO_PIN;              // Pin 4
  my_io_pin.Mode = GPIO_MODE_OUTPUT_PP;    // Push/Pull digital output
  my_io_pin.Pull = GPIO_NOPULL;            // No pullup or pulldown resistor
  my_io_pin.Speed = GPIO_SPEED_FREQ_VERY_HIGH;       // LOW, MEDIUM, FAST, or HIGH
  HAL_GPIO_Init(DIGITAL_IO_PORT, &my_io_pin);
}

#ifdef TIM4_TO_PB6
/**
 * @brief Configure PB6 to show the sampling clock
 * @param None
 * @retval None
 */
static void config_clkout(void)
{
  GPIO_InitTypeDef  my_io_pin;
  
  __HAL_RCC_GPIOB_CLK_ENABLE();
  my_io_pin.Pin = GPIO_PIN_6;              // Pin 4
  my_io_pin.Mode = GPIO_MODE_AF_PP;    // Push/Pull digital output
  my_io_pin.Pull = GPIO_NOPULL;            // No pullup or pulldown resistor
  my_io_pin.Speed = GPIO_SPEED_FREQ_VERY_HIGH;       // LOW, MEDIUM, FAST, or HIGH
  my_io_pin.Alternate = GPIO_AF2_TIM4;
  HAL_GPIO_Init(DIGITAL_IO_PORT, &my_io_pin);
}
#endif

/**
 * @brief Configure PA6 (Joystic Center) generate an interrupt
 * @param None
 * @retval None
 */
static void config_pushbutton(void)
{

  GPIO_InitTypeDef  joy_center;

  __HAL_RCC_GPIOA_CLK_ENABLE();
  joy_center.Pin = GPIO_PIN_0;              // Pin 4
  joy_center.Mode = GPIO_MODE_IT_FALLING;    // Push/Pull digital output
  joy_center.Pull = GPIO_PULLDOWN;            // No pullup or pulldown resistor
  joy_center.Speed = GPIO_SPEED_FREQ_VERY_HIGH;       // LOW, MEDIUM, FAST, or HIGH
  HAL_GPIO_Init(GPIOA, &joy_center);
  HAL_NVIC_SetPriority( (IRQn_Type) EXTI0_IRQn, 0x0F, 0x00);
  HAL_NVIC_EnableIRQ((IRQn_Type) EXTI0_IRQn);
}
 


/**
  * @brief Wait for a button-press while blinking the LEDs
  * @param None
  * @retval None
  */
static void blinkandwait(void) {

  BSP_LED_Off(NORMAL_LED);
  BSP_LED_On(ERROR_LED);
  
  BSP_LCD_GLASS_DisplayString((uint8_t*) "ECE486");
  KeyPressed = RESET;           // Reset the button status
  while (KeyPressed == RESET) { // Keep blinking until button press
    BSP_LED_Toggle(NORMAL_LED);
    HAL_Delay(100);
    BSP_LED_Toggle(ERROR_LED);
    HAL_Delay(100);
  }
  
  BSP_LED_On(NORMAL_LED);
  BSP_LED_Off(ERROR_LED);
  KeyPressed=RESET;             // Reset the button status
  BSP_LCD_GLASS_DisplayString((uint8_t*) "RUN   ");
  HAL_Delay(300);
}

/*
 * Simple function to return the best guess at the actual sampling frequency.
 */ 
float getsamplingfrequency(void){
  return Actual_Sampling_Frequency;
}


/**********************************************************************************/
/*  ******** DAC Initialization Code (and associated DMAs, Timers, IO pins) ***** */
/**********************************************************************************/

/*
 * DAC Set-up
 *   Configure and enable the appropriate output gpio pins (analog outputs)
 *   Configure the DMA to transfer samples from the DAC output buffer to the DAC
 *   Turn on the DAC and DMA clocks
 *   Start the DAC and DMA
 */
static void  init_dac(uint16_t fs, enum Num_Channels_Out chanout) 
{
  static DAC_ChannelConfTypeDef DacConfig;
  
  DacHandle.Instance = DAC;
  
  /* 
   * DAC Channel 2...  Trigger with Timer 4 TRG0 Event
   * Note that HAL_DAC_Init() calls HAL_DAC_MspInit() (The MPU-specific initialization
   * routine).  This function must be re-defined  below in order to associate 
   * the correct DMA stream with the DAC.  Similarly, HAL_DAC_DeInit() calls
   * HAL_DAC_MspDeInit()... which we're on the hook to define.
   */
  if(HAL_DAC_Init(&DacHandle) != HAL_OK)  flagerror(DAC_CONFIG_ERROR);
 
  DacConfig.DAC_Trigger = DAC_TRIGGER_T4_TRGO;
  DacConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;  // Output Buffer Amp
  DacConfig.DAC_UserTrimming = DAC_TRIMMING_FACTORY;
  DacConfig.DAC_ConnectOnChipPeripheral = DAC_CHIPCONNECT_DISABLE;
  DacConfig.DAC_SampleAndHold = DAC_SAMPLEANDHOLD_DISABLE;
  
  if (chanout == MONO_OUT) {
    if(HAL_DAC_ConfigChannel(&DacHandle, &DacConfig, DAC_CHANNEL_2) != HAL_OK)
      flagerror(DAC_CONFIG_ERROR);
    
    if( HAL_DAC_Start_DMA(&DacHandle, 
                          DAC_CHANNEL_2, 
                          (uint32_t *)DAC_Output_Buffer, 
                          ADC_Buffer_Size, 
                          DAC_ALIGN_12B_L) 
        != HAL_OK) flagerror(DAC_CONFIG_ERROR); 

  } else if (chanout == STEREO_OUT) {
      
   // DAC Channel 2 is the same as the Mono case... Channel 2 drives PA5 directly
   if(HAL_DAC_ConfigChannel(&DacHandle, &DacConfig, DAC_CHANNEL_2) != HAL_OK)
     flagerror(DAC_CONFIG_ERROR);
   
   // DAC Channel 1 is directed to opamp1, which can drive PA3
   // (This is because PA4 is not extended to the connector on the discovery board,
   //  and PA3 is extended.  The opamp is used to get the dac stignal to PA3.)
   opamp_init();
   DacConfig.DAC_ConnectOnChipPeripheral = DAC_CHIPCONNECT_ENABLE;
   if(HAL_DAC_ConfigChannel(&DacHandle, &DacConfig, DAC_CHANNEL_1) != HAL_OK)
     flagerror(DAC_CONFIG_ERROR);
  
    /*
    * To start the DAC in dual-sample mode, use a hacked up version of 
    * HAL_DAC_Start_DMA()...  The HAL library does not seem to support the 
    * dual mode very well!
    */
   if( Hacked_HAL_DAC_DualStart_DMA(&DacHandle,
                          (uint32_t *)DAC_Output_Buffer, 
                          ADC_Buffer_Size) 
        != HAL_OK) flagerror(DAC_CONFIG_ERROR); 
 } else {
   flagerror(DAC_CONFIG_ERROR);
  }

}


/*
 * Hacked up version of HAL_DAC_START_DMA intended to support dual-sample mode
 * for the DAC.
 * 
 * Data is assumed left aligned for dual-sample mode.
 */
static HAL_StatusTypeDef Hacked_HAL_DAC_DualStart_DMA(
  DAC_HandleTypeDef* hdac, 
  uint32_t* pData, 
  uint32_t Length) 
{
  uint32_t tmpreg = 0;
  
  /* Process locked */
  __HAL_LOCK(hdac);
  
  /* Change DAC state */
  hdac->State = HAL_DAC_STATE_BUSY;

  /* Set the DMA transfer complete callback for channel2 */
  hdac->DMA_Handle2->XferCpltCallback = DAC_DMAConvCpltCh2;

  /* Set the DMA half transfer complete callback for channel2 */
  hdac->DMA_Handle2->XferHalfCpltCallback = DAC_DMAHalfConvCpltCh2;

  /* Set the DMA error callback for channel2 */
  hdac->DMA_Handle2->XferErrorCallback = DAC_DMAErrorCh2;

  /* Enable the selected DAC channel2 DMA request */
  hdac->Instance->CR |= DAC_CR_DMAEN2;

  tmpreg = (uint32_t)&hdac->Instance->DHR12LD;          // 12-bit left align, dual sample mode
  
  /* Enable the DMA Stream */
  HAL_DMA_Start_IT(hdac->DMA_Handle2, (uint32_t)pData, tmpreg, Length);
  
  /* Enable the both DACs */
  __HAL_DAC_ENABLE(hdac, DAC_CHANNEL_2);
  __HAL_DAC_ENABLE(hdac, DAC_CHANNEL_1);
 
  /* Process Unlocked */
  __HAL_UNLOCK(hdac);
  
  /* Return function status */
  return HAL_OK;
}

/*
 * MPU Specific DAC Initialization code
 * Set up DMA2, Channel 5 to transfer data to DAC2 based upon interrupt 
 * from DAC2  (DAC2 uses GPIO Pin PA5... Need the GPIOA Clock enabled)
 */
void HAL_DAC_MspInit(DAC_HandleTypeDef* hdac) {
  GPIO_InitTypeDef          gpio_dacpins;
  static DMA_HandleTypeDef  hdma;
 
  // Start required clocks...
  __HAL_RCC_DAC1_CLK_ENABLE();                  /* DAC Periph clock enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();                 /* Enable GPIO clock for PA5 */
  __HAL_RCC_DMA2_CLK_ENABLE();                  /* DMA2 clock enable */
  
  // Configure PA5 as the output for DAC Channel 2.     
  gpio_dacpins.Pin = GPIO_PIN_5;                
  gpio_dacpins.Mode = GPIO_MODE_ANALOG;         /* Analog output pin */
  gpio_dacpins.Pull = GPIO_NOPULL;              /* Don't activate pull up/down resistor */
  gpio_dacpins.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  HAL_GPIO_Init(GPIOA, &gpio_dacpins);
  
  // Initialize DMA2, Channel 5 for this DAC Channel 2 (DMA Request 3))
  hdma.Instance = DMA2_Channel5;
  hdma.Init.Request = DMA_REQUEST_3;
  hdma.Init.Direction = DMA_MEMORY_TO_PERIPH;
  hdma.Init.PeriphInc = DMA_PINC_DISABLE;
  hdma.Init.MemInc = DMA_MINC_ENABLE;
  hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
  hdma.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
  hdma.Init.Mode = DMA_CIRCULAR;
  hdma.Init.Priority = DMA_PRIORITY_HIGH;
  HAL_DMA_Init(&hdma);
    
  // Associate the initialized DMA handle to DAC channel 2 
  // (strange, multi-statement macro)
  __HAL_LINKDMA(hdac, DMA_Handle2, hdma);

  // Configure the NVIC for DMA 
  HAL_NVIC_SetPriority(DMA2_Channel5_IRQn, 1, 0);
  // Enabling the interrupt here will call ISR DMA1_Stream6_IRQHandler()
  // on buffer transfer half-complete and complete.
  // HAL_NVIC_EnableIRQ(DMA2_Channel5_IRQn);
  
  // Configure Interrupt for DAC Channel 2
  HAL_NVIC_SetPriority(TIM6_DAC_IRQn,3,0);
  HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
  
  
}
  
void HAL_DAC_MspDeInit(DAC_HandleTypeDef* hdac) {
  
  // Reset and release the DAC peripheral
  __HAL_RCC_DAC1_FORCE_RESET();
  __HAL_RCC_DAC1_RELEASE_RESET();

  
  // De-Initialize the DMA Stream 
  HAL_DMA_DeInit(hdac->DMA_Handle2);
    
  // Disable the NVIC for DMA
  HAL_NVIC_DisableIRQ(DMA2_Channel5_IRQn);
  HAL_NVIC_DisableIRQ(TIM6_DAC_IRQn);
}

/*
 * MPU Specific Timer initialization and de-initialization code
 * (called by HAL_TIM_Base_Init()
 */
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim) {
  if(htim->Instance == TIM4) {
    __HAL_RCC_TIM4_CLK_ENABLE();
  } else {
    
  }
}


void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim) {
  if(htim->Instance == TIM4) {
    __HAL_RCC_TIM4_FORCE_RESET();
    __HAL_RCC_TIM4_RELEASE_RESET();
  } else {
    
  }
}








/**********************************************************************************/
/*  ******** ADC Initialization Code (and associated DMAs, Timers, IO pins) ***** */
/**********************************************************************************/

/*
 * ADC Initialization
 * 
 * ADC1 is always started, with DMA1, Channel 1 transferring samples
 * to the input buffer.  ADC1 is triggered through Timer 4.
 * 
 * If chanin=STEREO_IN, ADC2 is also configured as a slave to ADC1 (no 
 * external trigger required).  The DMA configuration is changed to use
 * dual-sample mode so that it serves data from both ADCs
 */
static void  init_adc(uint16_t fs, enum Num_Channels_In chanin) 
{
  ADC_ChannelConfTypeDef sConfig;
  ADC_MultiModeTypeDef   mode;

  // ADC1 is configured the same, whether there's one or two channels... 
  // In 2-channel mode, The ADC1 clock is distributed to ADC2, which acts as the
  // slave.
  // ADC1 is triggered using Timer 4.
  // DMA1, Channel 1 is used to transfer data from the ADC to an internal buffer.
  AdcHandle.Instance = ADC1;
  
  AdcHandle.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2; 
  AdcHandle.Init.Resolution = ADC_RESOLUTION_12B;
  AdcHandle.Init.ScanConvMode = DISABLE;
  AdcHandle.Init.EOCSelection = ADC_EOC_SINGLE_CONV; 
  AdcHandle.Init.ContinuousConvMode = DISABLE;
  AdcHandle.Init.NbrOfConversion = 1;
  AdcHandle.Init.DiscontinuousConvMode = DISABLE;    
  AdcHandle.Init.NbrOfDiscConversion = 1;
  AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
  // The ADC_EXTERNALTRIG_T4_TRGO macro seems to be defined (in error) to 
  // specify CC4 envents instead of TRGO events. I'll use the low-level
  // values from the HAL library (should not be needed!)
  // AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIG_T4_TRGO;
  AdcHandle.Init.ExternalTrigConv = LL_ADC_REG_TRIG_EXT_TIM4_TRGO;
  AdcHandle.Init.DataAlign = ADC_DATAALIGN_LEFT;
  AdcHandle.Init.DMAContinuousRequests = ENABLE;
  AdcHandle.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
  AdcHandle.Init.OversamplingMode = DISABLE;
      
  if(HAL_ADC_Init(&AdcHandle) != HAL_OK) flagerror(ADC_CONFIG_ERROR);  
  if(HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_SINGLE_ENDED) != HAL_OK) flagerror(ADC_CONFIG_ERROR);  
    
  sConfig.Channel = ADC1_CHANNEL;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_92CYCLES_5;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
 
  if(HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) flagerror(ADC_CONFIG_ERROR);  
  
  if (chanin == MONO_IN) {
    // Start up ADC1 with the DMA, and we're done
    if(HAL_ADC_Start_DMA(&AdcHandle, (uint32_t *)ADC_Input_Buffer, ADC_Buffer_Size) != HAL_OK) {
      flagerror(ADC_CONFIG_ERROR); 
    }
    
  } else if (chanin == STEREO_IN) {
    // Two Analog Inputs...  ADC2 is the slave...  
    //   ADC2 gets the same configuration without the external trigger.
    //   (it's clocked as a slave to ADC1)
    AdcHandle2.Instance = ADC2;
    AdcHandle2.Init = AdcHandle.Init;   //  Copy the ADC1 Configuration
    AdcHandle2.Init.ExternalTrigConv = ADC_SOFTWARE_START;
        
    if(HAL_ADC_Init(&AdcHandle2) != HAL_OK) flagerror(ADC_CONFIG_ERROR);  
    
    sConfig.Channel = ADC2_CHANNEL;     // 
    
    if(HAL_ADC_ConfigChannel(&AdcHandle2, &sConfig) != HAL_OK)  flagerror(ADC_CONFIG_ERROR);  
    
    // Multimode Configuration (Common ADC configuration register... only call once
    // using either ADC handle)
    mode.Mode = ADC_DUALMODE_REGSIMULT;
    mode.DMAAccessMode = ADC_DMAACCESSMODE_12_10_BITS;
    mode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_5CYCLES; // Ignored? (Since not interleaved)
    if(HAL_ADCEx_MultiModeConfigChannel(&AdcHandle, &mode) != HAL_OK) flagerror(ADC_CONFIG_ERROR);
    
    // Normal start for ADC2 (Slave Channel)
    if(HAL_ADC_Start(&AdcHandle2) != HAL_OK) flagerror(ADC_CONFIG_ERROR);  
    
    // ADC1 gets the multi-mode start, which fires up the DMA. 
    if(HAL_ADCEx_MultiModeStart_DMA(&AdcHandle, (uint32_t *)ADC_Input_Buffer, ADC_Buffer_Size) != HAL_OK) {
      flagerror(ADC_CONFIG_ERROR); 
    }
  } 
}


static void TIM4_Config(uint16_t fs)
{
  static TIM_HandleTypeDef htim;
  TIM_MasterConfigTypeDef  sMasterConfig;
  
  htim.Instance = TIM4;
  
  /* Number of timer counts per ADC sample....  The timer 4 clock frequency is 
   * the APB1 Bus frequency: 80 MHz.  For example, To get 50 ksps, we're 
   * counting (50 MHz)/(50 ksps) = 1600 counts
   */
  htim.Init.Period = fs;          
  htim.Init.Prescaler = 0;       
  htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;    
  htim.Init.CounterMode = TIM_COUNTERMODE_UP; 
  HAL_TIM_Base_Init(&htim);

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  
  HAL_TIMEx_MasterConfigSynchronization(&htim, &sMasterConfig);
  
  /*##-2- Enable TIM peripheral counter ######################################*/
  HAL_TIM_Base_Start(&htim);
}

/*
 * MPU Specific ADC Initialization code.
 * For ADC1, initialize the DMA, and associated with the ADC.
 * For ADC2, don't bother with the DMA...  The ADC1 DMA will run in dual-sample
 * mode and transfer both the ADC1 and ADC2 samples
 * Set up DMA1, Channel1 to transfer the data triggered from ADC1 (Request 0)
 * Enable the half-transfer and full-transfer interrupts from the DMA
 */
void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc)
{
  GPIO_InitTypeDef          gpio_adcpins;
  static DMA_HandleTypeDef  hdma;
  
  __HAL_RCC_ADC_CLK_ENABLE();
  __HAL_RCC_ADC_CONFIG(RCC_ADCCLKSOURCE_SYSCLK);
    
  if (hadc->Instance == ADC2) {  /* Slave ADC... no DMA/Trigger required */
    /*
     * ADC2 has no associated DMA...  just activate the clocks, and enable the
     * appropriate GPIO output pins as analog I/O without pull-up or pull-down resistors
     */
    ADC2_GPIO_CLK_ENABLE();
    
    gpio_adcpins.Pin = ADC2_GPIO_PIN;
    gpio_adcpins.Mode = GPIO_MODE_ANALOG_ADC_CONTROL;   /* Analog output pin */
    gpio_adcpins.Pull = GPIO_NOPULL;            /* Don't activate pull up/down resistor */
    HAL_GPIO_Init(ADC2_GPIO_PORT, &gpio_adcpins);
  } else {                      /* Master ADC */
    /*
     * ADC1 needs clocks and gpio pins... but also has a DMA associated with it.
     * The DMA is started in dual-sample mode if two channels are used (so it 
     * simultaneously transfers the ADC2 samples.
     */
    ADC1_GPIO_CLK_ENABLE();
    __HAL_RCC_DMA1_CLK_ENABLE();
    
    gpio_adcpins.Pin = ADC1_GPIO_PIN;
    gpio_adcpins.Mode = GPIO_MODE_ANALOG_ADC_CONTROL;   /* Analog input pin */
    gpio_adcpins.Pull = GPIO_NOPULL;    
    HAL_GPIO_Init(ADC1_GPIO_PORT, &gpio_adcpins);
  
    // DMA1, Channel 1 serves the ADC1 Trigger
    hdma.Instance = DMA1_Channel1;
    hdma.Init.Request = DMA_REQUEST_0;
    hdma.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma.Init.MemInc = DMA_MINC_ENABLE;
    hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
    hdma.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
    hdma.Init.Mode = DMA_CIRCULAR;
    hdma.Init.Priority = DMA_PRIORITY_HIGH;

    HAL_DMA_Init(&hdma);
      
    /* Associate the initialized DMA handle to the the ADC handle */
    __HAL_LINKDMA(hadc, DMA_Handle, hdma);

    // Configure and enable the interrupts from the DMA
    // ISR is DMA1_Channel1_IRQHandler()
    HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);   
    HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
    
  }
  
  // Configure and enable the interrupts from the ADC1 & for ADC2
  // ( Both ADCs share the same isr on the STM32L4xx )
  // ISR is ADC1_2_IRQHandler()
  HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0);   
  HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
  
}

void HAL_ADC_MspDeInit(ADC_HandleTypeDef *hadc)
{
  __ADC_FORCE_RESET();
  __ADC_RELEASE_RESET();
  
  if(hadc->DMA_Handle != NULL) HAL_DMA_DeInit(hadc->DMA_Handle); 

  HAL_NVIC_DisableIRQ(DMA1_Channel1_IRQn);
  HAL_NVIC_DisableIRQ(ADC1_2_IRQn);
}





/*
 * ISR Routines
 */

void DMA2_Channel5_IRQHandler(void)
{
  HAL_DMA_IRQHandler(DacHandle.DMA_Handle2); 
}

void TIM6_DAC_IRQHandler(void)
{
  HAL_DAC_IRQHandler(&DacHandle);
}

void ADC1_2_IRQHandler(void)
{ 
    /*
     * Note that ADC1 and ADC2 share the same ISR
     */ 
    HAL_ADC_IRQHandler(&AdcHandle);
    HAL_ADC_IRQHandler(&AdcHandle2);
}

void DMA1_Channel1_IRQHandler (void)
{
  /*
   * The HAL DMA Handler routine examines the interrupt, and eventually 
   * calls HAL_ADC_ConvCpltCallback() or HAL_ADC_ConvHalfCpltCallback() 
   * as appropriate.
   * These callback routines by default do nothing... but are declared as 
   * __weak so they can be redefined below to do the right thing.
   */
  HAL_DMA_IRQHandler(AdcHandle.DMA_Handle);  
}


// This function handles SysTick Handler.
void SysTick_Handler(void)
{
  HAL_IncTick();
}



// Joystick presses should generate an EXTIx interrupt
void EXTI0_IRQHandler(void)
{
  HAL_GPIO_EXTI_IRQHandler(SEL_JOY_PIN);
}

void EXTI1_IRQHandler(void)
{
  HAL_GPIO_EXTI_IRQHandler(LEFT_JOY_PIN);
}

void EXTI2_IRQHandler(void)
{
  HAL_GPIO_EXTI_IRQHandler(RIGHT_JOY_PIN);
}

void EXTI3_IRQHandler(void)
{
  HAL_GPIO_EXTI_IRQHandler(UP_JOY_PIN);
}

void EXTI9_5_IRQHandler(void)
{
  HAL_GPIO_EXTI_IRQHandler(DOWN_JOY_PIN);
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
    
    // Check for Joystick press
    if ( GPIO_Pin & (DOWN_JOY_PIN | UP_JOY_PIN | RIGHT_JOY_PIN | LEFT_JOY_PIN | SEL_JOY_PIN) ){
        KeyPressed = SET;
        switch(GPIO_Pin) {
          case DOWN_JOY_PIN :
            JoyState = JOY_DOWN;
            break;
          case UP_JOY_PIN :
            JoyState = JOY_UP;
            break;
          case SEL_JOY_PIN :
            JoyState = JOY_SEL;
            break;
          case RIGHT_JOY_PIN :
            JoyState = JOY_RIGHT;
            break;
          case LEFT_JOY_PIN :
            JoyState = JOY_LEFT;
            break;
        }
    } else {
        // Not a joystick event...  what else generates exti interrupts??
    }
}