コード例 #1
0
ファイル: DelayFunctions.c プロジェクト: michaelnen/1404a
void delay_init(void)		/* Initializes the timer used for delays */
{
	pmc_enable_periph_clk(ID_TC4);
	tc_init(TC1,1,0);		 /* TC1, channel 1, TCLK1 och capturemode */
	tc_set_block_mode(TC1,0);
	tc_stop(TC1,1);			/* making sure the timer does not run  */
}
コード例 #2
0
ファイル: main.c プロジェクト: AlexShiLucky/freertos
/**
 *  \brief Process Buttons Events
 *
 *  Change active states of LEDs when corresponding button events happened.
 */
static void ProcessButtonEvt(uint8_t uc_button)
{
// [main_button1_evnt_process]
	if (uc_button == 0) {
		g_b_led0_active = !g_b_led0_active;
		if (!g_b_led0_active) {
			ioport_set_pin_level(LED0_GPIO, IOPORT_PIN_LEVEL_HIGH);
		}
	}
// [main_button1_evnt_process]
#ifdef LED1_GPIO 
	else {
// [main_button2_evnt_process]
		g_b_led1_active = !g_b_led1_active;

		/* Enable LED#2 and TC if they were enabled */
		if (g_b_led1_active) {
			ioport_set_pin_level(LED1_GPIO, IOPORT_PIN_LEVEL_LOW);
			tc_start(TC0, 0);
		}
		/* Disable LED#2 and TC if they were disabled */
		else {
			ioport_set_pin_level(LED1_GPIO, IOPORT_PIN_LEVEL_HIGH);
			tc_stop(TC0, 0);
		}
// [main_button2_evnt_process]
	}
#endif
}
コード例 #3
0
ファイル: afec_example4.c プロジェクト: InSoonPark/asf
/**
 * \brief Application entry point.
 *
 * \return Unused (ANSI-C compatibility).
 */
int main(void)
{
	uint8_t uc_key;

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

	configure_console();

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

	g_afec0_sample_data = 0;
	g_afec1_sample_data = 0;
	g_max_digital = MAX_DIGITAL_12_BIT;

	set_afec_test();

	while (1) {
		afec_start_software_conversion(AFEC0);
		delay_ms(g_delay_cnt);

		/* Check if the user enters a key. */
		if (!uart_read(CONF_UART, &uc_key)) {
			/* Disable all afec interrupt. */
			afec_disable_interrupt(AFEC0, AFEC_INTERRUPT_ALL);
			afec_disable_interrupt(AFEC1, AFEC_INTERRUPT_ALL);
			tc_stop(TC0, 0);
			set_afec_test();
		}
	}
}
コード例 #4
0
ファイル: tc.c プロジェクト: ishgum/Wacky-Racers
/* Sleep for specified period.  This is useful for synchronising the
   CPU clock MCK to the timer clock, especially since the fastest
   timer clock is MCK / 2.  */
void
tc_clock_sync (tc_t tc, tc_period_t period)
{
    uint32_t id;

    tc_config_1 (tc, TC_MODE_DELAY_ONESHOT, period, period, 1);

    id = ID_TC0 + TC_CHANNEL (tc);

    irq_config (id, 7, tc_clock_sync_handler);
            
    irq_enable (id);

    /* Enable interrupt when have compare on A.  */
    tc->base->TC_IER = TC_IER_CPAS;

    tc_start (tc);
    
    /* Stop CPU clock until interrupt.  FIXME, should disable other
       interrupts first. */
    mcu_cpu_idle ();

    /* Disable interrupt when have compare on A.  */
    tc->base->TC_IDR = TC_IDR_CPAS;

    irq_disable (id);

    tc_stop (tc);
}
コード例 #5
0
/**
 *  \brief Interrupt handler for USART.
 *
 * Increment the number of bytes received in the current second and start
 * another transfer if the desired bps has not been met yet.
 *
 */
