zaubentrucker/muele-marlin
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

🎨 Rename HAL timer elements

Browse source
This commit is contained in:
Scott Lahteine 2021-11-27 18:33:32 -06:00 committed by Scott Lahteine
parent d75e7784e5
commit 9b1c0a75e1
51 changed files with 380 additions and 402 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
Marlin/src/HAL/AVR/timers.h
View file

@ -34,14 +34,14 @@ typedef uint16_t hal_timer_t;
#define HAL_TIMER_RATE ((F_CPU) / 8) // i.e., 2MHz or 2.5MHz #define HAL_TIMER_RATE ((F_CPU) / 8) // i.e., 2MHz or 2.5MHz
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 1 #define MF_TIMER_STEP 1
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 0 #define MF_TIMER_TEMP 0
#endif #endif
#define TEMP_TIMER_FREQUENCY ((F_CPU) / 64.0 / 256.0) #define TEMP_TIMER_FREQUENCY ((F_CPU) / 64.0 / 256.0)
@ -64,7 +64,7 @@ typedef uint16_t hal_timer_t;
FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) { FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: case MF_TIMER_STEP:
// waveform generation = 0100 = CTC // waveform generation = 0100 = CTC
SET_WGM(1, CTC_OCRnA); SET_WGM(1, CTC_OCRnA);
@ -84,7 +84,7 @@ FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
TCNT1 = 0; TCNT1 = 0;
break; break;
case TEMP_TIMER_NUM: case MF_TIMER_TEMP:
// Use timer0 for temperature measurement // Use timer0 for temperature measurement
// Interleave temperature interrupt with millies interrupt // Interleave temperature interrupt with millies interrupt
OCR0B = 128; OCR0B = 128;

6
Marlin/src/HAL/DUE/Tone.cpp
View file

@ -38,17 +38,17 @@ volatile static int32_t toggles;
void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) { void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) {
tone_pin = _pin; tone_pin = _pin;
toggles = 2 * frequency * duration / 1000; toggles = 2 * frequency * duration / 1000;
HAL_timer_start(TONE_TIMER_NUM, 2 * frequency); HAL_timer_start(MF_TIMER_TONE, 2 * frequency);
} }
void noTone(const pin_t _pin) { void noTone(const pin_t _pin) {
HAL_timer_disable_interrupt(TONE_TIMER_NUM); HAL_timer_disable_interrupt(MF_TIMER_TONE);
extDigitalWrite(_pin, LOW); extDigitalWrite(_pin, LOW);
} }
HAL_TONE_TIMER_ISR() { HAL_TONE_TIMER_ISR() {
static uint8_t pin_state = 0; static uint8_t pin_state = 0;
HAL_timer_isr_prologue(TONE_TIMER_NUM); HAL_timer_isr_prologue(MF_TIMER_TONE);
if (toggles) { if (toggles) {
toggles--; toggles--;

16
Marlin/src/HAL/DUE/timers.cpp
View file

@ -42,7 +42,7 @@
// Private Variables // Private Variables
// ------------------------ // ------------------------
const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = { const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
{ TC0, 0, TC0_IRQn, 3}, // 0 - [servo timer5] { TC0, 0, TC0_IRQn, 3}, // 0 - [servo timer5]
{ TC0, 1, TC1_IRQn, 0}, // 1 { TC0, 1, TC1_IRQn, 0}, // 1
{ TC0, 2, TC2_IRQn, 2}, // 2 - stepper { TC0, 2, TC2_IRQn, 2}, // 2 - stepper
@ -66,9 +66,9 @@ const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
*/ */
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
Tc *tc = TimerConfig[timer_num].pTimerRegs; Tc *tc = timer_config[timer_num].pTimerRegs;
IRQn_Type irq = TimerConfig[timer_num].IRQ_Id; IRQn_Type irq = timer_config[timer_num].IRQ_Id;
uint32_t channel = TimerConfig[timer_num].channel; uint32_t channel = timer_config[timer_num].channel;
// Disable interrupt, just in case it was already enabled // Disable interrupt, just in case it was already enabled
NVIC_DisableIRQ(irq); NVIC_DisableIRQ(irq);
@ -86,7 +86,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
pmc_set_writeprotect(false); pmc_set_writeprotect(false);
pmc_enable_periph_clk((uint32_t)irq); pmc_enable_periph_clk((uint32_t)irq);
NVIC_SetPriority(irq, TimerConfig [timer_num].priority); NVIC_SetPriority(irq, timer_config[timer_num].priority);
// wave mode, reset counter on match with RC, // wave mode, reset counter on match with RC,
TC_Configure(tc, channel, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK1); TC_Configure(tc, channel, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK1);
@ -105,12 +105,12 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
} }
void HAL_timer_enable_interrupt(const uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
IRQn_Type irq = TimerConfig[timer_num].IRQ_Id; IRQn_Type irq = timer_config[timer_num].IRQ_Id;
NVIC_EnableIRQ(irq); NVIC_EnableIRQ(irq);
} }
void HAL_timer_disable_interrupt(const uint8_t timer_num) { void HAL_timer_disable_interrupt(const uint8_t timer_num) {
IRQn_Type irq = TimerConfig[timer_num].IRQ_Id; IRQn_Type irq = timer_config[timer_num].IRQ_Id;
NVIC_DisableIRQ(irq); NVIC_DisableIRQ(irq);
// We NEED memory barriers to ensure Interrupts are actually disabled! // We NEED memory barriers to ensure Interrupts are actually disabled!
@ -125,7 +125,7 @@ static bool NVIC_GetEnabledIRQ(IRQn_Type IRQn) {
} }
bool HAL_timer_interrupt_enabled(const uint8_t timer_num) { bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
IRQn_Type irq = TimerConfig[timer_num].IRQ_Id; IRQn_Type irq = timer_config[timer_num].IRQ_Id;
return NVIC_GetEnabledIRQ(irq); return NVIC_GetEnabledIRQ(irq);
} }

36
Marlin/src/HAL/DUE/timers.h
View file

@ -37,17 +37,17 @@ typedef uint32_t hal_timer_t;
#define HAL_TIMER_RATE ((F_CPU) / 2) // frequency of timers peripherals #define HAL_TIMER_RATE ((F_CPU) / 2) // frequency of timers peripherals
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 2 // Timer Index for Stepper #define MF_TIMER_STEP 2 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 4 // Timer Index for Temperature #define MF_TIMER_TEMP 4 // Timer Index for Temperature
#endif #endif
#ifndef TONE_TIMER_NUM #ifndef MF_TIMER_TONE
#define TONE_TIMER_NUM 6 // index of timer to use for beeper tones #define MF_TIMER_TONE 6 // index of timer to use for beeper tones
#endif #endif
#define TEMP_TIMER_FREQUENCY 1000 // temperature interrupt frequency #define TEMP_TIMER_FREQUENCY 1000 // temperature interrupt frequency
@ -60,12 +60,12 @@ typedef uint32_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#ifndef HAL_STEP_TIMER_ISR #ifndef HAL_STEP_TIMER_ISR
#define HAL_STEP_TIMER_ISR() void TC2_Handler() #define HAL_STEP_TIMER_ISR() void TC2_Handler()
@ -92,7 +92,7 @@ typedef struct {
// Public Variables // Public Variables
// ------------------------ // ------------------------
extern const tTimerConfig TimerConfig[]; extern const tTimerConfig timer_config[];
// ------------------------ // ------------------------
// Public functions // Public functions
@ -101,17 +101,17 @@ extern const tTimerConfig TimerConfig[];
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency); void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) { FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
const tTimerConfig * const pConfig = &TimerConfig[timer_num]; const tTimerConfig * const pConfig = &timer_config[timer_num];
pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_RC = compare; pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_RC = compare;
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
const tTimerConfig * const pConfig = &TimerConfig[timer_num]; const tTimerConfig * const pConfig = &timer_config[timer_num];
return pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_RC; return pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_RC;
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
const tTimerConfig * const pConfig = &TimerConfig[timer_num]; const tTimerConfig * const pConfig = &timer_config[timer_num];
return pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_CV; return pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_CV;
} }
@ -120,7 +120,7 @@ void HAL_timer_disable_interrupt(const uint8_t timer_num);
bool HAL_timer_interrupt_enabled(const uint8_t timer_num); bool HAL_timer_interrupt_enabled(const uint8_t timer_num);
FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) { FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
const tTimerConfig * const pConfig = &TimerConfig[timer_num]; const tTimerConfig * const pConfig = &timer_config[timer_num];
// Reading the status register clears the interrupt flag // Reading the status register clears the interrupt flag
pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_SR; pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_SR;
} }

6
Marlin/src/HAL/ESP32/HAL.cpp
View file

