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);
}