void USART_Handler(void)
{
	uint32_t ul_status;

	tc_stop(TC0, 0);

	/* Read USART status. */
	ul_status = usart_get_status(BOARD_USART);

	/* Receive buffer is full. */
	if (ul_status & US_CSR_RXBUFF) {
		g_ul_bytes_received += 2 * BUFFER_SIZE;
		if (g_ul_bytes_received < MAX_BPS) {
			/* Restart transfer if BPS is not high enough. */
			g_st_packet.ul_addr = (uint32_t)gs_puc_buffer;
			g_st_packet.ul_size = BUFFER_SIZE;
			g_st_nextpacket.ul_addr = (uint32_t)gs_puc_nextbuffer;
			g_st_nextpacket.ul_size = BUFFER_SIZE;
			pdc_rx_init(g_p_pdc, &g_st_packet, &g_st_nextpacket);
		} else {
			/* Otherwise disable interrupt. */
			usart_disable_interrupt(BOARD_USART, US_IDR_RXBUFF);
		}
		memcpy(gs_dump_buffer, gs_puc_buffer, BUFFER_SIZE);
	}
	tc_start(TC0, 0);
}
コード例 #6
0
ファイル: ili93xx_example.c プロジェクト: ericaykido/Entregas
/**
 * \brief ADC interrupt handler.
 * Entramos aqui quando a conversao for concluida.
 */
void ADC_Handler(void)
{
	uint32_t tempValue;
	uint32_t status ;

	status = adc_get_status(ADC);
	
	/* Checa se a interrupção é devido ao canal 5 */
	if ((status & ADC_ISR_EOC5)) {
		tempValue = adc_get_channel_value(ADC, ADC_POT_CHANNEL);
		if ((tempValue > adc_value_old + 2) || (tempValue < adc_value_old - 2))
		{
			if (isAmp){
				amplitude = tempValue;
				atualiza_amp(amplitude);
			} else {
				frequencia = tempValue;
				tc_stop(TC0,0);
				configure_tc((frequencia*32768/2000)/4095);
				atualiza_freq(frequencia);
			}
		}
		adc_value_old = tempValue;
	}
	
}
コード例 #7
0
ファイル: rtimer-arch.c プロジェクト: EmuxEvans/calipso
void TC1_Handler(void)
{
	volatile uint32_t ul_dummy;
	/* Clear status bit to acknowledge interrupt */
	ul_dummy = tc_get_status(TC0,1);
	
	#if RTIMER_DEBUG
	if ((ul_dummy & TC_SR_CPCS) == TC_SR_CPCS) {
	#endif
		tc_stop(TC0,1);	// Crucial, since the execution may take long time
	#if RTIMER_DEBUG
		printf("Compare event %16x\r\n", ul_dummy);
	#endif
		tc_disable_interrupt(TC0,1,TC_IDR_CPCS);  // Disable the next compare interrupt XXX XXX
		ENERGEST_ON(ENERGEST_TYPE_IRQ);
		rtimer_run_next(); /* Run the posted task. */
		ENERGEST_OFF(ENERGEST_TYPE_IRQ);
		
	#if RTIMER_DEBUG
	}
	else {
		printf("Unknown interrupt.\n\n");
	}
	#endif
	
}
コード例 #8
0
ファイル: audio.c プロジェクト: alanvgreen/DirSpk1
// Set the frequency of the generated tone. 0 means off.
void audioFrequencySet(uint32_t freq) {
	// In order to avoid audio hiccups, don't do anything if setting 
	// same frequency. 
	if (currFreq == freq) {
		return;
	}
	
	tc_stop(TC0, 0);
	if (freq == 0) {
		return;
	}
	
	// Find the best divisor for this frequency
	uint32_t ul_div, ul_tcclks;
	tc_find_mck_divisor(freq, SystemCoreClock, 
		&ul_div, &ul_tcclks, SystemCoreClock);
		
	// Put Timer into wavesel up RC mode with TIOA at 50% duty cycle
	// Clear TIOA at CPC match and set at CPA match
	tc_init(TC0, 0, ul_tcclks | TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_ACPC_CLEAR | TC_CMR_ACPA_SET);
	uint16_t rcVal = (SystemCoreClock / ul_div) / freq;
	tc_write_rc(TC0, 0, rcVal);
	tc_write_ra(TC0, 0, rcVal / 2);  // 50% duty cycle
	
	// Start the thing
	tc_start(TC0, 0);
	
	currFreq = freq;
}
コード例 #9
0
ファイル: tc_comm.c プロジェクト: bobo8909/RTT
void tc_start(const char* tc_prefix)
{
	rt_err_t result;

	/* tesecase prefix is null */
	if (tc_prefix == RT_NULL)
	{
		rt_kprintf("TestCase Usage: tc_start(prefix)\n\n");
		rt_kprintf("list_tc() can list all testcases.\n");
		return ;
	}

	/* init tc thread */
	if (_tc_stat & TC_STAT_RUNNING)
	{
		/* stop old tc thread */
		tc_stop();
	}

	rt_memset(_tc_prefix, 0, sizeof(_tc_prefix));
	rt_snprintf(_tc_prefix, sizeof(_tc_prefix), "_tc_%s", tc_prefix);

	result = rt_thread_init(&_tc_thread, "tc",
		tc_thread_entry, RT_NULL,
		&_tc_stack[0], sizeof(_tc_stack),
		TC_PRIORITY - 3, 5);

	/* set tc stat */
	_tc_stat = TC_STAT_RUNNING | TC_STAT_FAILED;

	if (result == RT_EOK)
		rt_thread_startup(&_tc_thread);
}
コード例 #10
0
ファイル: main.c プロジェクト: wpd/atmel-software-package
/**
 *  \brief LIN Application entry point.
 *
 *  \return Unused (ANSI-C compatibility).
 */