@ -276,7 +276,7 @@ void analogWrite(pin_t pin, int value) {
idx = numPWMUsed; idx = numPWMUsed;
pwmPins[idx] = pin; pwmPins[idx] = pin;
// Start timer on first use // Start timer on first use
if (idx == 0) HAL_timer_start(PWM_TIMER_NUM, PWM_TIMER_FREQUENCY); if (idx == 0) HAL_timer_start(MF_TIMER_PWM, PWM_TIMER_FREQUENCY);
++numPWMUsed; ++numPWMUsed;
} }
@ -287,7 +287,7 @@ void analogWrite(pin_t pin, int value) {
// Handle PWM timer interrupt // Handle PWM timer interrupt
HAL_PWM_TIMER_ISR() { HAL_PWM_TIMER_ISR() {
HAL_timer_isr_prologue(PWM_TIMER_NUM); HAL_timer_isr_prologue(MF_TIMER_PWM);
static uint8_t count = 0; static uint8_t count = 0;
@ -301,7 +301,7 @@ HAL_PWM_TIMER_ISR() {
// 128 for 7 Bit resolution // 128 for 7 Bit resolution
count = (count + 1) & 0x7F; count = (count + 1) & 0x7F;
HAL_timer_isr_epilogue(PWM_TIMER_NUM); HAL_timer_isr_epilogue(MF_TIMER_PWM);
} }
#endif // ARDUINO_ARCH_ESP32 #endif // ARDUINO_ARCH_ESP32

6
Marlin/src/HAL/ESP32/Tone.cpp
View file

@ -38,16 +38,16 @@ volatile static int32_t toggles;
void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) { void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) {
tone_pin = _pin; tone_pin = _pin;
toggles = 2 * frequency * duration / 1000; toggles = 2 * frequency * duration / 1000;
HAL_timer_start(TONE_TIMER_NUM, 2 * frequency); HAL_timer_start(MF_TIMER_TONE, 2 * frequency);
} }
void noTone(const pin_t _pin) { void noTone(const pin_t _pin) {
HAL_timer_disable_interrupt(TONE_TIMER_NUM); HAL_timer_disable_interrupt(MF_TIMER_TONE);
WRITE(_pin, LOW); WRITE(_pin, LOW);
} }
HAL_TONE_TIMER_ISR() { HAL_TONE_TIMER_ISR() {
HAL_timer_isr_prologue(TONE_TIMER_NUM); HAL_timer_isr_prologue(MF_TIMER_TONE);
if (toggles) { if (toggles) {
toggles--; toggles--;

18
Marlin/src/HAL/ESP32/timers.cpp
View file

@ -41,7 +41,7 @@
static timg_dev_t *TG[2] = {&TIMERG0, &TIMERG1}; static timg_dev_t *TG[2] = {&TIMERG0, &TIMERG1};
const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = { const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
{ TIMER_GROUP_0, TIMER_0, STEPPER_TIMER_PRESCALE, stepTC_Handler }, // 0 - Stepper { TIMER_GROUP_0, TIMER_0, STEPPER_TIMER_PRESCALE, stepTC_Handler }, // 0 - Stepper
{ TIMER_GROUP_0, TIMER_1, TEMP_TIMER_PRESCALE, tempTC_Handler }, // 1 - Temperature { TIMER_GROUP_0, TIMER_1, TEMP_TIMER_PRESCALE, tempTC_Handler }, // 1 - Temperature
{ TIMER_GROUP_1, TIMER_0, PWM_TIMER_PRESCALE, pwmTC_Handler }, // 2 - PWM { TIMER_GROUP_1, TIMER_0, PWM_TIMER_PRESCALE, pwmTC_Handler }, // 2 - PWM
@ -53,7 +53,7 @@ const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
// ------------------------ // ------------------------
void IRAM_ATTR timer_isr(void *para) { void IRAM_ATTR timer_isr(void *para) {
const tTimerConfig& timer = TimerConfig[(int)para]; const tTimerConfig& timer = timer_config[(int)para];
// Retrieve the interrupt status and the counter value // Retrieve the interrupt status and the counter value
// from the timer that reported the interrupt // from the timer that reported the interrupt
@ -82,7 +82,7 @@ void IRAM_ATTR timer_isr(void *para) {
* @param frequency frequency of the timer * @param frequency frequency of the timer
*/ */
void HAL_timer_start(const uint8_t timer_num, uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, uint32_t frequency) {
const tTimerConfig timer = TimerConfig[timer_num]; const tTimerConfig timer = timer_config[timer_num];
timer_config_t config; timer_config_t config;
config.divider = timer.divider; config.divider = timer.divider;
@ -115,7 +115,7 @@ void HAL_timer_start(const uint8_t timer_num, uint32_t frequency) {
* @param count threshold at which the interrupt is triggered * @param count threshold at which the interrupt is triggered
*/ */
void HAL_timer_set_compare(const uint8_t timer_num, hal_timer_t count) { void HAL_timer_set_compare(const uint8_t timer_num, hal_timer_t count) {
const tTimerConfig timer = TimerConfig[timer_num]; const tTimerConfig timer = timer_config[timer_num];
timer_set_alarm_value(timer.group, timer.idx, count); timer_set_alarm_value(timer.group, timer.idx, count);
} }
@ -125,7 +125,7 @@ void HAL_timer_set_compare(const uint8_t timer_num, hal_timer_t count) {
* @return the timer current threshold for the alarm to be triggered * @return the timer current threshold for the alarm to be triggered
*/ */
hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) { hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
const tTimerConfig timer = TimerConfig[timer_num]; const tTimerConfig timer = timer_config[timer_num];
uint64_t alarm_value; uint64_t alarm_value;
timer_get_alarm_value(timer.group, timer.idx, &alarm_value); timer_get_alarm_value(timer.group, timer.idx, &alarm_value);
@ -139,7 +139,7 @@ hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
* @return the current counter of the alarm * @return the current counter of the alarm
*/ */
hal_timer_t HAL_timer_get_count(const uint8_t timer_num) { hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
const tTimerConfig timer = TimerConfig[timer_num]; const tTimerConfig timer = timer_config[timer_num];
uint64_t counter_value; uint64_t counter_value;
timer_get_counter_value(timer.group, timer.idx, &counter_value); timer_get_counter_value(timer.group, timer.idx, &counter_value);
return counter_value; return counter_value;
@ -150,7 +150,7 @@ hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
* @param timer_num timer number to enable interrupts on * @param timer_num timer number to enable interrupts on
*/ */
void HAL_timer_enable_interrupt(const uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
//const tTimerConfig timer = TimerConfig[timer_num]; //const tTimerConfig timer = timer_config[timer_num];
//timer_enable_intr(timer.group, timer.idx); //timer_enable_intr(timer.group, timer.idx);
} }
@ -159,12 +159,12 @@ void HAL_timer_enable_interrupt(const uint8_t timer_num) {
* @param timer_num timer number to disable interrupts on * @param timer_num timer number to disable interrupts on
*/ */
void HAL_timer_disable_interrupt(const uint8_t timer_num) { void HAL_timer_disable_interrupt(const uint8_t timer_num) {
//const tTimerConfig timer = TimerConfig[timer_num]; //const tTimerConfig timer = timer_config[timer_num];
//timer_disable_intr(timer.group, timer.idx); //timer_disable_intr(timer.group, timer.idx);
} }
bool HAL_timer_interrupt_enabled(const uint8_t timer_num) { bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
const tTimerConfig timer = TimerConfig[timer_num]; const tTimerConfig timer = timer_config[timer_num];
return TG[timer.group]->int_ena.val | BIT(timer_num); return TG[timer.group]->int_ena.val | BIT(timer_num);
} }

32
Marlin/src/HAL/ESP32/timers.h
View file

@ -32,20 +32,20 @@
typedef uint64_t hal_timer_t; typedef uint64_t hal_timer_t;
#define HAL_TIMER_TYPE_MAX 0xFFFFFFFFFFFFFFFFULL #define HAL_TIMER_TYPE_MAX 0xFFFFFFFFFFFFFFFFULL
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 0 // Timer Index for Stepper #define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 1 // Timer Index for Temperature #define MF_TIMER_TEMP 1 // Timer Index for Temperature
#endif #endif
#ifndef PWM_TIMER_NUM #ifndef MF_TIMER_PWM
#define PWM_TIMER_NUM 2 // index of timer to use for PWM outputs #define MF_TIMER_PWM 2 // index of timer to use for PWM outputs
#endif #endif
#ifndef TONE_TIMER_NUM #ifndef MF_TIMER_TONE
#define TONE_TIMER_NUM 3 // index of timer for beeper tones #define MF_TIMER_TONE 3 // index of timer for beeper tones
#endif #endif
#define HAL_TIMER_RATE APB_CLK_FREQ // frequency of timer peripherals #define HAL_TIMER_RATE APB_CLK_FREQ // frequency of timer peripherals
@ -79,12 +79,12 @@ typedef uint64_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#ifndef HAL_TEMP_TIMER_ISR #ifndef HAL_TEMP_TIMER_ISR
#define HAL_TEMP_TIMER_ISR() extern "C" void tempTC_Handler() #define HAL_TEMP_TIMER_ISR() extern "C" void tempTC_Handler()
@ -121,7 +121,7 @@ typedef struct {
// Public Variables // Public Variables
// ------------------------ // ------------------------
extern const tTimerConfig TimerConfig[]; extern const tTimerConfig timer_config[];
// ------------------------ // ------------------------
// Public functions // Public functions

23
Marlin/src/HAL/LINUX/timers.h
View file

@ -37,14 +37,14 @@ typedef uint32_t hal_timer_t;
#define HAL_TIMER_RATE ((SystemCoreClock) / 4) // frequency of timers peripherals #define HAL_TIMER_RATE ((SystemCoreClock) / 4) // frequency of timers peripherals
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 0 // Timer Index for Stepper #define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 1 // Timer Index for Temperature #define MF_TIMER_TEMP 1 // Timer Index for Temperature
#endif #endif
#define TEMP_TIMER_RATE 1000000 #define TEMP_TIMER_RATE 1000000
@ -58,12 +58,12 @@ typedef uint32_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#ifndef HAL_STEP_TIMER_ISR #ifndef HAL_STEP_TIMER_ISR
#define HAL_STEP_TIMER_ISR() extern "C" void TIMER0_IRQHandler() #define HAL_STEP_TIMER_ISR() extern "C" void TIMER0_IRQHandler()
@ -77,7 +77,6 @@ typedef uint32_t hal_timer_t;
#define HAL_PWM_TIMER_ISR() extern "C" void TIMER3_IRQHandler() #define HAL_PWM_TIMER_ISR() extern "C" void TIMER3_IRQHandler()
#define HAL_PWM_TIMER_IRQn #define HAL_PWM_TIMER_IRQn
void HAL_timer_init(); void HAL_timer_init();
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency); void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);

4
Marlin/src/HAL/LPC1768/timers.cpp
View file

@ -40,7 +40,7 @@ void HAL_timer_init() {
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP:
LPC_TIM0->MCR = _BV(SBIT_MR0I) | _BV(SBIT_MR0R); // Match on MR0, reset on MR0, interrupts when NVIC enables them LPC_TIM0->MCR = _BV(SBIT_MR0I) | _BV(SBIT_MR0R); // Match on MR0, reset on MR0, interrupts when NVIC enables them
LPC_TIM0->MR0 = uint32_t(STEPPER_TIMER_RATE) / frequency; // Match value (period) to set frequency LPC_TIM0->MR0 = uint32_t(STEPPER_TIMER_RATE) / frequency; // Match value (period) to set frequency
LPC_TIM0->TCR = _BV(SBIT_CNTEN); // Counter Enable LPC_TIM0->TCR = _BV(SBIT_CNTEN); // Counter Enable
@ -49,7 +49,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
NVIC_EnableIRQ(TIMER0_IRQn); NVIC_EnableIRQ(TIMER0_IRQn);
break; break;
case 1: case MF_TIMER_TEMP:
LPC_TIM1->MCR = _BV(SBIT_MR0I) | _BV(SBIT_MR0R); // Match on MR0, reset on MR0, interrupts when NVIC enables them LPC_TIM1->MCR = _BV(SBIT_MR0I) | _BV(SBIT_MR0R); // Match on MR0, reset on MR0, interrupts when NVIC enables them
LPC_TIM1->MR0 = uint32_t(TEMP_TIMER_RATE) / frequency; LPC_TIM1->MR0 = uint32_t(TEMP_TIMER_RATE) / frequency;
LPC_TIM1->TCR = _BV(SBIT_CNTEN); // Counter Enable LPC_TIM1->TCR = _BV(SBIT_CNTEN); // Counter Enable

62
Marlin/src/HAL/LPC1768/timers.h
View file

@ -60,17 +60,17 @@ typedef uint32_t hal_timer_t;
#define HAL_TIMER_RATE ((F_CPU) / 4) // frequency of timers peripherals #define HAL_TIMER_RATE ((F_CPU) / 4) // frequency of timers peripherals
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 0 // Timer Index for Stepper #define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 1 // Timer Index for Temperature #define MF_TIMER_TEMP 1 // Timer Index for Temperature
#endif #endif
#ifndef PWM_TIMER_NUM #ifndef MF_TIMER_PWM
#define PWM_TIMER_NUM 3 // Timer Index for PWM #define MF_TIMER_PWM 3 // Timer Index for PWM
#endif #endif
#define TEMP_TIMER_RATE 1000000 #define TEMP_TIMER_RATE 1000000
@ -84,23 +84,23 @@ typedef uint32_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#ifndef HAL_STEP_TIMER_ISR #ifndef HAL_STEP_TIMER_ISR
#define HAL_STEP_TIMER_ISR() _HAL_TIMER_ISR(STEP_TIMER_NUM) #define HAL_STEP_TIMER_ISR() _HAL_TIMER_ISR(MF_TIMER_STEP)
#endif #endif
#ifndef HAL_TEMP_TIMER_ISR #ifndef HAL_TEMP_TIMER_ISR
#define HAL_TEMP_TIMER_ISR() _HAL_TIMER_ISR(TEMP_TIMER_NUM) #define HAL_TEMP_TIMER_ISR() _HAL_TIMER_ISR(MF_TIMER_TEMP)
#endif #endif
// Timer references by index // Timer references by index
#define STEP_TIMER_PTR _HAL_TIMER(STEP_TIMER_NUM) #define STEP_TIMER_PTR _HAL_TIMER(MF_TIMER_STEP)
#define TEMP_TIMER_PTR _HAL_TIMER(TEMP_TIMER_NUM) #define TEMP_TIMER_PTR _HAL_TIMER(MF_TIMER_TEMP)
// ------------------------ // ------------------------
// Public functions // Public functions
@ -110,38 +110,38 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) { FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
switch (timer_num) { switch (timer_num) {
case 0: STEP_TIMER_PTR->MR0 = compare; break; // Stepper Timer Match Register 0 case MF_TIMER_STEP: STEP_TIMER_PTR->MR0 = compare; break; // Stepper Timer Match Register 0
case 1: TEMP_TIMER_PTR->MR0 = compare; break; // Temp Timer Match Register 0 case MF_TIMER_TEMP: TEMP_TIMER_PTR->MR0 = compare; break; // Temp Timer Match Register 0
} }
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return STEP_TIMER_PTR->MR0; // Stepper Timer Match Register 0 case MF_TIMER_STEP: return STEP_TIMER_PTR->MR0; // Stepper Timer Match Register 0
case 1: return TEMP_TIMER_PTR->MR0; // Temp Timer Match Register 0 case MF_TIMER_TEMP: return TEMP_TIMER_PTR->MR0; // Temp Timer Match Register 0
} }
return 0; return 0;
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return STEP_TIMER_PTR->TC; // Stepper Timer Count case MF_TIMER_STEP: return STEP_TIMER_PTR->TC; // Stepper Timer Count
case 1: return TEMP_TIMER_PTR->TC; // Temp Timer Count case MF_TIMER_TEMP: return TEMP_TIMER_PTR->TC; // Temp Timer Count
} }
return 0; return 0;
} }
FORCE_INLINE static void HAL_timer_enable_interrupt(const uint8_t timer_num) { FORCE_INLINE static void HAL_timer_enable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: NVIC_EnableIRQ(TIMER0_IRQn); break; // Enable interrupt handler case MF_TIMER_STEP: NVIC_EnableIRQ(TIMER0_IRQn); break; // Enable interrupt handler
case 1: NVIC_EnableIRQ(TIMER1_IRQn); break; // Enable interrupt handler case MF_TIMER_TEMP: NVIC_EnableIRQ(TIMER1_IRQn); break; // Enable interrupt handler
} }
} }
FORCE_INLINE static void HAL_timer_disable_interrupt(const uint8_t timer_num) { FORCE_INLINE static void HAL_timer_disable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: NVIC_DisableIRQ(TIMER0_IRQn); break; // Disable interrupt handler case MF_TIMER_STEP: NVIC_DisableIRQ(TIMER0_IRQn); break; // Disable interrupt handler
case 1: NVIC_DisableIRQ(TIMER1_IRQn); break; // Disable interrupt handler case MF_TIMER_TEMP: NVIC_DisableIRQ(TIMER1_IRQn); break; // Disable interrupt handler
} }
// We NEED memory barriers to ensure Interrupts are actually disabled! // We NEED memory barriers to ensure Interrupts are actually disabled!
@ -157,16 +157,16 @@ FORCE_INLINE static bool NVIC_GetEnableIRQ(IRQn_Type IRQn) {
FORCE_INLINE static bool HAL_timer_interrupt_enabled(const uint8_t timer_num) { FORCE_INLINE static bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return NVIC_GetEnableIRQ(TIMER0_IRQn); // Check if interrupt is enabled or not case MF_TIMER_STEP: return NVIC_GetEnableIRQ(TIMER0_IRQn); // Check if interrupt is enabled or not
case 1: return NVIC_GetEnableIRQ(TIMER1_IRQn); // Check if interrupt is enabled or not case MF_TIMER_TEMP: return NVIC_GetEnableIRQ(TIMER1_IRQn); // Check if interrupt is enabled or not
} }
return false; return false;
} }
FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) { FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: SBI(STEP_TIMER_PTR->IR, SBIT_CNTEN); break; case MF_TIMER_STEP: SBI(STEP_TIMER_PTR->IR, SBIT_CNTEN); break;
case 1: SBI(TEMP_TIMER_PTR->IR, SBIT_CNTEN); break; case MF_TIMER_TEMP: SBI(TEMP_TIMER_PTR->IR, SBIT_CNTEN); break;
} }
} }

