C++ pmc_enable_periph_clk函数代码示例

/**
 * \brief Application entry point for TWIHS Slave example.
 *
 * \return Unused (ANSI-C compatibility).
 */
int main(void)
{
	uint32_t i;

	/* Initialize the SAM system */
	sysclk_init();

	/* Initialize the board */
	board_init();

	/* Initialize the console UART */
	configure_console();

	/* Output example information */
	puts(STRING_HEADER);

	/* Enable the peripheral clock for TWIHS */
	pmc_enable_periph_clk(BOARD_ID_TWIHS_SLAVE);

	for (i = 0; i < MEMORY_SIZE; i++) {
		emulate_driver.uc_memory[i] = 0;
	}
	emulate_driver.us_offset_memory = 0;
	emulate_driver.uc_acquire_address = 0;
	emulate_driver.us_page_address = 0;

	/* Configure TWIHS as slave */
	puts("-I- Configuring the TWIHS in slave mode\n\r");
	twihs_slave_init(BOARD_BASE_TWIHS_SLAVE, SLAVE_ADDRESS);

	/* Clear receipt buffer */
	twihs_read_byte(BOARD_BASE_TWIHS_SLAVE);

	/* Configure TWIHS interrupts */
	NVIC_DisableIRQ(BOARD_TWIHS_IRQn);
	NVIC_ClearPendingIRQ(BOARD_TWIHS_IRQn);
	NVIC_SetPriority(BOARD_TWIHS_IRQn, 0);
	NVIC_EnableIRQ(BOARD_TWIHS_IRQn);
	twihs_enable_interrupt(BOARD_BASE_TWIHS_SLAVE, TWIHS_SR_SVACC);

	while (1) {
	}
}

void timer_init()  {
	// assign a clock signal
	pmc_enable_periph_clk(ID_TC0);
	
	// divide master clock by 32 and enable waveform mode in the channel mode register
	TC_CMR0_CH0 = CMR_DIV_32 + CMR_WAVE_EN + CMR_WAVE_SEL;
	
	// load the RC register with the value to interrupt every 1 ms
	TC_RC0_CH0 = 3125;
	
	// enable the RC compare interrupt in the Interrupt Enable Register
	TC_IER0_CH0 = INT_CPCS;
	
	//  enable interrupts for timer 0
	NVIC_EnableIRQ(TC0_IRQn);
	
	// enable timer 0 in the channel control register
	TC_CCR0_CH0 = CCR_CLKEN + CCR_SWTRG;
}

void pwm_init() {
	// assign a clock signal to this peripheral
	pmc_enable_periph_clk(ID_PWM);
	
	// divide the master clock by 32 and then again by 3 in the mode register
	PWM_MR = (0x05*0x100) + 0x03;
	
	// set up the pwm module to use CLKA and set the polarity in the channel mode register
	PWM_CMR0 = (0x02*0x100) + 0x0B;
	
	// set the period to 511 in the period register to match the speed value from the potentiometer
	PWM_CPRD0 = 0x1FF;
	
	// initialize the duty cycle to 0 in the Duty Register
	PWM_CDTY0 = 0x00;
	
	// enable pwm 0 in enable register
	PWM_ENA = CHID0;
}

/**
 * \brief Application entry point for sdramc_example.
 *
 * \return Unused (ANSI-C compatibility).
 */
int main(void)
{
	/* Initialize the system */
	sysclk_init();
	board_init();
	sleepmgr_init();

	/* Configure the console uart */
	configure_console();

	/* Output example information */
	puts(STRING_HEADER);

	/* Systick configuration */
	if (SysTick_Config(SystemCoreClock / (1000))) {
		puts("-F- Systick configuration error.\r");
	}

	/* Enable SMC peripheral clock */
	pmc_enable_periph_clk(ID_SDRAMC);

	/* Complete SDRAM configuration */
	sdramc_init((sdramc_memory_dev_t *)&SDRAM_ISSI_IS42S16100E,
			sysclk_get_cpu_hz());
	sdram_enable_unaligned_support();

	/* Test external SDRAM access */
	puts("Test external SDRAM access. \r");

	if (sdram_access_test() == SDRAMC_OK) {
		puts("SDRAM access is successful.\n\r");
	} else {
		puts("SDRAM access is failed.\r");
	}

	if (sdram_benchmarks() == SDRAMC_OK) {
		puts("SDRAM test: pass.\r");
	}

	for (;;) {
		sleepmgr_enter_sleep();
	}
}

/**
 * \brief Test TRNG setting.
 *
 * This test sets the TRNG to generate interrupt when new random value is completed.
 *
 * \param test Current test case.
 */