int main(void)
{
	/* Output example information */
	console_example_info("LIN Example");

	/* Configure Console interrupts */
	printf("Initializing console interrupts\r\n");
	console_set_rx_handler(_console_handler);
	console_enable_rx_interrupt();

	/* Configure Timer/Counter */
	_configure_tc();

	/* Configure com port */
	_init_com_master();
	_init_com_slave();

	/* main LIN program */
	_display_menu();
	do {
		switch (key) {
		case 'P':
		case 'p':
		case 'S':
		case 's':
		case 'I':
		case 'i':
			tc_stop(TC0, TC_CHANNEL);
			_process_button_evt();
			_display_menu();
			if (key == 'I' || key == 'i')
				tc_stop(TC0, 0);
			else
				tc_start(TC0, TC_CHANNEL);
			key = 0;
			break;
		default:
			break;
		}
	} while (key != 'q' && key != 'Q');

	tc_stop(TC0, TC_CHANNEL);
	timer_wait(500);
	printf("\n\rEnd of demo\n\r");
	while (1);
}
コード例 #11
0
int delayInit(void)		/* Initializes the timer used for delays */
{
	pmc_enable_periph_clk(ID_TC0);	/* power on the peripheral clock for timers */
	tc_init(TC0,0,0);				/* TC0, channel 0, TCLK1 och capturemode */
	tc_set_block_mode(TC0,0);
	tc_stop(TC0,0);					/* making sure the timer does not run  */
	return 0;						/* evertyhing is ok, typical response */
}
コード例 #12
0
ファイル: wifi.c プロジェクト: jdrunner/smartee
//*** Private method that actually sends data ***//
int wifi_send_data(int ch, const uint8_t* data, int size){
  int cmd_buf_size = MD_BUF_SIZE;
  char *cmd;
  int timeout = 7; //wait 7 seconds to transmit the data
  //allocate memory
  cmd = core_malloc(cmd_buf_size);
  snprintf(cmd,cmd_buf_size,"AT+CIPSEND=%d,%d\r\n",ch,size);
  data_tx_status=TX_PENDING;
  rx_wait=true;
  resp_buf_idx = 0;
  memset(resp_buf,0x0,RESP_BUF_SIZE);
  memset(wifi_rx_buf,0x0,WIFI_RX_BUF_SIZE); //to make debugging easier
  wifi_rx_buf_idx=0;
  usart_serial_write_packet(WIFI_UART,(uint8_t*)cmd,strlen(cmd));
  delay_ms(250); //wait for module to be ready to accept data
  usart_serial_write_packet(WIFI_UART,(uint8_t*)data,size);
  //now wait for the data to be sent
  while(timeout>0){
    //start the timer
    tc_start(TC0, 0);	  
    //when timer expires, return what we have in the buffer
    rx_wait=true; //reset the wait flag
    while(rx_wait && data_tx_status!=TX_SUCCESS);
    tc_stop(TC0,0);
    //the success flag is set *before* we receive the server's response
    //core_process_wifi_data receives the response but discards it 
    if(data_tx_status==TX_SUCCESS){
      data_tx_status=TX_IDLE;
      rx_wait = false;
      //free memory
      core_free(cmd);
      return TX_SUCCESS;
    }
    timeout--;
  }
  //check if this is a timeout error
  if(strlen((char*)resp_buf)==0){
    printf("timeout error\n");
    core_log("timeout error");
    data_tx_status = TX_TIMEOUT;
  }
  //an error occured, see if it is due to a module reset
  else if(strcmp((char*)resp_buf,"\r\nready\r\n")==0){
    //module reset itself!!! 
    printf("detected module reset\n");
    core_log("module reset");
    data_tx_status = TX_ERR_MODULE_RESET;
  } else {
    data_tx_status=TX_ERROR;
    core_log("TX error:");
    core_log((char*)resp_buf);
    data_tx_status = TX_ERROR;
  }
  //free memory
  core_free(cmd);
  return data_tx_status;
}
コード例 #13
0
ファイル: XPROGTimeout.c プロジェクト: EwanLu/chipwhisperer
void start_timeoutcnt(void)
{
	if(timerEnabled == false){
		setup_timeoutcnt();
	}
	tc_stop(TC0, TC_CHANNEL_TICKCNT);
	TimeoutTicksRemaining = defaultTimeoutTicks; /* x / 2500 = timeout in seconds  */
	tc_start(TC0, TC_CHANNEL_TICKCNT);
}
コード例 #14
0
ファイル: buart_if.c プロジェクト: Realtime-7/asf
/**
 * \brief This function closes and disables communication in the specified UART.
 *
 * \param chn  Communication channel [0, 1]
 *
 * \retval true on success.
 * \retval false on failure.
 */