26
Marlin/src/HAL/NATIVE_SIM/timers.h
View file

@ -37,17 +37,17 @@ typedef uint64_t hal_timer_t;
#define HAL_TIMER_RATE ((SystemCoreClock) / 4) // frequency of timers peripherals #define HAL_TIMER_RATE ((SystemCoreClock) / 4) // frequency of timers peripherals
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 0 // Timer Index for Stepper #define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 1 // Timer Index for Temperature #define MF_TIMER_TEMP 1 // Timer Index for Temperature
#endif #endif
#ifndef SYSTICK_TIMER_NUM #ifndef MF_TIMER_SYSTICK
#define SYSTICK_TIMER_NUM 2 // Timer Index for Systick #define MF_TIMER_SYSTICK 2 // Timer Index for Systick
#endif #endif
#define SYSTICK_TIMER_FREQUENCY 1000 #define SYSTICK_TIMER_FREQUENCY 1000
@ -62,12 +62,12 @@ typedef uint64_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#ifndef HAL_STEP_TIMER_ISR #ifndef HAL_STEP_TIMER_ISR
#define HAL_STEP_TIMER_ISR() extern "C" void TIMER0_IRQHandler() #define HAL_STEP_TIMER_ISR() extern "C" void TIMER0_IRQHandler()

8
Marlin/src/HAL/SAMD51/Servo.cpp
View file