static void run_trng_test(const struct test_case *test)
{
	/* Configure PMC */
	pmc_enable_periph_clk(ID_TRNG);

	/* Enable TRNG */
	trng_enable(TRNG);

	/* Enable TRNG interrupt */
	NVIC_DisableIRQ(TRNG_IRQn);
	NVIC_ClearPendingIRQ(TRNG_IRQn);
	NVIC_SetPriority(TRNG_IRQn, 0);
	NVIC_EnableIRQ(TRNG_IRQn);
	trng_enable_interrupt(TRNG);
	
	while(trng_int_flag == 0);

	test_assert_true(test, trng_int_flag == 1, "No random value is generated");
}

/**
 * \brief Configure the Push buttons
 *
 * Configure the PIO as inputs and generate corresponding interrupt when
 * pressed or released.
 */
static void configure_buttons(void)
{
	/* Enable the peripheral clock for PCK and push button */
	pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);

	/* Adjust PIO debounce filter parameters, using 10 Hz filter. */
	pio_set_debounce_filter(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, 10);

	/* Initialize PIOs interrupt handlers, see PIO definition in board.h. */
	/* Interrupt on rising edge  */
	pio_handler_set(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_ID,
			PIN_PUSHBUTTON_1_MASK, PIN_PUSHBUTTON_1_ATTR, button1_handler);

	/* Enable PIO controller IRQs. */
	NVIC_EnableIRQ((IRQn_Type) PIN_PUSHBUTTON_1_ID);

	/* Enable PIO line interrupts. */
	pio_enable_interrupt(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK);
}

/**
 * \brief DACC configuration.
 */
static void dsp_configure_dacc(void)
{
	pmc_enable_periph_clk(ID_DACC);

	/*
	 * DACC setting
	 * -Refresh Period = 1024*REFRESH/DACC Clock
	 * -No max Speed Mode
	 * -Startup time of 0 periods of DACClock
	 */
	dacc_set_timing(DACC, DACC_REFRESH, 0, DACC_MR_STARTUP_0);

	/* Set TIO Output of TC Channel 1 as trigger */
	dacc_set_trigger(DACC,2);

	/* Set to half word transfer */
	dacc_set_transfer_mode(DACC, DACC_MR_WORD_HALF);

#if (SAM3S) || (SAM3XA)
	/* Set to No Sleep Mode and No Fast Wake Up Mode*/
	dacc_set_power_save(DACC, 0, 0);
#endif

	/* Select both left/right speaker channels. */
	dacc_set_channel_selection(DACC, SPEAKER_CHANNEL_R);
	dacc_set_channel_selection(DACC, SPEAKER_CHANNEL_L);

	/* Enable DACC channels. */
	dacc_enable_channel(DACC, SPEAKER_CHANNEL_R);
	dacc_enable_channel(DACC, SPEAKER_CHANNEL_L);

	/* Tag selection mode enabled. */
	dacc_enable_flexible_selection(DACC);

	/* Get board DACC PDC base address. */
	dacc_pdc = dacc_get_pdc_base(DACC);

	/* Enable DACC interrupt. */
	dacc_enable_interrupt(DACC,DACC_IER_ENDTX);
	NVIC_SetPriority(DACC_IRQn, INT_PRIORITY_DACC);
	NVIC_EnableIRQ(DACC_IRQn);
}

/**
 * \brief Configures SAMG55 for low power demo.
 */
void init_specific_board(void)
{
	/* For the lowest power consumption all pins should have defined state
	 * e.g. no floating pins.
	 * Set all pins as input with pull-up enabled with the exception:
	 * - CDC UART RX (PA27) should not be pulled up because this pin is
	 *   driven by the EDBG in this application
	 * - CDC UART TX (PA28) This is actively driven by the SAMG55 in this
	 *   application
	 * - PB04 should set as output
	 * - PB8 PB9 PB10 PB11 should set as output
	 */
	pio_set_input(PIOA, 0xE7FFFFFF, PIO_PULLUP);
	pio_set_input(PIOA, 0x18000000, PIO_DEFAULT);
	pio_set_input(PIOB, 0xFFFF0EF, PIO_PULLUP);
	pio_set_output(PIOB, 0xF10, HIGH, DISABLE, DISABLE);
	/* Enable the PMC clocks of push button for wakeup */
	pmc_enable_periph_clk(ID_PIOA);
	pio_handler_set_priority(PIOA, PIOA_IRQn, IRQ_PRIORITY_PIO);
}

