EFM32 DMA/PRS例程

/**************************************************************************//**
 * @file
 * @brief High Frequaency ADC Sampling using Timer, DMA and PRS
 * @author Energy Micro AS
 * @version 1.0.0
 ******************************************************************************
 * @section License
 * <b>(C) Copyright 2014 Silicon Labs, http://www.silabs.com</b>
 *******************************************************************************
 *
 * This file is licensed under the Silicon Labs Software License Agreement. See  
 * "http://developer.silabs.com/legal/version/v11/Silicon_Labs_Software_License_Agreement.txt"   
 * for details. Before using this software for any purpose, you must agree to the  
 * terms of that agreement.
 *
 ******************************************************************************/
 
#include <stdlib.h>
#include <stdio.h>
#include "efm32.h"
#include "em_chip.h"
#include "em_emu.h"
#include "em_cmu.h"
#include "em_adc.h"
#include "em_lcd.h"
#include "em_prs.h"
#include "em_dma.h"
#include "em_timer.h"
 
/* Drivers */
#include "segmentlcd.h"
 
/* Support functions */
#include "support.h"
 
/* Defines */
#define ADC_SAMPLE_RATE       100000
#define HFPER                 14000000
#define TIMER_TOP             (HFPER / ADC_SAMPLE_RATE)
#define BUFFER_SIZE_SHIFT     9
#define BUFFER_SIZE           (1 << BUFFER_SIZE_SHIFT)
#define BUFFERS_PER_SECOND    (ADC_SAMPLE_RATE / BUFFER_SIZE)
#define DMA_CHANNEL           0
#define PRS_CHANNEL           0
 
/* Uncomment to use Fahrenheit instead of Celsius */
/* #define FAHRENHEIT */
 
/* DMA control block, must be aligned to 256. */
#if defined (__ICCARM__)
#pragma data_alignment=256
DMA_DESCRIPTOR_TypeDef dmaControlBlock[DMA_CHAN_COUNT * 2];
#elif defined (__CC_ARM)
DMA_DESCRIPTOR_TypeDef dmaControlBlock[DMA_CHAN_COUNT * 2] __attribute__ ((aligned(256)));
#elif defined (__GNUC__)
DMA_DESCRIPTOR_TypeDef dmaControlBlock[DMA_CHAN_COUNT * 2] __attribute__ ((aligned(256)));
#else
#error Undefined toolkit, need to define alignment
#endif
 
/* Variables */
uint16_t              ramBufferA[BUFFER_SIZE];
uint16_t              ramBufferB[BUFFER_SIZE];
bool                  usingRamBufferA;
static DMA_CB_TypeDef cbInData;
char                  string[8];
 
/**************************************************************************//**
 * @brief ADC0 interrupt handler. Simply clears interrupt flag.
 *****************************************************************************/
static void preampDMAInCb(unsigned int channel, bool primary, void *user)
{
  (void) user; /* Unused parameter */
 
  /* Refresh DMA */
  DMA_RefreshPingPong(channel,     /* channel */
                      primary,         /* descriptor to update */
                      false,           /* do not use burst */
                      NULL,            /* do not change destination */
                      NULL,            /* do not change source */
                      BUFFER_SIZE - 1, /* number of transfers */
                      false);          /* do not stop after completing this cycle */
 
  /* Switch buffer */
  usingRamBufferA = primary;
 
  /* Set software interrupt */
  SCB->ICSR = SCB_ICSR_PENDSVSET_Msk;
}
 
/**************************************************************************//**
 * @brief Software interrupt handler
 * Computes and displays the average temperature
 *****************************************************************************/