@ -53,7 +53,7 @@
static volatile int8_t currentServoIndex[_Nbr_16timers]; // index for the servo being pulsed for each timer (or -1 if refresh interval) static volatile int8_t currentServoIndex[_Nbr_16timers]; // index for the servo being pulsed for each timer (or -1 if refresh interval)
FORCE_INLINE static uint16_t getTimerCount() { FORCE_INLINE static uint16_t getTimerCount() {
Tc * const tc = TimerConfig[SERVO_TC].pTc; Tc * const tc = timer_config[SERVO_TC].pTc;
tc->COUNT16.CTRLBSET.reg = TC_CTRLBCLR_CMD_READSYNC; tc->COUNT16.CTRLBSET.reg = TC_CTRLBCLR_CMD_READSYNC;
SYNC(tc->COUNT16.SYNCBUSY.bit.CTRLB || tc->COUNT16.SYNCBUSY.bit.COUNT); SYNC(tc->COUNT16.SYNCBUSY.bit.CTRLB || tc->COUNT16.SYNCBUSY.bit.COUNT);
@ -65,7 +65,7 @@ FORCE_INLINE static uint16_t getTimerCount() {
// Interrupt handler for the TC // Interrupt handler for the TC
// ---------------------------- // ----------------------------
HAL_SERVO_TIMER_ISR() { HAL_SERVO_TIMER_ISR() {
Tc * const tc = TimerConfig[SERVO_TC].pTc; Tc * const tc = timer_config[SERVO_TC].pTc;
const timer16_Sequence_t timer = const timer16_Sequence_t timer =
#ifndef _useTimer1 #ifndef _useTimer1
_timer2 _timer2
@ -125,7 +125,7 @@ HAL_SERVO_TIMER_ISR() {
} }
void initISR(timer16_Sequence_t timer) { void initISR(timer16_Sequence_t timer) {
Tc * const tc = TimerConfig[SERVO_TC].pTc; Tc * const tc = timer_config[SERVO_TC].pTc;
const uint8_t tcChannel = TIMER_TCCHANNEL(timer); const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
static bool initialized = false; // Servo TC has been initialized static bool initialized = false; // Servo TC has been initialized
@ -202,7 +202,7 @@ void initISR(timer16_Sequence_t timer) {
} }
void finISR(timer16_Sequence_t timer) { void finISR(timer16_Sequence_t timer) {
Tc * const tc = TimerConfig[SERVO_TC].pTc; Tc * const tc = timer_config[SERVO_TC].pTc;
const uint8_t tcChannel = TIMER_TCCHANNEL(timer); const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
// Disable the match channel interrupt request // Disable the match channel interrupt request

2
Marlin/src/HAL/SAMD51/inc/SanityCheck.h
View file

@ -36,7 +36,7 @@
#error "OnBoard SPI BUS can't be shared with other devices." #error "OnBoard SPI BUS can't be shared with other devices."
#endif #endif
#if SERVO_TC == RTC_TIMER_NUM #if SERVO_TC == MF_TIMER_RTC
#error "Servos can't use RTC timer" #error "Servos can't use RTC timer"
#endif #endif

20
Marlin/src/HAL/SAMD51/timers.cpp
View file

@ -31,13 +31,13 @@
// Local defines // Local defines
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
#define NUM_HARDWARE_TIMERS 8 #define NUM_HARDWARE_TIMERS 9
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Private Variables // Private Variables
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
const tTimerConfig TimerConfig[NUM_HARDWARE_TIMERS+1] = { const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
{ {.pTc=TC0}, TC0_IRQn, TC_PRIORITY(0) }, // 0 - stepper (assigned priority 2) { {.pTc=TC0}, TC0_IRQn, TC_PRIORITY(0) }, // 0 - stepper (assigned priority 2)
{ {.pTc=TC1}, TC1_IRQn, TC_PRIORITY(1) }, // 1 - stepper (needed by 32 bit timers) { {.pTc=TC1}, TC1_IRQn, TC_PRIORITY(1) }, // 1 - stepper (needed by 32 bit timers)
{ {.pTc=TC2}, TC2_IRQn, 5 }, // 2 - tone (reserved by framework and fixed assigned priority 5) { {.pTc=TC2}, TC2_IRQn, 5 }, // 2 - tone (reserved by framework and fixed assigned priority 5)
@ -67,13 +67,13 @@ FORCE_INLINE void Disable_Irq(IRQn_Type irq) {
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
IRQn_Type irq = TimerConfig[timer_num].IRQ_Id; IRQn_Type irq = timer_config[timer_num].IRQ_Id;
// Disable interrupt, just in case it was already enabled // Disable interrupt, just in case it was already enabled
Disable_Irq(irq); Disable_Irq(irq);
if (timer_num == RTC_TIMER_NUM) { if (timer_num == MF_TIMER_RTC) {
Rtc * const rtc = TimerConfig[timer_num].pRtc; Rtc * const rtc = timer_config[timer_num].pRtc;
// Disable timer interrupt // Disable timer interrupt
rtc->MODE0.INTENCLR.reg = RTC_MODE0_INTENCLR_CMP0; rtc->MODE0.INTENCLR.reg = RTC_MODE0_INTENCLR_CMP0;
@ -101,7 +101,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
SYNC(rtc->MODE0.SYNCBUSY.bit.ENABLE); SYNC(rtc->MODE0.SYNCBUSY.bit.ENABLE);
} }
else { else {
Tc * const tc = TimerConfig[timer_num].pTc; Tc * const tc = timer_config[timer_num].pTc;
// Disable timer interrupt // Disable timer interrupt
tc->COUNT32.INTENCLR.reg = TC_INTENCLR_OVF; // disable overflow interrupt tc->COUNT32.INTENCLR.reg = TC_INTENCLR_OVF; // disable overflow interrupt
@ -141,17 +141,17 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
} }
// Finally, enable IRQ // Finally, enable IRQ
NVIC_SetPriority(irq, TimerConfig[timer_num].priority); NVIC_SetPriority(irq, timer_config[timer_num].priority);
NVIC_EnableIRQ(irq); NVIC_EnableIRQ(irq);
} }
void HAL_timer_enable_interrupt(const uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
const IRQn_Type irq = TimerConfig[timer_num].IRQ_Id; const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
NVIC_EnableIRQ(irq); NVIC_EnableIRQ(irq);
} }
void HAL_timer_disable_interrupt(const uint8_t timer_num) { void HAL_timer_disable_interrupt(const uint8_t timer_num) {
const IRQn_Type irq = TimerConfig[timer_num].IRQ_Id; const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
Disable_Irq(irq); Disable_Irq(irq);
} }
@ -161,7 +161,7 @@ static bool NVIC_GetEnabledIRQ(IRQn_Type IRQn) {
} }
bool HAL_timer_interrupt_enabled(const uint8_t timer_num) { bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
const IRQn_Type irq = TimerConfig[timer_num].IRQ_Id; const IRQn_Type irq = timer_config[timer_num].IRQ_Id;
return NVIC_GetEnabledIRQ(irq); return NVIC_GetEnabledIRQ(irq);
} }

62
Marlin/src/HAL/SAMD51/timers.h
View file

@ -25,21 +25,22 @@
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Defines // Defines
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
#define RTC_TIMER_NUM 8 // This is not a TC but a RTC
typedef uint32_t hal_timer_t; typedef uint32_t hal_timer_t;
#define HAL_TIMER_TYPE_MAX 0xFFFFFFFF #define HAL_TIMER_TYPE_MAX 0xFFFFFFFF
#define HAL_TIMER_RATE F_CPU // frequency of timers peripherals #define HAL_TIMER_RATE F_CPU // frequency of timers peripherals
#ifndef STEP_TIMER_NUM #define MF_TIMER_RTC 8 // This is not a TC but a RTC
#define STEP_TIMER_NUM 0 // Timer Index for Stepper
#ifndef MF_TIMER_STEP
#define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM RTC_TIMER_NUM // Timer Index for Temperature #define MF_TIMER_TEMP MF_TIMER_RTC // Timer Index for Temperature
#endif #endif
#define TEMP_TIMER_FREQUENCY 1000 // temperature interrupt frequency #define TEMP_TIMER_FREQUENCY 1000 // temperature interrupt frequency
@ -52,30 +53,29 @@ typedef uint32_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#define TC_PRIORITY(t) t == SERVO_TC ? 1 \ #define TC_PRIORITY(t) ( t == SERVO_TC ? 1 \
: (t == STEP_TIMER_NUM || t == PULSE_TIMER_NUM) ? 2 \ : (t == MF_TIMER_STEP || t == MF_TIMER_PULSE) ? 2 \
: (t == TEMP_TIMER_NUM) ? 6 \ : (t == MF_TIMER_TEMP) ? 6 : 7 )
: 7
#define _TC_HANDLER(t) void TC##t##_Handler() #define _TC_HANDLER(t) void TC##t##_Handler()
#define TC_HANDLER(t) _TC_HANDLER(t) #define TC_HANDLER(t) _TC_HANDLER(t)
#ifndef HAL_STEP_TIMER_ISR #ifndef HAL_STEP_TIMER_ISR
#define HAL_STEP_TIMER_ISR() TC_HANDLER(STEP_TIMER_NUM) #define HAL_STEP_TIMER_ISR() TC_HANDLER(MF_TIMER_STEP)
#endif #endif
#if STEP_TIMER_NUM != PULSE_TIMER_NUM #if MF_TIMER_STEP != MF_TIMER_PULSE
#define HAL_PULSE_TIMER_ISR() TC_HANDLER(PULSE_TIMER_NUM) #define HAL_PULSE_TIMER_ISR() TC_HANDLER(MF_TIMER_PULSE)
#endif #endif
#if TEMP_TIMER_NUM == RTC_TIMER_NUM #if MF_TIMER_TEMP == MF_TIMER_RTC
#define HAL_TEMP_TIMER_ISR() void RTC_Handler() #define HAL_TEMP_TIMER_ISR() void RTC_Handler()
#else #else
#define HAL_TEMP_TIMER_ISR() TC_HANDLER(TEMP_TIMER_NUM) #define HAL_TEMP_TIMER_ISR() TC_HANDLER(MF_TIMER_TEMP)
#endif #endif
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@ -95,7 +95,7 @@ typedef struct {
// Public Variables // Public Variables
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
extern const tTimerConfig TimerConfig[]; extern const tTimerConfig timer_config[];
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Public functions // Public functions
@ -104,20 +104,20 @@ extern const tTimerConfig TimerConfig[];
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency); void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) { FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
// Should never be called with timer RTC_TIMER_NUM // Should never be called with timer MF_TIMER_RTC
Tc * const tc = TimerConfig[timer_num].pTc; Tc * const tc = timer_config[timer_num].pTc;
tc->COUNT32.CC[0].reg = compare; tc->COUNT32.CC[0].reg = compare;
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
// Should never be called with timer RTC_TIMER_NUM // Should never be called with timer MF_TIMER_RTC
Tc * const tc = TimerConfig[timer_num].pTc; Tc * const tc = timer_config[timer_num].pTc;
return (hal_timer_t)tc->COUNT32.CC[0].reg; return (hal_timer_t)tc->COUNT32.CC[0].reg;
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
// Should never be called with timer RTC_TIMER_NUM // Should never be called with timer MF_TIMER_RTC
Tc * const tc = TimerConfig[timer_num].pTc; Tc * const tc = timer_config[timer_num].pTc;
tc->COUNT32.CTRLBSET.reg = TC_CTRLBCLR_CMD_READSYNC; tc->COUNT32.CTRLBSET.reg = TC_CTRLBCLR_CMD_READSYNC;
SYNC(tc->COUNT32.SYNCBUSY.bit.CTRLB || tc->COUNT32.SYNCBUSY.bit.COUNT); SYNC(tc->COUNT32.SYNCBUSY.bit.CTRLB || tc->COUNT32.SYNCBUSY.bit.COUNT);
return tc->COUNT32.COUNT.reg; return tc->COUNT32.COUNT.reg;
@ -128,13 +128,13 @@ void HAL_timer_disable_interrupt(const uint8_t timer_num);
bool HAL_timer_interrupt_enabled(const uint8_t timer_num); bool HAL_timer_interrupt_enabled(const uint8_t timer_num);
FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) { FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
if (timer_num == RTC_TIMER_NUM) { if (timer_num == MF_TIMER_RTC) {
Rtc * const rtc = TimerConfig[timer_num].pRtc; Rtc * const rtc = timer_config[timer_num].pRtc;
// Clear interrupt flag // Clear interrupt flag
rtc->MODE0.INTFLAG.reg = RTC_MODE0_INTFLAG_CMP0; rtc->MODE0.INTFLAG.reg = RTC_MODE0_INTFLAG_CMP0;
} }
else { else {
Tc * const tc = TimerConfig[timer_num].pTc; Tc * const tc = timer_config[timer_num].pTc;
// Clear interrupt flag // Clear interrupt flag
tc->COUNT32.INTFLAG.reg = TC_INTFLAG_OVF; tc->COUNT32.INTFLAG.reg = TC_INTFLAG_OVF;
} }

5
Marlin/src/HAL/STM32/fast_pwm.cpp
View file

@ -70,9 +70,6 @@ void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255
void set_pwm_frequency(const pin_t pin, int f_desired) { void set_pwm_frequency(const pin_t pin, int f_desired) {
if (!PWM_PIN(pin)) return; // Don't proceed if no hardware timer if (!PWM_PIN(pin)) return; // Don't proceed if no hardware timer
HardwareTimer *HT;
PinName pin_name = digitalPinToPinName(pin);
TIM_TypeDef *Instance = (TIM_TypeDef *)pinmap_peripheral(pin_name, PinMap_PWM); // Get HAL timer instance
const PinName pin_name = digitalPinToPinName(pin); const PinName pin_name = digitalPinToPinName(pin);
TIM_TypeDef * const Instance = (TIM_TypeDef *)pinmap_peripheral(pin_name, PinMap_PWM); // Get HAL timer instance TIM_TypeDef * const Instance = (TIM_TypeDef *)pinmap_peripheral(pin_name, PinMap_PWM); // Get HAL timer instance
@ -87,7 +84,7 @@ void set_pwm_frequency(const pin_t pin, int f_desired) {
if (HardwareTimer_Handle[index] == nullptr) // If frequency is set before duty we need to create a handle here. if (HardwareTimer_Handle[index] == nullptr) // If frequency is set before duty we need to create a handle here.
HardwareTimer_Handle[index]->__this = new HardwareTimer((TIM_TypeDef *)pinmap_peripheral(pin_name, PinMap_PWM)); HardwareTimer_Handle[index]->__this = new HardwareTimer((TIM_TypeDef *)pinmap_peripheral(pin_name, PinMap_PWM));
HT = (HardwareTimer *)(HardwareTimer_Handle[index]->__this); HardwareTimer * const HT = (HardwareTimer *)(HardwareTimer_Handle[index]->__this);
timer_freq[index] = f_desired; // Save the last frequency so duty will not set the default for this timer number. timer_freq[index] = f_desired; // Save the last frequency so duty will not set the default for this timer number.
HT->setOverflow(f_desired, HERTZ_FORMAT); HT->setOverflow(f_desired, HERTZ_FORMAT);
} }

14
Marlin/src/HAL/STM32/timers.cpp
View file

@ -110,7 +110,7 @@ HardwareTimer *timer_instance[NUM_HARDWARE_TIMERS] = { nullptr };
uint32_t GetStepperTimerClkFreq() { uint32_t GetStepperTimerClkFreq() {
// Timer input clocks vary between devices, and in some cases between timers on the same device. // Timer input clocks vary between devices, and in some cases between timers on the same device.
// Retrieve at runtime to ensure device compatibility. Cache result to avoid repeated overhead. // Retrieve at runtime to ensure device compatibility. Cache result to avoid repeated overhead.
static uint32_t clkfreq = timer_instance[STEP_TIMER_NUM]->getTimerClkFreq(); static uint32_t clkfreq = timer_instance[MF_TIMER_STEP]->getTimerClkFreq();
return clkfreq; return clkfreq;
} }
@ -118,7 +118,7 @@ uint32_t GetStepperTimerClkFreq() {
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
if (!HAL_timer_initialized(timer_num)) { if (!HAL_timer_initialized(timer_num)) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: // STEPPER TIMER - use a 32bit timer if possible case MF_TIMER_STEP: // STEPPER TIMER - use a 32bit timer if possible
timer_instance[timer_num] = new HardwareTimer(STEP_TIMER_DEV); timer_instance[timer_num] = new HardwareTimer(STEP_TIMER_DEV);
/* Set the prescaler to the final desired value. /* Set the prescaler to the final desired value.
* This will change the effective ISR callback frequency but when * This will change the effective ISR callback frequency but when
@ -137,7 +137,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
timer_instance[timer_num]->setPrescaleFactor(STEPPER_TIMER_PRESCALE); //the -1 is done internally timer_instance[timer_num]->setPrescaleFactor(STEPPER_TIMER_PRESCALE); //the -1 is done internally
timer_instance[timer_num]->setOverflow(_MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (HAL_TIMER_RATE) / (STEPPER_TIMER_PRESCALE) /* /frequency */), TICK_FORMAT); timer_instance[timer_num]->setOverflow(_MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (HAL_TIMER_RATE) / (STEPPER_TIMER_PRESCALE) /* /frequency */), TICK_FORMAT);
break; break;
case TEMP_TIMER_NUM: // TEMP TIMER - any available 16bit timer case MF_TIMER_TEMP: // TEMP TIMER - any available 16bit timer
timer_instance[timer_num] = new HardwareTimer(TEMP_TIMER_DEV); timer_instance[timer_num] = new HardwareTimer(TEMP_TIMER_DEV);
// The prescale factor is computed automatically for HERTZ_FORMAT // The prescale factor is computed automatically for HERTZ_FORMAT
timer_instance[timer_num]->setOverflow(frequency, HERTZ_FORMAT); timer_instance[timer_num]->setOverflow(frequency, HERTZ_FORMAT);
@ -157,10 +157,10 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
// These calls can be removed and replaced with // These calls can be removed and replaced with
// timer_instance[timer_num]->setInterruptPriority // timer_instance[timer_num]->setInterruptPriority
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: case MF_TIMER_STEP:
timer_instance[timer_num]->setInterruptPriority(STEP_TIMER_IRQ_PRIO, 0); timer_instance[timer_num]->setInterruptPriority(STEP_TIMER_IRQ_PRIO, 0);
break; break;
case TEMP_TIMER_NUM: case MF_TIMER_TEMP:
timer_instance[timer_num]->setInterruptPriority(TEMP_TIMER_IRQ_PRIO, 0); timer_instance[timer_num]->setInterruptPriority(TEMP_TIMER_IRQ_PRIO, 0);
break; break;
} }
@ -170,10 +170,10 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
void HAL_timer_enable_interrupt(const uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
if (HAL_timer_initialized(timer_num) && !timer_instance[timer_num]->hasInterrupt()) { if (HAL_timer_initialized(timer_num) && !timer_instance[timer_num]->hasInterrupt()) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: case MF_TIMER_STEP:
timer_instance[timer_num]->attachInterrupt(Step_Handler); timer_instance[timer_num]->attachInterrupt(Step_Handler);
break; break;
case TEMP_TIMER_NUM: case MF_TIMER_TEMP:
timer_instance[timer_num]->attachInterrupt(Temp_Handler); timer_instance[timer_num]->attachInterrupt(Temp_Handler);
break; break;
} }

22
Marlin/src/HAL/STM32/timers.h
View file

@ -42,14 +42,14 @@
#define NUM_HARDWARE_TIMERS 2 #define NUM_HARDWARE_TIMERS 2
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 0 // Timer Index for Stepper #define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 1 // Timer Index for Temperature #define MF_TIMER_TEMP 1 // Timer Index for Temperature
#endif #endif
#define TEMP_TIMER_FREQUENCY 1000 // Temperature::isr() is expected to be called at around 1kHz #define TEMP_TIMER_FREQUENCY 1000 // Temperature::isr() is expected to be called at around 1kHz
@ -64,12 +64,12 @@ extern uint32_t GetStepperTimerClkFreq();
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
extern void Step_Handler(); extern void Step_Handler();
extern void Temp_Handler(); extern void Temp_Handler();

18
Marlin/src/HAL/STM32F1/Servo.cpp
View file

@ -60,7 +60,7 @@ uint8_t ServoCount = 0;
#define US_TO_ANGLE(us) int16_t(map((us), SERVO_DEFAULT_MIN_PW, SERVO_DEFAULT_MAX_PW, minAngle, maxAngle)) #define US_TO_ANGLE(us) int16_t(map((us), SERVO_DEFAULT_MIN_PW, SERVO_DEFAULT_MAX_PW, minAngle, maxAngle))
void libServo::servoWrite(uint8_t inPin, uint16_t duty_cycle) { void libServo::servoWrite(uint8_t inPin, uint16_t duty_cycle) {
#ifdef SERVO0_TIMER_NUM #ifdef MF_TIMER_SERVO0
if (servoIndex == 0) { if (servoIndex == 0) {
pwmSetDuty(duty_cycle); pwmSetDuty(duty_cycle);
return; return;
@ -74,7 +74,7 @@ void libServo::servoWrite(uint8_t inPin, uint16_t duty_cycle) {
libServo::libServo() { libServo::libServo() {
servoIndex = ServoCount < MAX_SERVOS ? ServoCount++ : INVALID_SERVO; servoIndex = ServoCount < MAX_SERVOS ? ServoCount++ : INVALID_SERVO;
timer_set_interrupt_priority(SERVO0_TIMER_NUM, SERVO0_TIMER_IRQ_PRIO); HAL_timer_set_interrupt_priority(MF_TIMER_SERVO0, SERVO0_TIMER_IRQ_PRIO);
} }
bool libServo::attach(const int32_t inPin, const int32_t inMinAngle, const int32_t inMaxAngle) { bool libServo::attach(const int32_t inPin, const int32_t inMinAngle, const int32_t inMaxAngle) {
@ -85,7 +85,7 @@ bool libServo::attach(const int32_t inPin, const int32_t inMinAngle, const int32
maxAngle = inMaxAngle; maxAngle = inMaxAngle;
angle = -1; angle = -1;
#ifdef SERVO0_TIMER_NUM #ifdef MF_TIMER_SERVO0
if (servoIndex == 0 && setupSoftPWM(inPin)) { if (servoIndex == 0 && setupSoftPWM(inPin)) {
pin = inPin; // set attached() pin = inPin; // set attached()
return true; return true;
@ -119,7 +119,7 @@ bool libServo::detach() {
int32_t libServo::read() const { int32_t libServo::read() const {
if (attached()) { if (attached()) {
#ifdef SERVO0_TIMER_NUM #ifdef MF_TIMER_SERVO0
if (servoIndex == 0) return angle; if (servoIndex == 0) return angle;
#endif #endif
timer_dev *tdev = PIN_MAP[pin].timer_device; timer_dev *tdev = PIN_MAP[pin].timer_device;
@ -141,9 +141,9 @@ void libServo::move(const int32_t value) {
} }
} }
#ifdef SERVO0_TIMER_NUM #ifdef MF_TIMER_SERVO0
extern "C" void Servo_IRQHandler() { extern "C" void Servo_IRQHandler() {
static timer_dev *tdev = get_timer_dev(SERVO0_TIMER_NUM); static timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
uint16_t SR = timer_get_status(tdev); uint16_t SR = timer_get_status(tdev);
if (SR & TIMER_SR_CC1IF) { // channel 1 off if (SR & TIMER_SR_CC1IF) { // channel 1 off
#ifdef SERVO0_PWM_OD #ifdef SERVO0_PWM_OD
@ -164,7 +164,7 @@ void libServo::move(const int32_t value) {
} }
bool libServo::setupSoftPWM(const int32_t inPin) { bool libServo::setupSoftPWM(const int32_t inPin) {
timer_dev *tdev = get_timer_dev(SERVO0_TIMER_NUM); timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
if (!tdev) return false; if (!tdev) return false;
#ifdef SERVO0_PWM_OD #ifdef SERVO0_PWM_OD
OUT_WRITE_OD(inPin, 1); OUT_WRITE_OD(inPin, 1);
@ -189,7 +189,7 @@ void libServo::move(const int32_t value) {
} }
void libServo::pwmSetDuty(const uint16_t duty_cycle) { void libServo::pwmSetDuty(const uint16_t duty_cycle) {
timer_dev *tdev = get_timer_dev(SERVO0_TIMER_NUM); timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
timer_set_compare(tdev, 1, duty_cycle); timer_set_compare(tdev, 1, duty_cycle);
timer_generate_update(tdev); timer_generate_update(tdev);
if (duty_cycle) { if (duty_cycle) {
@ -208,7 +208,7 @@ void libServo::move(const int32_t value) {
} }
void libServo::pauseSoftPWM() { // detach void libServo::pauseSoftPWM() { // detach
timer_dev *tdev = get_timer_dev(SERVO0_TIMER_NUM); timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
timer_pause(tdev); timer_pause(tdev);
pwmSetDuty(0); pwmSetDuty(0);
} }

9
Marlin/src/HAL/STM32F1/fast_pwm.cpp
View file

@ -35,7 +35,6 @@ void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255
uint16_t max_val = timer->regs.bas->ARR * v / v_size; uint16_t max_val = timer->regs.bas->ARR * v / v_size;
if (invert) max_val = v_size - max_val; if (invert) max_val = v_size - max_val;
pwmWrite(pin, max_val); pwmWrite(pin, max_val);
} }
void set_pwm_frequency(const pin_t pin, int f_desired) { void set_pwm_frequency(const pin_t pin, int f_desired) {
@ -45,10 +44,10 @@ void set_pwm_frequency(const pin_t pin, int f_desired) {
uint8_t channel = PIN_MAP[pin].timer_channel; uint8_t channel = PIN_MAP[pin].timer_channel;
// Protect used timers // Protect used timers
if (timer == get_timer_dev(TEMP_TIMER_NUM)) return; if (timer == HAL_get_timer_dev(MF_TIMER_TEMP)) return;
if (timer == get_timer_dev(STEP_TIMER_NUM)) return; if (timer == HAL_get_timer_dev(MF_TIMER_STEP)) return;
#if PULSE_TIMER_NUM != STEP_TIMER_NUM #if MF_TIMER_PULSE != MF_TIMER_STEP
if (timer == get_timer_dev(PULSE_TIMER_NUM)) return; if (timer == HAL_get_timer_dev(MF_TIMER_PULSE)) return;
#endif #endif
if (!(timer->regs.bas->SR & TIMER_CR1_CEN)) // Ensure the timer is enabled if (!(timer->regs.bas->SR & TIMER_CR1_CEN)) // Ensure the timer is enabled

30
Marlin/src/HAL/STM32F1/timers.cpp
View file

@ -47,10 +47,7 @@
* TODO: Calculate Timer prescale value, so we get the 32bit to adjust * TODO: Calculate Timer prescale value, so we get the 32bit to adjust
*/ */
void HAL_timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority) {
void timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority) {
nvic_irq_num irq_num; nvic_irq_num irq_num;
switch (timer_num) { switch (timer_num) {
case 1: irq_num = NVIC_TIMER1_CC; break; case 1: irq_num = NVIC_TIMER1_CC; break;
@ -73,7 +70,6 @@ void timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority)
nvic_irq_set_priority(irq_num, priority); nvic_irq_set_priority(irq_num, priority);
} }
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
/** /**
* Give the Stepper ISR a higher priority (lower number) * Give the Stepper ISR a higher priority (lower number)
@ -81,7 +77,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
*/ */
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: case MF_TIMER_STEP:
timer_pause(STEP_TIMER_DEV); timer_pause(STEP_TIMER_DEV);
timer_set_mode(STEP_TIMER_DEV, STEP_TIMER_CHAN, TIMER_OUTPUT_COMPARE); // counter timer_set_mode(STEP_TIMER_DEV, STEP_TIMER_CHAN, TIMER_OUTPUT_COMPARE); // counter
timer_set_count(STEP_TIMER_DEV, 0); timer_set_count(STEP_TIMER_DEV, 0);
@ -91,11 +87,11 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
timer_set_compare(STEP_TIMER_DEV, STEP_TIMER_CHAN, _MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (STEPPER_TIMER_RATE) / frequency)); timer_set_compare(STEP_TIMER_DEV, STEP_TIMER_CHAN, _MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (STEPPER_TIMER_RATE) / frequency));
timer_no_ARR_preload_ARPE(STEP_TIMER_DEV); // Need to be sure no preload on ARR register timer_no_ARR_preload_ARPE(STEP_TIMER_DEV); // Need to be sure no preload on ARR register
timer_attach_interrupt(STEP_TIMER_DEV, STEP_TIMER_CHAN, stepTC_Handler); timer_attach_interrupt(STEP_TIMER_DEV, STEP_TIMER_CHAN, stepTC_Handler);
timer_set_interrupt_priority(STEP_TIMER_NUM, STEP_TIMER_IRQ_PRIO); HAL_timer_set_interrupt_priority(MF_TIMER_STEP, STEP_TIMER_IRQ_PRIO);
timer_generate_update(STEP_TIMER_DEV); timer_generate_update(STEP_TIMER_DEV);
timer_resume(STEP_TIMER_DEV); timer_resume(STEP_TIMER_DEV);
break; break;
case TEMP_TIMER_NUM: case MF_TIMER_TEMP:
timer_pause(TEMP_TIMER_DEV); timer_pause(TEMP_TIMER_DEV);
timer_set_mode(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, TIMER_OUTPUT_COMPARE); timer_set_mode(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, TIMER_OUTPUT_COMPARE);
timer_set_count(TEMP_TIMER_DEV, 0); timer_set_count(TEMP_TIMER_DEV, 0);
@ -103,7 +99,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
timer_set_reload(TEMP_TIMER_DEV, 0xFFFF); timer_set_reload(TEMP_TIMER_DEV, 0xFFFF);
timer_set_compare(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, _MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (F_CPU) / (TEMP_TIMER_PRESCALE) / frequency)); timer_set_compare(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, _MIN(hal_timer_t(HAL_TIMER_TYPE_MAX), (F_CPU) / (TEMP_TIMER_PRESCALE) / frequency));
timer_attach_interrupt(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, tempTC_Handler); timer_attach_interrupt(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, tempTC_Handler);
timer_set_interrupt_priority(TEMP_TIMER_NUM, TEMP_TIMER_IRQ_PRIO); HAL_timer_set_interrupt_priority(MF_TIMER_TEMP, TEMP_TIMER_IRQ_PRIO);
timer_generate_update(TEMP_TIMER_DEV); timer_generate_update(TEMP_TIMER_DEV);
timer_resume(TEMP_TIMER_DEV); timer_resume(TEMP_TIMER_DEV);
break; break;
@ -112,31 +108,31 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
void HAL_timer_enable_interrupt(const uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: ENABLE_STEPPER_DRIVER_INTERRUPT(); break; case MF_TIMER_STEP: ENABLE_STEPPER_DRIVER_INTERRUPT(); break;
case TEMP_TIMER_NUM: ENABLE_TEMPERATURE_INTERRUPT(); break; case MF_TIMER_TEMP: ENABLE_TEMPERATURE_INTERRUPT(); break;
} }
} }
void HAL_timer_disable_interrupt(const uint8_t timer_num) { void HAL_timer_disable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: DISABLE_STEPPER_DRIVER_INTERRUPT(); break; case MF_TIMER_STEP: DISABLE_STEPPER_DRIVER_INTERRUPT(); break;
case TEMP_TIMER_NUM: DISABLE_TEMPERATURE_INTERRUPT(); break; case MF_TIMER_TEMP: DISABLE_TEMPERATURE_INTERRUPT(); break;
} }
} }
static inline bool timer_irq_enabled(const timer_dev * const dev, const uint8_t interrupt) { static inline bool HAL_timer_irq_enabled(const timer_dev * const dev, const uint8_t interrupt) {
return bool(*bb_perip(&(dev->regs).gen->DIER, interrupt)); return bool(*bb_perip(&(dev->regs).gen->DIER, interrupt));
} }
bool HAL_timer_interrupt_enabled(const uint8_t timer_num) { bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: return timer_irq_enabled(STEP_TIMER_DEV, STEP_TIMER_CHAN); case MF_TIMER_STEP: return HAL_timer_irq_enabled(STEP_TIMER_DEV, STEP_TIMER_CHAN);
case TEMP_TIMER_NUM: return timer_irq_enabled(TEMP_TIMER_DEV, TEMP_TIMER_CHAN); case MF_TIMER_TEMP: return HAL_timer_irq_enabled(TEMP_TIMER_DEV, TEMP_TIMER_CHAN);
} }
return false; return false;
} }
timer_dev* get_timer_dev(int number) { timer_dev* HAL_get_timer_dev(int number) {
switch (number) { switch (number) {
#if STM32_HAVE_TIMER(1) #if STM32_HAVE_TIMER(1)
case 1: return &timer1; case 1: return &timer1;

46
Marlin/src/HAL/STM32F1/timers.h
View file

@ -65,30 +65,30 @@ typedef uint16_t hal_timer_t;
* - Otherwise it uses Timer 8 on boards with STM32_HIGH_DENSITY * - Otherwise it uses Timer 8 on boards with STM32_HIGH_DENSITY
* or Timer 4 on other boards. * or Timer 4 on other boards.
*/ */
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#if defined(MCU_STM32F103CB) || defined(MCU_STM32F103C8) #if defined(MCU_STM32F103CB) || defined(MCU_STM32F103C8)
#define STEP_TIMER_NUM 4 // For C8/CB boards, use timer 4 #define MF_TIMER_STEP 4 // For C8/CB boards, use timer 4
#else #else
#define STEP_TIMER_NUM 5 // for other boards, five is fine. #define MF_TIMER_STEP 5 // for other boards, five is fine.
#endif #endif
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 2 // Timer Index for Temperature #define MF_TIMER_TEMP 2 // Timer Index for Temperature
//#define TEMP_TIMER_NUM 4 // 2->4, Timer 2 for Stepper Current PWM //#define MF_TIMER_TEMP 4 // 2->4, Timer 2 for Stepper Current PWM
#endif #endif
#if MB(BTT_SKR_MINI_E3_V1_0, BTT_SKR_E3_DIP, BTT_SKR_MINI_E3_V1_2, MKS_ROBIN_LITE, MKS_ROBIN_E3D, MKS_ROBIN_E3) #if MB(BTT_SKR_MINI_E3_V1_0, BTT_SKR_E3_DIP, BTT_SKR_MINI_E3_V1_2, MKS_ROBIN_LITE, MKS_ROBIN_E3D, MKS_ROBIN_E3)
// SKR Mini E3 boards use PA8 as FAN_PIN, so TIMER 1 is used for Fan PWM. // SKR Mini E3 boards use PA8 as FAN_PIN, so TIMER 1 is used for Fan PWM.
#ifdef STM32_HIGH_DENSITY #ifdef STM32_HIGH_DENSITY
#define SERVO0_TIMER_NUM 8 // tone.cpp uses Timer 4 #define MF_TIMER_SERVO0 8 // tone.cpp uses Timer 4
#else #else
#define SERVO0_TIMER_NUM 3 // tone.cpp uses Timer 8 #define MF_TIMER_SERVO0 3 // tone.cpp uses Timer 8
#endif #endif
#else #else
#define SERVO0_TIMER_NUM 1 // SERVO0 or BLTOUCH #define MF_TIMER_SERVO0 1 // SERVO0 or BLTOUCH
#endif #endif
#define STEP_TIMER_IRQ_PRIO 2 #define STEP_TIMER_IRQ_PRIO 2
@ -106,14 +106,14 @@ typedef uint16_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
timer_dev* get_timer_dev(int number); timer_dev* HAL_get_timer_dev(int number);
#define TIMER_DEV(num) get_timer_dev(num) #define TIMER_DEV(num) HAL_get_timer_dev(num)
#define STEP_TIMER_DEV TIMER_DEV(STEP_TIMER_NUM) #define STEP_TIMER_DEV TIMER_DEV(MF_TIMER_STEP)
#define TEMP_TIMER_DEV TIMER_DEV(TEMP_TIMER_NUM) #define TEMP_TIMER_DEV TIMER_DEV(MF_TIMER_TEMP)
#define ENABLE_STEPPER_DRIVER_INTERRUPT() timer_enable_irq(STEP_TIMER_DEV, STEP_TIMER_CHAN) #define ENABLE_STEPPER_DRIVER_INTERRUPT() timer_enable_irq(STEP_TIMER_DEV, STEP_TIMER_CHAN)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() timer_disable_irq(STEP_TIMER_DEV, STEP_TIMER_CHAN) #define DISABLE_STEPPER_DRIVER_INTERRUPT() timer_disable_irq(STEP_TIMER_DEV, STEP_TIMER_CHAN)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() timer_enable_irq(TEMP_TIMER_DEV, TEMP_TIMER_CHAN) #define ENABLE_TEMPERATURE_INTERRUPT() timer_enable_irq(TEMP_TIMER_DEV, TEMP_TIMER_CHAN)
#define DISABLE_TEMPERATURE_INTERRUPT() timer_disable_irq(TEMP_TIMER_DEV, TEMP_TIMER_CHAN) #define DISABLE_TEMPERATURE_INTERRUPT() timer_disable_irq(TEMP_TIMER_DEV, TEMP_TIMER_CHAN)
@ -138,8 +138,8 @@ extern "C" {
// Public Variables // Public Variables
// ------------------------ // ------------------------
//static HardwareTimer StepperTimer(STEP_TIMER_NUM); //static HardwareTimer StepperTimer(MF_TIMER_STEP);
//static HardwareTimer TempTimer(TEMP_TIMER_NUM); //static HardwareTimer TempTimer(MF_TIMER_TEMP);
// ------------------------ // ------------------------
// Public functions // Public functions
@ -163,13 +163,13 @@ bool HAL_timer_interrupt_enabled(const uint8_t timer_num);
FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) { FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: case MF_TIMER_STEP:
// NOTE: WE have set ARPE = 0, which means the Auto reload register is not preloaded // NOTE: WE have set ARPE = 0, which means the Auto reload register is not preloaded
// and there is no need to use any compare, as in the timer mode used, setting ARR to the compare value // and there is no need to use any compare, as in the timer mode used, setting ARR to the compare value
// will result in exactly the same effect, ie triggering an interrupt, and on top, set counter to 0 // will result in exactly the same effect, ie triggering an interrupt, and on top, set counter to 0
timer_set_reload(STEP_TIMER_DEV, compare); // We reload direct ARR as needed during counting up timer_set_reload(STEP_TIMER_DEV, compare); // We reload direct ARR as needed during counting up
break; break;
case TEMP_TIMER_NUM: case MF_TIMER_TEMP:
timer_set_compare(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, compare); timer_set_compare(TEMP_TIMER_DEV, TEMP_TIMER_CHAN, compare);
break; break;
} }
@ -177,11 +177,11 @@ FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const ha
FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) { FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case STEP_TIMER_NUM: case MF_TIMER_STEP:
// No counter to clear // No counter to clear
timer_generate_update(STEP_TIMER_DEV); timer_generate_update(STEP_TIMER_DEV);
return; return;
case TEMP_TIMER_NUM: case MF_TIMER_TEMP:
timer_set_count(TEMP_TIMER_DEV, 0); timer_set_count(TEMP_TIMER_DEV, 0);
timer_generate_update(TEMP_TIMER_DEV); timer_generate_update(TEMP_TIMER_DEV);
return; return;
@ -196,6 +196,6 @@ FORCE_INLINE static void timer_no_ARR_preload_ARPE(timer_dev *dev) {
bb_peri_set_bit(&(dev->regs).gen->CR1, TIMER_CR1_ARPE_BIT, 0); bb_peri_set_bit(&(dev->regs).gen->CR1, TIMER_CR1_ARPE_BIT, 0);
} }
void timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority); void HAL_timer_set_interrupt_priority(uint_fast8_t timer_num, uint_fast8_t priority);
#define TIMER_OC_NO_PRELOAD 0 // Need to disable preload also on compare registers. #define TIMER_OC_NO_PRELOAD 0 // Need to disable preload also on compare registers.

20
Marlin/src/HAL/TEENSY31_32/timers.cpp
View file

@ -47,7 +47,7 @@ FORCE_INLINE static void __DSB() {
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP:
FTM0_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN; FTM0_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN;
FTM0_SC = 0x00; // Set this to zero before changing the modulus FTM0_SC = 0x00; // Set this to zero before changing the modulus
FTM0_CNT = 0x0000; // Reset the count to zero FTM0_CNT = 0x0000; // Reset the count to zero
@ -56,7 +56,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
FTM0_SC = (FTM_SC_CLKS(0b1) & FTM_SC_CLKS_MASK) | (FTM_SC_PS(FTM0_TIMER_PRESCALE_BITS) & FTM_SC_PS_MASK); // Bus clock 60MHz divided by prescaler 8 FTM0_SC = (FTM_SC_CLKS(0b1) & FTM_SC_CLKS_MASK) | (FTM_SC_PS(FTM0_TIMER_PRESCALE_BITS) & FTM_SC_PS_MASK); // Bus clock 60MHz divided by prescaler 8
FTM0_C0SC = FTM_CSC_CHIE | FTM_CSC_MSA | FTM_CSC_ELSA; FTM0_C0SC = FTM_CSC_CHIE | FTM_CSC_MSA | FTM_CSC_ELSA;
break; break;
case 1: case MF_TIMER_TEMP:
FTM1_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN; // Disable write protection, Enable FTM1 FTM1_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN; // Disable write protection, Enable FTM1
FTM1_SC = 0x00; // Set this to zero before changing the modulus FTM1_SC = 0x00; // Set this to zero before changing the modulus
FTM1_CNT = 0x0000; // Reset the count to zero FTM1_CNT = 0x0000; // Reset the count to zero
@ -70,15 +70,15 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
void HAL_timer_enable_interrupt(const uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: NVIC_ENABLE_IRQ(IRQ_FTM0); break; case MF_TIMER_STEP: NVIC_ENABLE_IRQ(IRQ_FTM0); break;
case 1: NVIC_ENABLE_IRQ(IRQ_FTM1); break; case MF_TIMER_TEMP: NVIC_ENABLE_IRQ(IRQ_FTM1); break;
} }
} }
void HAL_timer_disable_interrupt(const uint8_t timer_num) { void HAL_timer_disable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: NVIC_DISABLE_IRQ(IRQ_FTM0); break; case MF_TIMER_STEP: NVIC_DISABLE_IRQ(IRQ_FTM0); break;
case 1: NVIC_DISABLE_IRQ(IRQ_FTM1); break; case MF_TIMER_TEMP: NVIC_DISABLE_IRQ(IRQ_FTM1); break;
} }
// We NEED memory barriers to ensure Interrupts are actually disabled! // We NEED memory barriers to ensure Interrupts are actually disabled!
@ -89,20 +89,20 @@ void HAL_timer_disable_interrupt(const uint8_t timer_num) {
bool HAL_timer_interrupt_enabled(const uint8_t timer_num) { bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return NVIC_IS_ENABLED(IRQ_FTM0); case MF_TIMER_STEP: return NVIC_IS_ENABLED(IRQ_FTM0);
case 1: return NVIC_IS_ENABLED(IRQ_FTM1); case MF_TIMER_TEMP: return NVIC_IS_ENABLED(IRQ_FTM1);
} }
return false; return false;
} }
void HAL_timer_isr_prologue(const uint8_t timer_num) { void HAL_timer_isr_prologue(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP:
FTM0_CNT = 0x0000; FTM0_CNT = 0x0000;
FTM0_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag FTM0_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag
FTM0_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag FTM0_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag
break; break;
case 1: case MF_TIMER_TEMP:
FTM1_CNT = 0x0000; FTM1_CNT = 0x0000;
FTM1_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag FTM1_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag
FTM1_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag FTM1_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag

34
Marlin/src/HAL/TEENSY31_32/timers.h
View file

@ -46,14 +46,14 @@ typedef uint32_t hal_timer_t;
#define HAL_TIMER_RATE (FTM0_TIMER_RATE) #define HAL_TIMER_RATE (FTM0_TIMER_RATE)
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 0 // Timer Index for Stepper #define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 1 // Timer Index for Temperature #define MF_TIMER_TEMP 1 // Timer Index for Temperature
#endif #endif
#define TEMP_TIMER_FREQUENCY 1000 #define TEMP_TIMER_FREQUENCY 1000
@ -66,12 +66,12 @@ typedef uint32_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#ifndef HAL_STEP_TIMER_ISR #ifndef HAL_STEP_TIMER_ISR
#define HAL_STEP_TIMER_ISR() extern "C" void ftm0_isr() //void TC3_Handler() #define HAL_STEP_TIMER_ISR() extern "C" void ftm0_isr() //void TC3_Handler()
@ -84,23 +84,23 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) { FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
switch (timer_num) { switch (timer_num) {
case 0: FTM0_C0V = compare; break; case MF_TIMER_STEP: FTM0_C0V = compare; break;
case 1: FTM1_C0V = compare; break; case MF_TIMER_TEMP: FTM1_C0V = compare; break;
} }
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return FTM0_C0V; case MF_TIMER_STEP: return FTM0_C0V;
case 1: return FTM1_C0V; case MF_TIMER_TEMP: return FTM1_C0V;
} }
return 0; return 0;
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return FTM0_CNT; case MF_TIMER_STEP: return FTM0_CNT;
case 1: return FTM1_CNT; case MF_TIMER_TEMP: return FTM1_CNT;
} }
return 0; return 0;
} }