/*------------------------------------------------------------------------------
Name:           startTimer
parameters:     tc - timer counter
                channel - timer channel
                irq - isr request
                frequency - frequency of inetrrupts
description:    initializes timer for periodic interrupt generation
------------------------------------------------------------------------------*/
void BldcControl::configureTimerInterrupt(Tc *tc,
                                          uint32_t channel,
                                          IRQn_Type irq,
                                          uint32_t frequency)
{
        pmc_set_writeprotect(false);
        pmc_enable_periph_clk((uint32_t)irq);
        TC_Configure(tc,
                     channel,
                     TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC |
                        TC_CMR_TCCLKS_TIMER_CLOCK4);
        uint32_t rc = VARIANT_MCK/128/frequency; //128 because we selected
                                                 //TIMER_CLOCK4 above
        TC_SetRA(tc, channel, rc/2); //50% high, 50% low
        TC_SetRC(tc, channel, rc);
        TC_Start(tc, channel);
        tc->TC_CHANNEL[channel].TC_IER=TC_IER_CPCS;
        tc->TC_CHANNEL[channel].TC_IDR=~TC_IER_CPCS;
        NVIC_EnableIRQ(irq);
}

//------------------------------------------------------------------------------
void SdSpiAltDriver::begin(uint8_t csPin) {
  m_csPin = csPin;
  pinMode(m_csPin, OUTPUT);
  digitalWrite(m_csPin, HIGH);
SPI.begin();
#if USE_SAM3X_DMAC
  pmc_enable_periph_clk(ID_DMAC);
  dmac_disable();
  DMAC->DMAC_GCFG = DMAC_GCFG_ARB_CFG_FIXED;
  dmac_enable();
#if USE_SAM3X_BUS_MATRIX_FIX
  MATRIX->MATRIX_WPMR = 0x4d415400;
  MATRIX->MATRIX_MCFG[1] = 1;
  MATRIX->MATRIX_MCFG[2] = 1;
  MATRIX->MATRIX_SCFG[0] = 0x01000010;
  MATRIX->MATRIX_SCFG[1] = 0x01000010;
  MATRIX->MATRIX_SCFG[7] = 0x01000010;
#endif  // USE_SAM3X_BUS_MATRIX_FIX
#endif  // USE_SAM3X_DMAC
}

/**
 * \brief GMAC link test function.
 *
 * \param test Current test case.
 */
static void run_gmac_link_test(const struct test_case *test)
{
	gmac_options_t gmac_option;
	uint8_t uc_rc = 1;

	/* Enable GMAC clock */
	pmc_enable_periph_clk(ID_GMAC);

	/* Fill in GMAC options */
	gmac_option.uc_copy_all_frame = 1;
	gmac_option.uc_no_boardcast = 1;

	memcpy(gmac_option.uc_mac_addr, gs_uc_mac_address, sizeof(gs_uc_mac_address));

	gs_gmac_dev.p_hw = GMAC;

	/* Init GMAC driver structure */
	gmac_dev_init(GMAC, &gs_gmac_dev, &gmac_option);

	/* Enable Interrupt */
	NVIC_EnableIRQ(GMAC_IRQn);

	/* Init MAC PHY driver */
	if (ethernet_phy_init(GMAC, BOARD_GMAC_PHY_ADDR, sysclk_get_cpu_hz())
			!= GMAC_OK) {
		uc_rc = 0;
	}

	/* Auto Negotiate, work in RMII mode */
	if (ethernet_phy_auto_negotiate(GMAC, BOARD_GMAC_PHY_ADDR) != GMAC_OK) {
		uc_rc = 0;

	}

	/* Establish ethernet link */
	while (ethernet_phy_set_link(GMAC, BOARD_GMAC_PHY_ADDR, 1) != GMAC_OK) {
		uc_rc = 0;
	}

	test_assert_true(test, uc_rc == 1, "Test GMAC: GMAC link test error!");
}