int8_t buart_if_close(uint8_t chn)
{
	if (!buart_chn_open[chn]) {
		return false;
	}

	switch (chn) {
#ifdef CONF_BOARD_UART0
	case 0:
	{
		uart_disable(UART0);
		uart_disable_interrupt(UART0, US_IDR_RXRDY);
		uart_disable_interrupt(UART0, US_IER_ENDRX);

		/* Stop TC */
		if (!buart_chn_open[1]) {
			tc_stop(TC_UART, TC_UART_CHN);
		}

		return true;
	}
	break;
#endif

#ifdef CONF_BOARD_UART1
	case 1:
	{
		uart_disable(UART1);
		uart_disable_interrupt(UART1, US_IDR_RXRDY);
		uart_disable_interrupt(UART1, US_IER_ENDRX);

		/* Stop TC */
		if (!buart_chn_open[0]) {
			tc_stop(TC_UART, TC_UART_CHN);
		}

		return true;
	}
	break;
#endif
	default:
		return false;
	}
}
コード例 #15
0
ファイル: buzzer.c プロジェクト: ShankarWright/TklabsVanet
static void disable_output(const channel_def_t* channel)
{
    if (channel->externally_driven)
    {
        // software trigger to clear the output, turn off the timer
        tc_software_trigger(channel->ex.timer, channel->ex.channel);
        tc_stop(channel->ex.timer, channel->ex.channel);
    }
    else if (channel->in.active_level)
    {
        gpio_set_pin_low(channel->in.pin1);
    }
    else
    {
        gpio_set_pin_high(channel->in.pin1);
    }
}
コード例 #16
0
ファイル: buzzer.c プロジェクト: ShankarWright/TklabsVanet
static void reset_timeout(void)
{
    if (s_period_counter > 0)
    {
        // see how long to wait
        uint16_t rc = min(0xffff,s_period_counter);
        tc_write_rc(CONFIG_BSP_BUZZER_REP_TIMER, CONFIG_BSP_BUZZER_REP_CHANNEL, rc);
        
        // remember how much we've waited
        s_period_counter -= rc;

        // Reset the counter
        tc_start(CONFIG_BSP_BUZZER_REP_TIMER, CONFIG_BSP_BUZZER_REP_CHANNEL);
    }
    else
    {
        // make sure the timer is stopped
        tc_stop(CONFIG_BSP_BUZZER_REP_TIMER, CONFIG_BSP_BUZZER_REP_CHANNEL);
    }
}
コード例 #17
0
ファイル: lp_ticker.c プロジェクト: Archcady/mbed-os
void TICKER_COUNTER_Handlr2(void)
{
    uint32_t status=tc_get_status(TICKER_COUNTER_lp, TICKER_COUNTER_CHANNEL2);
    uint32_t interrupmask=tc_get_interrupt_mask(TICKER_COUNTER_lp, TICKER_COUNTER_CHANNEL2);

    if (((status & interrupmask)  & TC_IER_CPCS)) {
        if(lp_ticker_interrupt_counter) {
            lp_ticker_interrupt_counter--;
        } else {
            if(lp_ticker_interrupt_offset) {
                tc_stop(TICKER_COUNTER_lp, TICKER_COUNTER_CHANNEL2);
                tc_write_rc(TICKER_COUNTER_lp, TICKER_COUNTER_CHANNEL2, (uint32_t)lp_ticker_interrupt_offset);
                tc_start(TICKER_COUNTER_lp, TICKER_COUNTER_CHANNEL2);
                lp_ticker_interrupt_offset=0;
            } else {
                lp_ticker_irq_handler();
            }
        }
    }
}
コード例 #18
0
/**
 * \brief Configure Timer Counter 0 to generate an interrupt with the specific
 * frequency.
 *
 * \param freq Timer counter frequency.
 */