20
Marlin/src/HAL/TEENSY35_36/timers.cpp
View file

@ -47,7 +47,7 @@ FORCE_INLINE static void __DSB() {
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP:
FTM0_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN; FTM0_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN;
FTM0_SC = 0x00; // Set this to zero before changing the modulus FTM0_SC = 0x00; // Set this to zero before changing the modulus
FTM0_CNT = 0x0000; // Reset the count to zero FTM0_CNT = 0x0000; // Reset the count to zero
@ -56,7 +56,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
FTM0_SC = (FTM_SC_CLKS(0b1) & FTM_SC_CLKS_MASK) | (FTM_SC_PS(FTM0_TIMER_PRESCALE_BITS) & FTM_SC_PS_MASK); // Bus clock 60MHz divided by prescaler 8 FTM0_SC = (FTM_SC_CLKS(0b1) & FTM_SC_CLKS_MASK) | (FTM_SC_PS(FTM0_TIMER_PRESCALE_BITS) & FTM_SC_PS_MASK); // Bus clock 60MHz divided by prescaler 8
FTM0_C0SC = FTM_CSC_CHIE | FTM_CSC_MSA | FTM_CSC_ELSA; FTM0_C0SC = FTM_CSC_CHIE | FTM_CSC_MSA | FTM_CSC_ELSA;
break; break;
case 1: case MF_TIMER_TEMP:
FTM1_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN; // Disable write protection, Enable FTM1 FTM1_MODE = FTM_MODE_WPDIS | FTM_MODE_FTMEN; // Disable write protection, Enable FTM1
FTM1_SC = 0x00; // Set this to zero before changing the modulus FTM1_SC = 0x00; // Set this to zero before changing the modulus
FTM1_CNT = 0x0000; // Reset the count to zero FTM1_CNT = 0x0000; // Reset the count to zero
@ -70,15 +70,15 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
void HAL_timer_enable_interrupt(const uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: NVIC_ENABLE_IRQ(IRQ_FTM0); break; case MF_TIMER_STEP: NVIC_ENABLE_IRQ(IRQ_FTM0); break;
case 1: NVIC_ENABLE_IRQ(IRQ_FTM1); break; case MF_TIMER_TEMP: NVIC_ENABLE_IRQ(IRQ_FTM1); break;
} }
} }
void HAL_timer_disable_interrupt(const uint8_t timer_num) { void HAL_timer_disable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: NVIC_DISABLE_IRQ(IRQ_FTM0); break; case MF_TIMER_STEP: NVIC_DISABLE_IRQ(IRQ_FTM0); break;
case 1: NVIC_DISABLE_IRQ(IRQ_FTM1); break; case MF_TIMER_TEMP: NVIC_DISABLE_IRQ(IRQ_FTM1); break;
} }
// We NEED memory barriers to ensure Interrupts are actually disabled! // We NEED memory barriers to ensure Interrupts are actually disabled!
@ -89,20 +89,20 @@ void HAL_timer_disable_interrupt(const uint8_t timer_num) {
bool HAL_timer_interrupt_enabled(const uint8_t timer_num) { bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return NVIC_IS_ENABLED(IRQ_FTM0); case MF_TIMER_STEP: return NVIC_IS_ENABLED(IRQ_FTM0);
case 1: return NVIC_IS_ENABLED(IRQ_FTM1); case MF_TIMER_TEMP: return NVIC_IS_ENABLED(IRQ_FTM1);
} }
return false; return false;
} }
void HAL_timer_isr_prologue(const uint8_t timer_num) { void HAL_timer_isr_prologue(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP:
FTM0_CNT = 0x0000; FTM0_CNT = 0x0000;
FTM0_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag FTM0_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag
FTM0_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag FTM0_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag
break; break;
case 1: case MF_TIMER_TEMP:
FTM1_CNT = 0x0000; FTM1_CNT = 0x0000;
FTM1_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag FTM1_SC &= ~FTM_SC_TOF; // Clear FTM Overflow flag
FTM1_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag FTM1_C0SC &= ~FTM_CSC_CHF; // Clear FTM Channel Compare flag

34
Marlin/src/HAL/TEENSY35_36/timers.h
View file

@ -45,14 +45,14 @@ typedef uint32_t hal_timer_t;
#define HAL_TIMER_RATE (FTM0_TIMER_RATE) #define HAL_TIMER_RATE (FTM0_TIMER_RATE)
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 0 // Timer Index for Stepper #define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 1 // Timer Index for Temperature #define MF_TIMER_TEMP 1 // Timer Index for Temperature
#endif #endif
#define TEMP_TIMER_FREQUENCY 1000 #define TEMP_TIMER_FREQUENCY 1000
@ -65,12 +65,12 @@ typedef uint32_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#ifndef HAL_STEP_TIMER_ISR #ifndef HAL_STEP_TIMER_ISR
#define HAL_STEP_TIMER_ISR() extern "C" void ftm0_isr() //void TC3_Handler() #define HAL_STEP_TIMER_ISR() extern "C" void ftm0_isr() //void TC3_Handler()
@ -83,23 +83,23 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) { FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
switch (timer_num) { switch (timer_num) {
case 0: FTM0_C0V = compare; break; case MF_TIMER_STEP: FTM0_C0V = compare; break;
case 1: FTM1_C0V = compare; break; case MF_TIMER_TEMP: FTM1_C0V = compare; break;
} }
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return FTM0_C0V; case MF_TIMER_STEP: return FTM0_C0V;
case 1: return FTM1_C0V; case MF_TIMER_TEMP: return FTM1_C0V;
} }
return 0; return 0;
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return FTM0_CNT; case MF_TIMER_STEP: return FTM0_CNT;
case 1: return FTM1_CNT; case MF_TIMER_TEMP: return FTM1_CNT;
} }
return 0; return 0;
} }

