void delta_sigma_start(uint32_t period, uint32_t range, uint8_t pins[],
uint8_t n_pins)
{
// Stop the timer during configuration
timer_set_run(FRC1, false);
g_n_pins = n_pins;
for (uint8_t i = 0; i < n_pins; ++i)
{
g_pins[i].gpio_mask = BIT(pins[i]);
g_pins[i].duty = 0;
g_pins[i].acc = 0;
gpio_enable(pins[i], GPIO_OUTPUT);
}
g_range = range;
timer_set_interrupts(FRC1, false);
timer_set_divider(FRC1, TIMER_CLKDIV_256);
if (period > TIMER_FRC1_MAX_LOAD)
{
printf("delta_sigma: period %u too large\n", period);
period = TIMER_FRC1_MAX_LOAD;
}
timer_set_load(FRC1, period);
timer_set_reload(FRC1, true);
_xt_isr_attach(INUM_TIMER_FRC1, timer_isr, NULL);
timer_set_interrupts(FRC1, true);
timer_set_run(FRC1, true);
}
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);
}
void TIM2_init() {
uint32_t SystemCoreClock = 72000000;
uint16_t prescalerValue = (uint16_t) (SystemCoreClock / 24000000) - 1;
rcc_clk_enable(RCC_TIMER2);
/* Time base configuration */
timer_pause(TIMER2);
timer_set_prescaler(TIMER2, prescalerValue);
timer_set_reload(TIMER2, 29); // 800kHz
/* Timing Mode configuration: Channel 1 */
timer_set_mode(TIMER2, 1, TIMER_OUTPUT_COMPARE);
timer_set_compare(TIMER2, 1, 8);
timer_oc_set_mode(TIMER2, 1, TIMER_OC_MODE_FROZEN, ~TIMER_OC_PE);
/* Timing Mode configuration: Channel 2 */
timer_set_mode(TIMER2, 2, TIMER_OUTPUT_COMPARE);
timer_set_compare(TIMER2, 2, 17);
timer_oc_set_mode(TIMER2, 2, TIMER_OC_MODE_PWM_1, ~TIMER_OC_PE);
//timer_resume(TIMER2);
timer_attach_interrupt(TIMER2, TIMER_UPDATE_INTERRUPT, TIM2_IRQHandler);
/* configure TIM2 interrupt */
nvic_irq_set_priority(NVIC_TIMER2, 2);
nvic_irq_enable(NVIC_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;
}
/**
* 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);
}
void busy_wait(unsigned int ds)
{
timer_enable(0);
timer_set_reload(0);
timer_set_counter(get_system_frequency()/10*ds);
timer_enable(1);
while(timer_get());
}
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);
}
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 pwm_start()
{
pwmInfo._onLoad = pwmInfo.dutyCicle * pwmInfo._maxLoad / UINT16_MAX;
pwmInfo._offLoad = pwmInfo._maxLoad - pwmInfo._onLoad;
pwmInfo._step = PERIOD_ON;
// Trigger ON
uint8_t i = 0;
for (; i < pwmInfo.usedPins; ++i)
{
gpio_write(pwmInfo.pins[i].pin, true);
}
timer_set_load(FRC1, pwmInfo._onLoad);
timer_set_reload(FRC1, false);
timer_set_interrupts(FRC1, true);
timer_set_run(FRC1, true);
pwmInfo.running = 1;
}
// Adafruit Modification to change PWM Period/Frequency
void pwmPeriod(uint8 pin, uint32 us)
{
if (pin >= BOARD_NR_GPIO_PINS) return;
timer_dev *dev = PIN_MAP[pin].timer_device;
if (dev == NULL || dev->type == TIMER_BASIC) return;
// Get timer's max speed in hz
uint32 max_speed = rcc_dev_timer_clk_speed(dev->clk_id);
// period in cpu cycles
uint32 cycle = us * (max_speed / 1000000UL);
uint16 prescaler = (uint16) (cycle / TIMER_MAX_RELOAD);
uint16 reload = (uint16) round(cycle / (prescaler+1));
// Re-map compare to preserve duty cycle
uint16 compare = timer_get_compare(dev, PIN_MAP[pin].timer_channel);
compare = map(compare, 0, timer_get_reload(dev), 0, reload);
timer_set_prescaler(dev, prescaler);
timer_set_reload(dev, reload);
timer_set_compare(dev, PIN_MAP[pin].timer_channel, compare);
}
void HardwareTimer::setOverflow(uint16 val) {
timer_set_reload(this->dev, val);
}
void speaker_setOverflow(uint16 val) {
timer_set_reload(SPEAKER_TIMER, val);
}