/*************************************************************************
 Initialization of the I2C bus interface. Need to be called only once
*************************************************************************/
void HAL::i2cInit(unsigned long clockSpeedHz)
{
    // enable TWI                                                        
    pmc_enable_periph_clk(TWI_ID);                                       
                                                                         
    // Configure pins                                                    
    PIO_Configure(g_APinDescription[SDA_PIN].pPort,                      
                  g_APinDescription[SDA_PIN].ulPinType,                  
                  g_APinDescription[SDA_PIN].ulPin,                      
                  g_APinDescription[SDA_PIN].ulPinConfiguration);        
    PIO_Configure(g_APinDescription[SCL_PIN].pPort,                      
                  g_APinDescription[SCL_PIN].ulPinType,                  
                  g_APinDescription[SCL_PIN].ulPin,                      
                  g_APinDescription[SCL_PIN].ulPinConfiguration);        
                                                                         
    // Set to Master mode with known state                               
    TWI_INTERFACE->TWI_CR = TWI_CR_SVEN;                                 
    TWI_INTERFACE->TWI_CR = TWI_CR_SWRST;                                
    //TWI_INTERFACE->TWI_RHR;  // no action???                                              
    TWI_INTERFACE->TWI_IMR = 0;                                          
                                                                         
    TWI_INTERFACE->TWI_CR = TWI_CR_SVDIS;                                
    TWI_INTERFACE->TWI_CR = TWI_CR_MSDIS;                                
    TWI_INTERFACE->TWI_CR = TWI_CR_MSEN;                                 
                                                                         
    // Set i2c clock rate                                                
    uint32_t dwCkDiv = 0;                                                
    uint32_t dwClDiv;                                                    
    while ( dwClDiv == 0 )                                               
    {                                                                    
        dwClDiv = ((F_CPU_TRUE / (2 * clockSpeedHz)) - 4) / (1<<dwCkDiv);
                                                                         
        if ( dwClDiv > 255 )                                             
        {                                                                
            dwCkDiv++;                                                   
            dwClDiv = 0;                                                 
        }                                                                
    }                                                                    
    TWI_INTERFACE->TWI_CWGR = 0;                                         
    TWI_INTERFACE->TWI_CWGR = (dwCkDiv << 16) | (dwClDiv << 8) | dwClDiv;
}

uint8_t twi_init(void){
	/*TWI0:
	- Clock:	PA4 (Laranja)
	- Data:		PA3 (Cinza)
	- Terra:	GND (Preta)
	- VCC:		3V3 (Branco)*/
	gpio_configure_pin(TWI0_DATA_GPIO, TWI0_DATA_FLAGS);
	gpio_configure_pin(TWI0_CLK_GPIO, TWI0_CLK_FLAGS);
	
	twi_options_t opt_twi;
	
	pmc_enable_periph_clk(ID_TWI0);	
	
	opt_twi.master_clk = sysclk_get_cpu_hz();
	opt_twi.speed = TWI_SPEED;
	opt_twi.smbus = 0;
	
	uint8_t twi_status = twi_master_init(TWI0, &opt_twi);
	
	return twi_status;
}

/**
 * \brief Initialize SAM3N_EK board for low power test.
 */
void init_specific_board(void)
{
    /* Configure all PIOs as inputs to save power */
    pio_set_input(PIOA, 0xFFFFFFFF, PIO_PULLUP);
    pio_set_input(PIOB, 0xFFFFFFFF, PIO_PULLUP);
    pio_set_input(PIOC, 0xFFFFFFFF, PIO_PULLUP);

    /* Disable USB Clock */
    pmc_disable_upll_clock();

    /* Disable PIO pull-up for PA0 (VBUS_USB) */
    pio_pull_up(PIOA, (0x1 << 0), 0);

    /* Initialize ADC pin as ADC input mode to save power */
    adc_enable_channel(ADC, ADC_CHANNEL_0);
    adc12b_enable_channel(ADC12B, ADC_CHANNEL_3);

    /* Enable the PMC clocks of push button for wakeup */
    pmc_enable_periph_clk(ID_PIOA);
    pio_handler_set_priority(PIOA, PIOA_IRQn, IRQ_PRIOR_PIO);
}

/**
 * \brief Configure Timer Counter 0 (TC0) to generate an interrupt every 200ms.
 * This interrupt will be used to flush USART input and echo back.
 */
static void configure_tc(void)
{
	uint32_t ul_div;
	uint32_t ul_tcclks;
	static uint32_t ul_sysclk;

	/* Get system clock. */
	ul_sysclk = sysclk_get_cpu_hz();

	/* Configure PMC. */
	pmc_enable_periph_clk(ID_TC0);

	/* Configure TC for a 50Hz frequency and trigger on RC compare. */
	tc_find_mck_divisor(TC_FREQ, ul_sysclk, &ul_div, &ul_tcclks, ul_sysclk);
	tc_init(TC0, 0, ul_tcclks | TC_CMR_CPCTRG);
	tc_write_rc(TC0, 0, (ul_sysclk / ul_div) / TC_FREQ);

	/* Configure and enable interrupt on RC compare. */
	NVIC_EnableIRQ((IRQn_Type)ID_TC0);
	tc_enable_interrupt(TC0, 0, TC_IER_CPCS);
}