28
Marlin/src/HAL/TEENSY40_41/timers.cpp
View file

@ -30,7 +30,7 @@
void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) { void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP:
CCM_CSCMR1 &= ~CCM_CSCMR1_PERCLK_CLK_SEL; // turn off 24mhz mode CCM_CSCMR1 &= ~CCM_CSCMR1_PERCLK_CLK_SEL; // turn off 24mhz mode
CCM_CCGR1 |= CCM_CCGR1_GPT1_BUS(CCM_CCGR_ON); CCM_CCGR1 |= CCM_CCGR1_GPT1_BUS(CCM_CCGR_ON);
@ -48,7 +48,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
attachInterruptVector(IRQ_GPT1, &stepTC_Handler); attachInterruptVector(IRQ_GPT1, &stepTC_Handler);
NVIC_SET_PRIORITY(IRQ_GPT1, 16); NVIC_SET_PRIORITY(IRQ_GPT1, 16);
break; break;
case 1: case MF_TIMER_TEMP:
CCM_CSCMR1 &= ~CCM_CSCMR1_PERCLK_CLK_SEL; // turn off 24mhz mode CCM_CSCMR1 &= ~CCM_CSCMR1_PERCLK_CLK_SEL; // turn off 24mhz mode
CCM_CCGR0 |= CCM_CCGR0_GPT2_BUS(CCM_CCGR_ON); CCM_CCGR0 |= CCM_CCGR0_GPT2_BUS(CCM_CCGR_ON);
@ -71,19 +71,15 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
void HAL_timer_enable_interrupt(const uint8_t timer_num) { void HAL_timer_enable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP: NVIC_ENABLE_IRQ(IRQ_GPT1); break;
NVIC_ENABLE_IRQ(IRQ_GPT1); case MF_TIMER_TEMP: NVIC_ENABLE_IRQ(IRQ_GPT2); break;
break;
case 1:
NVIC_ENABLE_IRQ(IRQ_GPT2);
break;
} }
} }
void HAL_timer_disable_interrupt(const uint8_t timer_num) { void HAL_timer_disable_interrupt(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: NVIC_DISABLE_IRQ(IRQ_GPT1); break; case MF_TIMER_STEP: NVIC_DISABLE_IRQ(IRQ_GPT1); break;
case 1: NVIC_DISABLE_IRQ(IRQ_GPT2); break; case MF_TIMER_TEMP: NVIC_DISABLE_IRQ(IRQ_GPT2); break;
} }
// We NEED memory barriers to ensure Interrupts are actually disabled! // We NEED memory barriers to ensure Interrupts are actually disabled!
@ -93,20 +89,16 @@ void HAL_timer_disable_interrupt(const uint8_t timer_num) {
bool HAL_timer_interrupt_enabled(const uint8_t timer_num) { bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return (NVIC_IS_ENABLED(IRQ_GPT1)); case MF_TIMER_STEP: return (NVIC_IS_ENABLED(IRQ_GPT1));
case 1: return (NVIC_IS_ENABLED(IRQ_GPT2)); case MF_TIMER_TEMP: return (NVIC_IS_ENABLED(IRQ_GPT2));
} }
return false; return false;
} }
void HAL_timer_isr_prologue(const uint8_t timer_num) { void HAL_timer_isr_prologue(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP: GPT1_SR = GPT_IR_OF1IE; break; // clear OF3 bit
GPT1_SR = GPT_IR_OF1IE; // clear OF3 bit case MF_TIMER_TEMP: GPT2_SR = GPT_IR_OF1IE; break; // clear OF3 bit
break;
case 1:
GPT2_SR = GPT_IR_OF1IE; // clear OF3 bit
break;
} }
asm volatile("dsb"); asm volatile("dsb");
} }

