static void timer_default_config(timer_dev *dev) { timer_adv_reg_map *regs = (dev->regs).adv; const uint16 full_overflow = 0xFFFF; const uint16 half_duty = 0x8FFF; timer_init(dev); timer_pause(dev); regs->CR1 = TIMER_CR1_ARPE; regs->PSC = 1; regs->SR = 0; regs->DIER = 0; regs->EGR = TIMER_EGR_UG; switch (dev->type) { case TIMER_ADVANCED: regs->BDTR = TIMER_BDTR_MOE | TIMER_BDTR_LOCK_OFF; // fall-through case TIMER_GENERAL: timer_set_reload(dev, full_overflow); for (uint8 channel = 1; channel <= 4; channel++) { if (timer_has_cc_channel(dev, channel)) { timer_set_compare(dev, channel, half_duty); timer_oc_set_mode(dev, channel, TIMER_OC_MODE_PWM_1, TIMER_OC_PE); } } // fall-through case TIMER_BASIC: break; } timer_generate_update(dev); timer_resume(dev); }
void Dynamixel::begin(int baud) { //TxDString("[DXL]start begin\r\n"); afio_remap(AFIO_REMAP_USART1);//USART1 -> DXL afio_cfg_debug_ports(AFIO_DEBUG_FULL_SWJ_NO_NJRST); #ifdef BOARD_CM900 //Engineering version case gpio_set_mode(PORT_ENABLE_TXD, PIN_ENABLE_TXD, GPIO_OUTPUT_PP); gpio_set_mode(PORT_ENABLE_RXD, PIN_ENABLE_RXD, GPIO_OUTPUT_PP); gpio_write_bit(PORT_ENABLE_TXD, PIN_ENABLE_TXD, 0 );// TX Disable gpio_write_bit(PORT_ENABLE_RXD, PIN_ENABLE_RXD, 1 );// RX Enable #else gpio_set_mode(PORT_TXRX_DIRECTION, PIN_TXRX_DIRECTION, GPIO_OUTPUT_PP); gpio_write_bit(PORT_TXRX_DIRECTION, PIN_TXRX_DIRECTION, 0 );// RX Enable #endif timer_set_mode(TIMER2, TIMER_CH1, TIMER_OUTPUT_COMPARE); timer_pause(TIMER2); uint16 ovf = timer_get_reload(TIMER2); timer_set_count(TIMER2, min(0, ovf)); timer_set_reload(TIMER2, 30000);//set overflow ovf = timer_get_reload(TIMER2); timer_set_compare(TIMER2, TIMER_CH1, min(1000, ovf)); timer_attach_interrupt(TIMER2, TIMER_CH1, TIM2_IRQHandler); timer_generate_update(TIMER2); timer_resume(TIMER2); dxl_initialize(0, baud); }
/* Transmit the frambuffer with buffersize number of bytes to the LEDs * buffersize = (#LEDs / 16) * 24 */ void neomaple_hard_send(uint8_t *buffer, uint32_t size) { // transmission complete flag, indicate that transmission is taking place WS2812_TC = 0; //WS2812_buffer = buffer; // clear all relevant DMA flags dma_clear_isr_bits(DMA1, DMA_CH2); dma_clear_isr_bits(DMA1, DMA_CH5); dma_clear_isr_bits(DMA1, DMA_CH7); // configure the number of bytes to be transferred by the DMA controller //dma_set_mem_addr(DMA1, DMA_CH5, WS2812_buffer); dma_set_num_transfers(DMA1, DMA_CH2, size); dma_set_num_transfers(DMA1, DMA_CH5, size); dma_set_num_transfers(DMA1, DMA_CH7, size); // clear all TIM2 flags TIMER2->regs.gen->SR = 0; // enable the corresponding DMA channels dma_enable(DMA1, DMA_CH2); dma_enable(DMA1, DMA_CH5); dma_enable(DMA1, DMA_CH7); // IMPORTANT: enable the TIM2 DMA requests AFTER enabling the DMA channels! timer_dma_enable_req(TIMER2, 1); timer_dma_enable_req(TIMER2, 2); timer_dma_enable_req(TIMER2, 0); /* TIM_DMA_Update */ // preload counter with 29 so TIM2 generates UEV directly to start DMA transfer timer_set_count(TIMER2, 29); // start TIM2 timer_resume(TIMER2); }
/** * Non-blocking piezo/headphone beep */ void buzzer_nonblocking_buzz(float time, bool piezo, bool headphones) { // No need to go further if both outputs are // false if (!(piezo || headphones)) return; piezo_out = piezo; headphones_out = headphones; buzz_time = 4100*time*2; // Configure timer2 to fire every N microseconds timer_pause(TIMER2); timer_set_prescaler(TIMER2,1); timer_set_reload(TIMER2,(125*CYCLES_PER_MICROSECOND)/2); // setup interrupt on channel 2 timer_set_mode(TIMER2,TIMER_CH2,TIMER_OUTPUT_COMPARE); timer_set_compare(TIMER2,TIMER_CH2,MAX_RELOAD-1); timer_attach_interrupt(TIMER2,TIMER_CH2,buzzer_handler); // start timer2 buzz_count=0; timer_generate_update(TIMER2); // refresh timer count, prescale, overflow timer_resume(TIMER2); }
bool Servo::attach(uint8 pin, uint16 minPW, uint16 maxPW, int16 minAngle, int16 maxAngle) { timer_dev *tdev = PIN_MAP[pin].timer_device; if (tdev == NULL) { // don't reset any fields or ASSERT(0), to keep driving any // previously attach()ed servo. return false; } if (this->attached()) { this->detach(); } this->pin = pin; this->minPW = minPW; this->maxPW = maxPW; this->minAngle = minAngle; this->maxAngle = maxAngle; pinMode(pin, PWM); timer_pause(tdev); timer_set_prescaler(tdev, SERVO_PRESCALER - 1); // prescaler is 1-based timer_set_reload(tdev, SERVO_OVERFLOW); timer_generate_update(tdev); timer_resume(tdev); return true; }
void DmxClass::send(void) { SerialUSB.println("DMX send"); if (DEBUG_LED) { toggleLED(); } this->headerIndex = 0; this->channelIndex = 0; this->bitIndex = 0; timer_resume(this->dmx_timer); }
int main(int argc, char *argv[]) { sigjmp_buf env; int var=1, i, s; sTimer timers[]={ {20, sighnd, (void *)1, &env, 20}, {15, sighnd, (void *)2, &env, 15}, {13, sighnd, (void *)3, &env, 13}, {10, sighnd, (void *)4, &env, 10}, { 9, sighnd, (void *)5, &env, 9}, { 5, sighnd, (void *)6, &env, 5}, { 1, sighnd, (void *)7, &env, 1} }; printf("\x1b[2J\x1b[0;0H"); for(i=0; i<sizeof(timers)/sizeof(*timers); i++) { if(i!=4) timer_start(&timers[i], 0); printf("%2d:\n", timers[i].jmpcode); } printf("\n"); s=sigsetjmp(env, 1); if(s==0) var=2; else printf("Timer %d expired\n", s); if(s==5) { timer_pause(&timers[1]); printf("Paused timer 15\n"); timer_start(&timers[4], 0); printf("Started timer 9\n"); timer_stop(&timers[2]); printf("Stopped timer 13\n"); } if(s==9) { timer_start(&timers[2], 13); printf("Started timer 13\n"); } if(s==10) { timer_resume(&timers[1]); printf("Resumed timer 15\n"); } getchar(); printf("var=%d\n", var); return 0; }
void DmxClass::begin(uint16 n) { SerialUSB.println("DMX begin"); this->number_of_channels = n; // red, green, and blue are independent channels //SerialUSB.end(); // initializes timer configurations timer_pause(this->dmx_timer); timer_set_prescaler(this->dmx_timer, 1); timer_set_reload(this->dmx_timer, 288); // 4 us = 288 clock pulses @ 72MHz timer_generate_update(this->dmx_timer); // update new reload value timer_set_mode(this->dmx_timer, dmx_timer_ch, TIMER_OUTPUT_COMPARE); timer_set_compare(this->dmx_timer, dmx_timer_ch, 1); // test timer_attach_interrupt(this->dmx_timer, TIMER_CC1_INTERRUPT, dmx_handler_hack); timer_resume(this->dmx_timer); }
//TODO implement timeout uint_fast8_t mdns_resolve(const char *name, mDNS_Resolve_Cb cb, void *data) { if(resolve.cb) // is there a mDNS resolve request already ongoing? return 0; // construct DNS label from mDNS name char *ref = resolve.name; const char *s0 = name; char *s1; char len; while( (s1 = strchr(s0, '.')) ) { len = s1 - s0; *ref++ = len; memcpy(ref, s0, len); ref += len; s0 = s1 + 1; // skip '.' } len = strlen(s0); *ref++ = len; memcpy(ref, s0, len); ref += len; *ref++ = 0x0; // trailing zero resolve.cb = cb; resolve.data = data; // serialize and send mDNS name request uint8_t *head = BUF_O_OFFSET(buf_o_ptr); uint8_t *tail = head; uint16_t id = rand() & 0xffff; tail = _serialize_query(tail, id, 0, 1, 0, 0, 0); tail = _serialize_question(tail, resolve.name, MDNS_TYPE_A, MDNS_CLASS_INET); udp_send(config.mdns.socket.sock, BUF_O_BASE(buf_o_ptr), tail-head); // start timer for timeout timer_pause(mdns_timer); mdns_timer_reconfigure(); timer_resume(mdns_timer); return 1; }
void buzzer_nonblocking_buzz(float time) { buzz_time = 4100*time*2; // Configure timer2 to fire every N microseconds timer_pause(TIMER2); timer_set_prescaler(TIMER2,1); timer_set_reload(TIMER2,(125*CYCLES_PER_MICROSECOND)/2); // setup interrupt on channel 2 timer_set_mode(TIMER2,TIMER_CH2,TIMER_OUTPUT_COMPARE); timer_set_compare(TIMER2,TIMER_CH2,MAX_RELOAD-1); timer_attach_interrupt(TIMER2,TIMER_CH2,buzzer_handler); // start timer2 buzz_count=0; timer_generate_update(TIMER2); // refresh timer count, prescale, overflow timer_resume(TIMER2); }
void timer_restore(Timer* timer, uint16_t seconds_elapsed) { timer->timer = NULL; if (timer->status == TIMER_STATUS_RUNNING) { switch (timer->type) { case TIMER_TYPE_STOPWATCH: timer->current_time += seconds_elapsed; break; case TIMER_TYPE_TIMER: { if (seconds_elapsed >= timer->current_time) { timer->current_time = 0; timer->status = TIMER_STATUS_DONE; } else { timer->current_time -= seconds_elapsed; } break; } } } if (timer->status == TIMER_STATUS_RUNNING) { timer_resume(timer); } }
status_t timers_restore(void) { timers_clear(); if (! persist_exists(STORAGE_TIMER_START)) { return 0; } int block = 0; TimerBlock* timerBlock = malloc(sizeof(TimerBlock)); persist_read_data(STORAGE_TIMER_START, timerBlock, sizeof(TimerBlock)); uint8_t timer_count = timerBlock->count; int seconds_elapsed = 0; if (settings()->resume_timers) { int save_time = timerBlock->time; seconds_elapsed = time(NULL) - save_time; } for (int t = 0; t < timer_count; t += 1) { if (t > 0 && t % TIMER_BLOCK_SIZE == 0) { block += 1; free_safe(timerBlock); timerBlock = malloc(sizeof(TimerBlock)); persist_read_data(STORAGE_TIMER_START + block, timerBlock, sizeof(TimerBlock)); } Timer* timer = timer_clone(&timerBlock->timers[t % TIMER_BLOCK_SIZE]); timers_add(timer); timer->app_timer = NULL; if (! settings()->resume_timers) { timer_reset(timer); continue; } if (TIMER_STATUS_RUNNING != timer->status) { continue; } if (TIMER_DIRECTION_UP == timer->direction) { timer->time_left += seconds_elapsed; } else { if (true == timer->repeat) { timer->time_left -= (seconds_elapsed % timer->length); if (timer->time_left <= 0) { timer->time_left += timer->length; } } else { timer->time_left -= seconds_elapsed; if (0 >= timer->time_left) { timer->time_left = 0; timer->status = TIMER_STATUS_FINISHED; continue; } } } timer_resume(timer); } free_safe(timerBlock); return 0; }
void HardwareTimer::resume(void) { timer_resume(this->dev); }
void speaker_resume(void) { timer_resume(SPEAKER_TIMER); }