void PendSV_Handler(void)
{
  static bool     enableAntenna = false;
  static uint32_t display_count = 0;
  int32_t         temp;
  uint32_t        i;
 
  uint32_t        avg = 0;
  /* Show Celsius on alphanumeric part of display */
  if (usingRamBufferA)
  {
    for (i = 0; i < BUFFER_SIZE; i++)
    {
      avg += ramBufferA[i];
    }
  }
  else
  {
    for (i = 0; i < BUFFER_SIZE; i++)
    {
      avg += ramBufferB[i];
    }
  }
 
  /* The buffer size is a power of two, so rightshift can be used instead of
   * division */
  avg = avg >> BUFFER_SIZE_SHIFT;
   
#if defined(_EFM32_GIANT_FAMILY)
  avg += 112;
#endif
 
  /* Show Celsius or Fahrenheit on alphanumeric part of display */
#ifndef FAHRENHEIT
  temp = (int32_t)(convertToCelsius(avg) * 10);
  snprintf(string, 8, "%2d,%1d%%C", (temp / 10), abs(temp) % 10);
#else
  temp = (int32_t)(convertToFahrenheit(avg) * 10);
  snprintf(string, 8, "%2d,%1d%%F", (temp / 10), abs(temp) % 10);
#endif
 
  /* Display result on LCD once a second */
  if (++display_count == BUFFERS_PER_SECOND)
  {
    display_count = 0;
 
    SegmentLCD_Write(string);
 
    /* Indicate update */
    SegmentLCD_Symbol(LCD_SYMBOL_ANT, enableAntenna);
    enableAntenna = !enableAntenna;
  }
}
 
/**************************************************************************//**
 * @brief Configure ADC with DMA
 *****************************************************************************/
static void adc_setup(void)
{
  /* Configure ADC single conversion */
  CMU_ClockEnable(cmuClock_ADC0, true);
 
  ADC_Init_TypeDef       init       = ADC_INIT_DEFAULT;
  ADC_InitSingle_TypeDef singleInit = ADC_INITSINGLE_DEFAULT;
 
  init.timebase   = ADC_TimebaseCalc(0);
  init.warmUpMode = adcWarmupKeepADCWarm;
 
  init.prescale = ADC_PrescaleCalc(7000000, 0);
  ADC_Init(ADC0, &init);
 
  singleInit.reference  = adcRef1V25;
  singleInit.input      = adcSingleInpTemp;
  singleInit.resolution = adcRes12Bit;
  singleInit.prsSel     = adcPRSSELCh0;
  singleInit.prsEnable  = true;
 
  singleInit.acqTime = adcAcqTime32;
 
  ADC_InitSingle(ADC0, &singleInit);
 
  /* Configure DMA usage by ADC */
  CMU_ClockEnable(cmuClock_DMA, true);
 
  DMA_CfgDescr_TypeDef   descrCfg;
  DMA_CfgChannel_TypeDef chnlCfg;
 
  cbInData.cbFunc  = preampDMAInCb;
  cbInData.userPtr = NULL;
 
  chnlCfg.highPri   = true;
  chnlCfg.enableInt = true;
  chnlCfg.select    = DMAREQ_ADC0_SINGLE;
  chnlCfg.cb        = &cbInData;
  DMA_CfgChannel(0, &chnlCfg);
 
  descrCfg.dstInc  = dmaDataInc2;
  descrCfg.srcInc  = dmaDataIncNone;
  descrCfg.size    = dmaDataSize2;
  descrCfg.arbRate = dmaArbitrate1;
  descrCfg.hprot   = 0;
  DMA_CfgDescr(DMA_CHANNEL, true, &descrCfg);
  DMA_CfgDescr(DMA_CHANNEL, false, &descrCfg);
 
  DMA_ActivatePingPong(DMA_CHANNEL,                              /* channel */
                       false,                                    /* do not use burst */
                       (void *) &ramBufferA,                     /* primary destination */
                       (void *)((uint32_t) &(ADC0->SINGLEDATA)), /* primary source */
                       BUFFER_SIZE - 1,                          /* primary number of transfers */
                       (void *) &ramBufferB,                     /*altenate deststination */
                       (void *)((uint32_t) &(ADC0->SINGLEDATA)), /* alternate source */
                       BUFFER_SIZE - 1);                         /* alternate number of transfers */
 
  /* Select ramBufferA as current */
  usingRamBufferA = true;
}
 
/**************************************************************************//**
 * @brief Configure PRS
 *****************************************************************************/
static void prs_setup(unsigned int prsChannel)
{
  PRS_LevelSet(0, 1 << (prsChannel + _PRS_SWLEVEL_CH0LEVEL_SHIFT));
  PRS_SourceSignalSet(prsChannel,
                      PRS_CH_CTRL_SOURCESEL_TIMER0,
                      PRS_CH_CTRL_SIGSEL_TIMER0OF,
                      prsEdgePos);
}
 
 
/**************************************************************************//**
 * @brief Configure Timer
 *****************************************************************************/