38
Marlin/src/HAL/TEENSY40_41/timers.h
View file

@ -43,14 +43,14 @@ typedef uint32_t hal_timer_t;
#define GPT1_TIMER_RATE (GPT_TIMER_RATE / GPT1_TIMER_PRESCALE) // 75MHz #define GPT1_TIMER_RATE (GPT_TIMER_RATE / GPT1_TIMER_PRESCALE) // 75MHz
#define GPT2_TIMER_RATE (GPT_TIMER_RATE / GPT2_TIMER_PRESCALE) // 15MHz #define GPT2_TIMER_RATE (GPT_TIMER_RATE / GPT2_TIMER_PRESCALE) // 15MHz
#ifndef STEP_TIMER_NUM #ifndef MF_TIMER_STEP
#define STEP_TIMER_NUM 0 // Timer Index for Stepper #define MF_TIMER_STEP 0 // Timer Index for Stepper
#endif #endif
#ifndef PULSE_TIMER_NUM #ifndef MF_TIMER_PULSE
#define PULSE_TIMER_NUM STEP_TIMER_NUM #define MF_TIMER_PULSE MF_TIMER_STEP
#endif #endif
#ifndef TEMP_TIMER_NUM #ifndef MF_TIMER_TEMP
#define TEMP_TIMER_NUM 1 // Timer Index for Temperature #define MF_TIMER_TEMP 1 // Timer Index for Temperature
#endif #endif
#define TEMP_TIMER_RATE 1000000 #define TEMP_TIMER_RATE 1000000
@ -64,12 +64,12 @@ typedef uint32_t hal_timer_t;
#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE #define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US #define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM) #define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_STEP)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM) #define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM) #define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM) #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(MF_TIMER_TEMP)
#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM) #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
#ifndef HAL_STEP_TIMER_ISR #ifndef HAL_STEP_TIMER_ISR
#define HAL_STEP_TIMER_ISR() extern "C" void stepTC_Handler() // GPT1_Handler() #define HAL_STEP_TIMER_ISR() extern "C" void stepTC_Handler() // GPT1_Handler()
@ -87,27 +87,23 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) { FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
switch (timer_num) { switch (timer_num) {
case 0: case MF_TIMER_STEP: GPT1_OCR1 = compare - 1; break;
GPT1_OCR1 = compare - 1; case MF_TIMER_TEMP: GPT2_OCR1 = compare - 1; break;
break;
case 1:
GPT2_OCR1 = compare - 1;
break;
} }
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return GPT1_OCR1; case MF_TIMER_STEP: return GPT1_OCR1;
case 1: return GPT2_OCR1; case MF_TIMER_TEMP: return GPT2_OCR1;
} }
return 0; return 0;
} }
FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) { FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
switch (timer_num) { switch (timer_num) {
case 0: return GPT1_CNT; case MF_TIMER_STEP: return GPT1_CNT;
case 1: return GPT2_CNT; case MF_TIMER_TEMP: return GPT2_CNT;
} }
return 0; return 0;
} }