static void configure_tc(uint32_t freq)
{
	uint32_t ul_div;
	uint32_t ul_tcclks;
	uint32_t ul_sysclk = sysclk_get_cpu_hz();

	/* Disable TC first */
	tc_stop(TC0, 0);
	tc_disable_interrupt(TC0, 0, TC_IER_CPCS);

	/** Configure TC with the frequency and trigger on RC compare. */
	tc_find_mck_divisor(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) / 4);

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

	/** Start the counter. */
	tc_start(TC0, 0);
}
コード例 #19
0
/**
 * \brief Interrupt handler for USART. Echo the bytes received and start the
 * next receive.
 */
void USART_Handler(void)
{
	uint32_t ul_status;

	/* Read USART Status. */
	ul_status = usart_get_status(BOARD_USART);

	/* Receive buffer is full. */
	if (ul_status & US_CSR_RXBUFF) {
		/* Disable timer. */
		tc_stop(TC0, 0);

		/* Echo back buffer. */
		pdca_channel_write_load(PDCA_TX_CHANNEL,
				(void *)gs_puc_buffer[gs_uc_buf_num],
				gs_ul_size_buffer);
		pdca_channel_write_reload(PDCA_TX_CHANNEL,
				(void *)gs_puc_nextbuffer[gs_uc_buf_num],
				gs_ul_size_nextbuffer);

		if (g_uc_transend_flag) {
			gs_ul_size_buffer = BUFFER_SIZE;
			gs_ul_size_nextbuffer = BUFFER_SIZE;
			g_uc_transend_flag = 0;
		}

		gs_uc_buf_num = MAX_BUF_NUM - gs_uc_buf_num;

		/* Restart read on buffer. */
		pdca_channel_write_load(PDCA_RX_CHANNEL,
				(void *)gs_puc_buffer[gs_uc_buf_num], BUFFER_SIZE);
		pdca_channel_write_reload(PDCA_RX_CHANNEL,
				(void *)gs_puc_nextbuffer[gs_uc_buf_num], BUFFER_SIZE);

		/* Restart timer. */
		tc_start(TC0, 0);
	}
}
コード例 #20
0
ファイル: XPROGTimeout.c プロジェクト: EwanLu/chipwhisperer
void stop_timeoutcnt(void)
{
	tc_stop(TC0, TC_CHANNEL_TICKCNT);
}
コード例 #21
0
ファイル: ui.c プロジェクト: AndreyMostovov/asf
/**
 * \name PWM functions
 * @{
 */