void timer_setup(void)
{
  /* Enable clock for TIMER0 module */
  CMU_ClockEnable(cmuClock_TIMER0, true);
 
  CMU_ClockEnable(cmuClock_PRS, true);
 
  /* Select TIMER0 parameters */
  TIMER_Init_TypeDef timerInit =
  {
    .enable     = true,
    .debugRun   = true,
    .prescale   = timerPrescale1,
    .clkSel     = timerClkSelHFPerClk,
    .fallAction = timerInputActionNone,
    .riseAction = timerInputActionNone,
    .mode       = timerModeUp,
    .dmaClrAct  = false,
    .quadModeX4 = false,
    .oneShot    = false,
    .sync       = false,
  };
 
  /* Set TIMER Top value */
  TIMER_TopSet(TIMER0, TIMER_TOP);
 
  /* Configure TIMER */
  TIMER_Init(TIMER0, &timerInit);
}
 
/**************************************************************************//**
 * @brief SWO Setup
 * Enables code view in energyAware Profiler
 *****************************************************************************/
void setupSWO(void)
{
  uint32_t *dwt_ctrl = (uint32_t *) 0xE0001000;
  uint32_t *tpiu_prescaler = (uint32_t *) 0xE0040010;
  uint32_t *tpiu_protocol = (uint32_t *) 0xE00400F0;
 
  CMU->HFPERCLKEN0 |= CMU_HFPERCLKEN0_GPIO;
  /* Enable Serial wire output pin */
  GPIO->ROUTE |= GPIO_ROUTE_SWOPEN;
#if defined(_EFM32_GIANT_FAMILY)
  /* Set location 0 */
  GPIO->ROUTE = (GPIO->ROUTE & ~(_GPIO_ROUTE_SWLOCATION_MASK)) | GPIO_ROUTE_SWLOCATION_LOC0;
 
  /* Enable output on pin - GPIO Port F, Pin 2 */
  GPIO->P[5].MODEL &= ~(_GPIO_P_MODEL_MODE2_MASK);
  GPIO->P[5].MODEL |= GPIO_P_MODEL_MODE2_PUSHPULL;
#else
  /* Set location 1 */
  GPIO->ROUTE = (GPIO->ROUTE & ~(_GPIO_ROUTE_SWLOCATION_MASK)) | GPIO_ROUTE_SWLOCATION_LOC1;
  /* Enable output on pin */
  GPIO->P[2].MODEH &= ~(_GPIO_P_MODEH_MODE15_MASK);
  GPIO->P[2].MODEH |= GPIO_P_MODEH_MODE15_PUSHPULL;
#endif
  /* Enable debug clock AUXHFRCO */
  CMU->OSCENCMD = CMU_OSCENCMD_AUXHFRCOEN;
 
  while(!(CMU->STATUS & CMU_STATUS_AUXHFRCORDY));
 
  /* Enable trace in core debug */
  CoreDebug->DHCSR |= 1;
  CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
 
  /* Enable PC and IRQ sampling output */
  *dwt_ctrl = 0x400113FF;
  /* Set TPIU prescaler to 16. */
  *tpiu_prescaler = 0xf;
  /* Set protocol to NRZ */
  *tpiu_protocol = 2;
  /* Unlock ITM and output data */
  ITM->LAR = 0xC5ACCE55;
  ITM->TCR = 0x10009;
}
 
 
/******************************************************************************
 * @brief  Main function
 *****************************************************************************/
int main(void)
{
  /* Initialize chip */
  CHIP_Init();
   
  /* Enable code view */
  setupSWO();
 
  SegmentLCD_Init(false);
 
  /* Enable clocks required */
  CMU_ClockEnable(cmuClock_HFPER, true);
 
 
  DMA_Init_TypeDef dmaInit;
  dmaInit.hprot        = 0;
  dmaInit.controlBlock = dmaControlBlock;
  DMA_Init(&dmaInit);
 
  /* Configure Timer, PRS and ADC */
  timer_setup();
  prs_setup(PRS_CHANNEL);
  adc_setup();
 
  /* Enable software interrupt */
  NVIC_EnableIRQ(PendSV_IRQn);
 
  /* Set priorities */
  NVIC_SetPriority(DMA_IRQn, 0);                              /* Highest priority */
  NVIC_SetPriority(PendSV_IRQn, (1 << __NVIC_PRIO_BITS) - 1); /* Lowest priority */
 
  /* Stay in this loop forever */
  while (1)
  {
    EMU_EnterEM1();
  }
}