20
Marlin/src/module/stepper.cpp
View file

@ -464,8 +464,8 @@ xyze_int8_t Stepper::count_direction{0};
#define PULSE_LOW_TICK_COUNT hal_timer_t(NS_TO_PULSE_TIMER_TICKS(_MIN_PULSE_LOW_NS - _MIN(_MIN_PULSE_LOW_NS, TIMER_SETUP_NS))) #define PULSE_LOW_TICK_COUNT hal_timer_t(NS_TO_PULSE_TIMER_TICKS(_MIN_PULSE_LOW_NS - _MIN(_MIN_PULSE_LOW_NS, TIMER_SETUP_NS)))
#define USING_TIMED_PULSE() hal_timer_t start_pulse_count = 0 #define USING_TIMED_PULSE() hal_timer_t start_pulse_count = 0
#define START_TIMED_PULSE(DIR) (start_pulse_count = HAL_timer_get_count(PULSE_TIMER_NUM)) #define START_TIMED_PULSE(DIR) (start_pulse_count = HAL_timer_get_count(MF_TIMER_PULSE))
#define AWAIT_TIMED_PULSE(DIR) while (PULSE_##DIR##_TICK_COUNT > HAL_timer_get_count(PULSE_TIMER_NUM) - start_pulse_count) { } #define AWAIT_TIMED_PULSE(DIR) while (PULSE_##DIR##_TICK_COUNT > HAL_timer_get_count(MF_TIMER_PULSE) - start_pulse_count) { }
#define START_HIGH_PULSE() START_TIMED_PULSE(HIGH) #define START_HIGH_PULSE() START_TIMED_PULSE(HIGH)
#define AWAIT_HIGH_PULSE() AWAIT_TIMED_PULSE(HIGH) #define AWAIT_HIGH_PULSE() AWAIT_TIMED_PULSE(HIGH)
#define START_LOW_PULSE() START_TIMED_PULSE(LOW) #define START_LOW_PULSE() START_TIMED_PULSE(LOW)
@ -1454,11 +1454,11 @@ void Stepper::set_directions() {
*/ */
HAL_STEP_TIMER_ISR() { HAL_STEP_TIMER_ISR() {
HAL_timer_isr_prologue(STEP_TIMER_NUM); HAL_timer_isr_prologue(MF_TIMER_STEP);
Stepper::isr(); Stepper::isr();
HAL_timer_isr_epilogue(STEP_TIMER_NUM); HAL_timer_isr_epilogue(MF_TIMER_STEP);
} }
#ifdef CPU_32_BIT #ifdef CPU_32_BIT
@ -1480,7 +1480,7 @@ void Stepper::isr() {
// Program timer compare for the maximum period, so it does NOT // Program timer compare for the maximum period, so it does NOT
// flag an interrupt while this ISR is running - So changes from small // flag an interrupt while this ISR is running - So changes from small
// periods to big periods are respected and the timer does not reset to 0 // periods to big periods are respected and the timer does not reset to 0
HAL_timer_set_compare(STEP_TIMER_NUM, hal_timer_t(HAL_TIMER_TYPE_MAX)); HAL_timer_set_compare(MF_TIMER_STEP, hal_timer_t(HAL_TIMER_TYPE_MAX));
// Count of ticks for the next ISR // Count of ticks for the next ISR
hal_timer_t next_isr_ticks = 0; hal_timer_t next_isr_ticks = 0;
@ -1584,7 +1584,7 @@ void Stepper::isr() {
* On AVR the ISR epilogue+prologue is estimated at 100 instructions - Give 8µs as margin * On AVR the ISR epilogue+prologue is estimated at 100 instructions - Give 8µs as margin
* On ARM the ISR epilogue+prologue is estimated at 20 instructions - Give 1µs as margin * On ARM the ISR epilogue+prologue is estimated at 20 instructions - Give 1µs as margin
*/ */
min_ticks = HAL_timer_get_count(STEP_TIMER_NUM) + hal_timer_t( min_ticks = HAL_timer_get_count(MF_TIMER_STEP) + hal_timer_t(
#ifdef __AVR__ #ifdef __AVR__
8 8
#else #else
@ -1608,7 +1608,7 @@ void Stepper::isr() {
// sure that the time has not arrived yet - Warrantied by the scheduler // sure that the time has not arrived yet - Warrantied by the scheduler
// Set the next ISR to fire at the proper time // Set the next ISR to fire at the proper time
HAL_timer_set_compare(STEP_TIMER_NUM, hal_timer_t(next_isr_ticks)); HAL_timer_set_compare(MF_TIMER_STEP, hal_timer_t(next_isr_ticks));
// Don't forget to finally reenable interrupts // Don't forget to finally reenable interrupts
ENABLE_ISRS(); ENABLE_ISRS();
@ -2769,7 +2769,7 @@ void Stepper::init() {
#endif #endif
#if DISABLED(I2S_STEPPER_STREAM) #if DISABLED(I2S_STEPPER_STREAM)
HAL_timer_start(STEP_TIMER_NUM, 122); // Init Stepper ISR to 122 Hz for quick starting HAL_timer_start(MF_TIMER_STEP, 122); // Init Stepper ISR to 122 Hz for quick starting
wake_up(); wake_up();
sei(); sei();
#endif #endif
@ -2980,8 +2980,8 @@ void Stepper::report_positions() {
#define EXTRA_CYCLES_BABYSTEP (STEP_PULSE_CYCLES - (CYCLES_EATEN_BABYSTEP)) #define EXTRA_CYCLES_BABYSTEP (STEP_PULSE_CYCLES - (CYCLES_EATEN_BABYSTEP))
#if EXTRA_CYCLES_BABYSTEP > 20 #if EXTRA_CYCLES_BABYSTEP > 20
#define _SAVE_START() const hal_timer_t pulse_start = HAL_timer_get_count(PULSE_TIMER_NUM) #define _SAVE_START() const hal_timer_t pulse_start = HAL_timer_get_count(MF_TIMER_PULSE)
#define _PULSE_WAIT() while (EXTRA_CYCLES_BABYSTEP > (uint32_t)(HAL_timer_get_count(PULSE_TIMER_NUM) - pulse_start) * (PULSE_TIMER_PRESCALE)) { /* nada */ } #define _PULSE_WAIT() while (EXTRA_CYCLES_BABYSTEP > (uint32_t)(HAL_timer_get_count(MF_TIMER_PULSE) - pulse_start) * (PULSE_TIMER_PRESCALE)) { /* nada */ }
#else #else
#define _SAVE_START() NOOP #define _SAVE_START() NOOP
#if EXTRA_CYCLES_BABYSTEP > 0 #if EXTRA_CYCLES_BABYSTEP > 0

6
Marlin/src/module/temperature.cpp
View file

@ -2399,7 +2399,7 @@ void Temperature::init() {
HAL_ANALOG_SELECT(POWER_MONITOR_VOLTAGE_PIN); HAL_ANALOG_SELECT(POWER_MONITOR_VOLTAGE_PIN);
#endif #endif
HAL_timer_start(TEMP_TIMER_NUM, TEMP_TIMER_FREQUENCY); HAL_timer_start(MF_TIMER_TEMP, TEMP_TIMER_FREQUENCY);
ENABLE_TEMPERATURE_INTERRUPT(); ENABLE_TEMPERATURE_INTERRUPT();
#if HAS_AUTO_FAN_0 #if HAS_AUTO_FAN_0
@ -2980,11 +2980,11 @@ void Temperature::readings_ready() {
* - Call planner.isr to count down its "ignore" time * - Call planner.isr to count down its "ignore" time
*/ */
HAL_TEMP_TIMER_ISR() { HAL_TEMP_TIMER_ISR() {
HAL_timer_isr_prologue(TEMP_TIMER_NUM); HAL_timer_isr_prologue(MF_TIMER_TEMP);
Temperature::isr(); Temperature::isr();
HAL_timer_isr_epilogue(TEMP_TIMER_NUM); HAL_timer_isr_epilogue(MF_TIMER_TEMP);
} }
#if ENABLED(SLOW_PWM_HEATERS) && !defined(MIN_STATE_TIME) #if ENABLED(SLOW_PWM_HEATERS) && !defined(MIN_STATE_TIME)

3
Marlin/src/pins/sam/pins_ARCHIM1.h
View file

@ -46,8 +46,7 @@
// //
// Timers // Timers
// //
// These are already defined in DUE, so must be undefined first #define MF_TIMER_STEP 3
#define STEP_TIMER_NUM 3
#define HAL_STEP_TIMER_ISR() void TC3_Handler() #define HAL_STEP_TIMER_ISR() void TC3_Handler()
// //