void ui_pwm_led_init(uint8_t lednum)
{
	/* Timer waveform options */
	static tc_waveform_opt_t waveform_options = {
		/* Channel selection. */
		.channel  = 1,

		.bswtrg   = TC_EVT_EFFECT_NOOP,
		.beevt    = TC_EVT_EFFECT_NOOP,
		.bcpc     = TC_EVT_EFFECT_NOOP,
		.bcpb     = TC_EVT_EFFECT_NOOP,

		.aswtrg   = TC_EVT_EFFECT_NOOP,
		.aeevt    = TC_EVT_EFFECT_NOOP,
		.acpc     = TC_EVT_EFFECT_NOOP,
		.acpa     = TC_EVT_EFFECT_NOOP,

		/* Waveform selection */
		.wavsel   = TC_WAVEFORM_SEL_UP_MODE_RC_TRIGGER,
		/* External event trigger enable. */
		.enetrg   = false,
		/* External event selection (non-zero for Channel B to work) */
		.eevt     = !0,
		/* External event edge selection. */
		.eevtedg  = TC_SEL_NO_EDGE,

		.cpcdis   = false,
		.cpcstop  = false,

		.burst    = false,
		.clki     = false,
		/* Internal source clock 5, fPBA/128. */
		.tcclks   = TC_CLOCK_SOURCE_TC5,
	};
	switch (lednum) {
	case LED0:
		/* Assign output pin to timer/counter 0 channel A */

		/* Channel selection. */
		waveform_options.channel = 1;

		waveform_options.bcpc = TC_EVT_EFFECT_NOOP;

		waveform_options.bcpb = TC_EVT_EFFECT_NOOP;
		/* RC compare effect on TIOA. */
		waveform_options.acpc = TC_EVT_EFFECT_CLEAR;
		/* RA compare effect on TIOA. */
		waveform_options.acpa = TC_EVT_EFFECT_SET;

		/* Setup timer/counter waveform mode */
		sysclk_enable_peripheral_clock(&AVR32_TC0);
		tc_init_waveform(&AVR32_TC0, &waveform_options);

		/* Write the TOP (RC) and COMPARE (RA) values */
		tc_write_ra(&AVR32_TC0, 1, 1);   /* Set RA value. */
		tc_write_rc(&AVR32_TC0, 1, 255); /* Set RC value. */

		/* Start the timer PWM channel */
		tc_start(&AVR32_TC0, 1);
		break;

	case LED1:
		/* Assign output pin to timer/counter 1 channel B */

		/* Channel selection. */
		waveform_options.channel = 2;

		waveform_options.acpc = TC_EVT_EFFECT_NOOP;

		waveform_options.acpa = TC_EVT_EFFECT_NOOP;
		/* RC compare effect on TIOB. */
		waveform_options.bcpc = TC_EVT_EFFECT_CLEAR;
		/* RB compare effect on TIOB. */
		waveform_options.bcpb = TC_EVT_EFFECT_SET;

		/* Setup timer/counter waveform mode */
		sysclk_enable_peripheral_clock(&AVR32_TC1);
		tc_init_waveform(&AVR32_TC1, &waveform_options);

		/* Write the TOP (RC) and COMPARE (RB) values */
		tc_write_rb(&AVR32_TC1, 2, 1);   /* Set RB value. */
		tc_write_rc(&AVR32_TC1, 2, 255); /* Set RC value. */

		/* Start the timer PWM channel */
		tc_start(&AVR32_TC1, 2);
		break;

	default:
		break;
	}
}

void ui_pwm_update(uint8_t channum, uint8_t brightness)
{
	switch (channum) {
	case LED0:
		if (brightness != 0) {
			gpio_enable_module_pin(AVR32_TC0_A1_0_1_PIN,
					AVR32_TC0_A1_0_1_FUNCTION);
			tc_start(&AVR32_TC0, 1);
			tc_write_ra(&AVR32_TC0, 1, brightness);
		} else {
			tc_stop(&AVR32_TC0, 1);
			LED_Off(LED0);
		}

		break;

	case LED1:
		if (brightness != 0) {
			gpio_enable_module_pin(AVR32_TC1_B2_0_PIN,
					AVR32_TC1_B2_0_FUNCTION);
			tc_start(&AVR32_TC1, 2);
			tc_write_rb(&AVR32_TC1, 2, brightness);
		} else {
			tc_stop(&AVR32_TC1, 2);
			LED_Off(LED0);
		}

		break;

	default:
		break;
	}
}

/* End of PWM */
/** @} */

/**
 * \name Display functions
 * @{
 */

static void ui_display_enable(void)
{
	delay_init(sysclk_get_cpu_hz());

	et024006_Init( sysclk_get_cpu_hz(), sysclk_get_hsb_hz());

	/* Clear the display i.e. make it black */
	et024006_DrawFilledRect(0, 0, ET024006_WIDTH, ET024006_HEIGHT, BLACK );

	/* Set the backlight. */
	gpio_set_gpio_pin(ET024006DHU_BL_PIN);

	ui_display_init_rtc();

	ui_display_welcome_msg();
}
コード例 #22
0
ファイル: hw_timer.c プロジェクト: songjw0820/contiki_atmel
/*! \brief  to stop the running timer
 */
void tmr_stop(void)
{
	tc_stop(TIMER, TIMER_CHANNEL_ID);
}
コード例 #23
0
ファイル: main.c プロジェクト: Cbrazioli/Entregas
/**
 *  Handle Interrupcao botao 2.
 */
static void Button2_Handler(uint32_t id, uint32_t mask)
{
	tc_stop(TC0,0);
	tc_write_rc(TC0, 0, tc_read_rc(TC0, 0)*0.9);
	tc_start(TC0,0);
}
コード例 #24
0
ファイル: EPD_hardware_driver.c プロジェクト: InSoonPark/asf
/**
* \brief The PWM signal stops toggling.
*/
void PWM_stop_toggle(void) {
	tc_stop(EPD_TC_WAVEFORM_ID);
}
コード例 #25
0
ファイル: EPD_hardware_driver.c プロジェクト: InSoonPark/asf
/**
* \brief Stop Timer
*/
void stop_EPD_timer(void) {
	tc_stop(EPD_TC_TIMER_ID);
}
コード例 #26
0
ファイル: main.c プロジェクト: zearaujo25/Entregas
int main(void)
{
	uint8_t uc_key;

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

	/* Configure LED 1 */
	pmc_enable_periph_clk(ID_LED_BLUE);
	pio_set_output(PORT_LED_BLUE  , MASK_LED_BLUE	,1,0,0);

	/* Initialize debug console */
	config_uart();
	
	/* frase de boas vindas */
	puts(" ---------------------------- \n\r"
	 	 " Bem vindo Corsi  !		\n\r"
		 " ---------------------------- \n\r");
		 
	/* display main menu */
	display_menu();
	configure_tc();
	TC0_Handler();
	
	pio_clear(PORT_LED_RED, MASK_LED_RED);
	pio_set(PORT_LED_GREEN, MASK_LED_GREEN);
	
	PIOA->PIO_PER = (1 << PIN_LED_BLUE );
	PIOA->PIO_OER |=  (1 << PIN_LED_BLUE );
	
	
	PMC->PMC_PCER0 |= ID_PIOC;
	PIOC->PIO_PER |= (1 << PIN_LED_RED );
	PIOC->PIO_OER |=  (1 << PIN_LED_RED );
	
	
	tc_stop(TC0, 0);
	PIOA->PIO_SODR = (1 << PIN_LED_BLUE );
	PIOC->PIO_CODR = (1 << PIN_LED_RED );
	
	while (1) {
		usart_serial_getchar((Usart *)CONSOLE_UART, &uc_key);	
		switch (uc_key) {
			case '1':
				display_menu();
				break;
			case '2':
				tc_start(TC0,0);
				PIOA->PIO_CODR = (1 << PIN_LED_BLUE );
				
				puts("Led BLUE ON \n\r");
				break;
			case '3' :
				tc_stop(TC0, 0);
				PIOA->PIO_SODR = (1 << PIN_LED_BLUE );
				puts("Led BLUE OFF \n\r");
			
				break;
			case '4':
				tc_start(TC0,0);
				pio_clear(PORT_LED_GREEN, MASK_LED_GREEN);
				puts("Led GREEN ON \n\r");
				break;
			case '5' :
				tc_stop(TC0, 0);

				pio_set(PORT_LED_GREEN, MASK_LED_GREEN);
				puts("Led GREEN OFF \n\r");
				break;
			case '6':
					tc_start(TC0,0);
					PIOC->PIO_SODR = (1 << PIN_LED_RED );
				
				puts("Led RED ON \n\r");
			break;
			case '7' :
				tc_stop(TC0, 0);
				PIOC->PIO_CODR = (1 << PIN_LED_RED );
				puts("Led RED OFF \n\r");
			break;
			case '8' :
				
				tc_write_rc(TC0, 0, tc_read_rc(TC0,0) * 0.5);
				puts("aumentando \n\r");
				break;
			case '9' :
				
				tc_write_rc(TC0, 0, tc_read_rc(TC0,0) * 1.4);
				puts("diminuindo \n\r");
				break;				
			default:
				printf("Opcao nao definida: %d \n\r", uc_key);
		}	
	}
}
コード例 #27
0
ファイル: DelayFunctions.c プロジェクト: michaelnen/1404a
void delay(uint32_t us)		/* A simple implementation for a delay in us (not calibrated) */
{
	tc_start(TC1,1);
	while (tc_read_cv(TC1,1) < us*42);
	tc_stop(TC1,1);
}
コード例 #28
0
ファイル: demo.c プロジェクト: thegeek82000/asf
/**
 * \brief Turn on/off ADC module.
 *
 * \param on True to start ADC, false to turn off.
 */
static void demo_start_adc(bool on)
{
	uint32_t low_threshold, high_threshold;

	if (on == true) {
		/* Check if already enabled */
		if (demo_adc_on) {
			return;
		}

		demo_config_adc();

		/* Start TC0 and hardware trigger. */
		tc_start(TC0, 1);

		/* Get the potentiometer initial value */
		pontentiometer_value = adc_get_channel_value(ADC,
				ADC_CHANNEL_POTENTIOMETER);

		/* Set Window threshold according to the initial values */
		low_threshold  = pontentiometer_value -
				(NB_INTERVALS * (0x1000 / 256));
		if (low_threshold > 0xf000000) {
			low_threshold = 0;
		}

		high_threshold = pontentiometer_value +
				(NB_INTERVALS * (0x1000 / 256));
		if (high_threshold >= 0x1000) {
			high_threshold = 0x1000 - 1;
		}

		pontentiometer_value
			= pontentiometer_value*100 + 1;

		/* Channel 5 has to be compared. */
		adc_set_comparison_channel(ADC, ADC_CHANNEL_POTENTIOMETER);
		/* Compare mode, out the window. */
		adc_set_comparison_mode(ADC, ADC_EMR_CMPMODE_OUT);

		/* Set up Threshold. */
		adc_set_comparison_window(ADC, low_threshold,
				high_threshold);

		/* Enable ADC interrupt. */
		NVIC_EnableIRQ(ADC_IRQn);

		/* Enable Compare Interrupt. */
		adc_enable_interrupt(ADC, ADC_IER_COMPE);

		/* Set adc on flag */
		demo_adc_on = 1;

		/* Reset clapse time */
		ppt_delay_clapse_counter = 0;
	} else {
		tc_stop(TC0, 1);
		/* Enable ADC interrupt. */
		NVIC_DisableIRQ(ADC_IRQn);
		/* Enable Compare Interrupt. */
		adc_disable_interrupt(ADC, ADC_IDR_COMPE);
		/* Set adc off flag */
		demo_adc_on = 0;
	}
}
コード例 #29
0
ファイル: lp_ticker.c プロジェクト: Archcady/mbed-os
void lp_ticker_disable_interrupt(void)
{
    tc_stop(TICKER_COUNTER_lp, TICKER_COUNTER_CHANNEL2);
    tc_disable_interrupt(TICKER_COUNTER_lp, TICKER_COUNTER_CHANNEL2, TC_IDR_CPCS);
    NVIC_DisableIRQ(TICKER_COUNTER_IRQn2);
}
コード例 #30
0
ファイル: busart_if.c プロジェクト: InSoonPark/asf
/**
 * \brief Interrupt handler. Record the number of bytes received,
 * and then restart a read transfer on the USART if the transfer was stopped.
 */
void TC_USART_Handler(void)
{
	uint32_t ul_status;
#if defined(CONF_BOARD_USART0_RXD) || defined(CONF_BOARD_USART1_RXD)
	uint32_t ul_byte_total = 0;
#endif

	/* Read TC_USART Status. */
	ul_status = tc_get_status(TC_USART, TC_USART_CHN);

	/* RC compare. */
	if ((ul_status & TC_SR_CPCS) == TC_SR_CPCS) {
#ifdef CONF_BOARD_USART0_RXD
		if (busart_chn_open[0]) {
			/* Flush PDC buffer. */
			ul_byte_total = USART_BUFFER_SIZE - pdc_read_rx_counter(g_p_usart_pdc0);
			if (ul_byte_total > 0) {
				if (ul_byte_total == num_bytes_rx_usart0) {
					/* Disable timer. */
					tc_stop(TC_USART, TC_USART_CHN);

					/* Log current size */
					gs_ul_size_usart_buf0 = ul_byte_total;

					/* Stop DMA USART_RX -> force Uart Handler*/
					g_st_usart_rx_packet0.ul_size = 0;
					pdc_rx_init(g_p_usart_pdc0, &g_st_usart_rx_packet0, NULL);
				} else {
					num_bytes_rx_usart0 = ul_byte_total;
				}
			} else {
				num_bytes_rx_usart0 = 0;
			}
		}
#endif

#ifdef CONF_BOARD_USART1_RXD
		if (busart_chn_open[1]) {
			/* Flush PDC buffer. */
			ul_byte_total = USART_BUFFER_SIZE - pdc_read_rx_counter(g_p_usart_pdc1);
			if (ul_byte_total > 0) {
				if (ul_byte_total == num_bytes_rx_usart1) {
					/* Disable timer. */
					tc_stop(TC_USART, TC_USART_CHN);

					/* Log current size */
					gs_ul_size_usart_buf1 = ul_byte_total;

					/* Stop DMA USART_RX -> force Uart Handler*/
					g_st_usart_rx_packet1.ul_size = 0;
					pdc_rx_init(g_p_usart_pdc1, &g_st_usart_rx_packet1, NULL);
				} else {
					num_bytes_rx_usart1 = ul_byte_total;
				}
			} else {
				num_bytes_rx_usart1 = 0;
			}
		}
#endif
	}
}