main.ino

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#define __AVR_ATmega32U4__ 1
 
// Include main Arduino library for basic Arduino functions
#include <Arduino.h>
 
// Include AVR input/output definitions for low-level hardware control
#include <avr/io.h>
 
// Define ISR macro for IntelliSense, else include AVR interrupt handling
// library
#ifdef __INTELLISENSE__
#define ISR(vector) void vector(void)
#else
#include <avr/interrupt.h>
#endif
 
// Define __LPM macro for IntelliSense, else include AVR program space utility
// library
#ifdef __INTELLISENSE__
#define __LPM(x) 0
#else
#include <avr/pgmspace.h>
#endif
 
// Include standard integer type definitions
#include <stdint.h>
 
// Include motor control related headers
#include "main.h"
#include "tables.h"
#include "fault.h"
#include "scpi.h"
#include "filter.h"
 
// Include PID control algorithm if closed-loop speed control is enabled
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
#include "pid.h"
#endif
 
volatile motorflags_t motorFlags FAST_ACCESS(0x3E);
 
volatile faultflags_t faultFlags FAST_ACCESS(0x4A);
 
volatile motorconfigs_t motorConfigs;
 
volatile uint16_t commutationTicks = 0;
volatile uint16_t lastCommutationTicks = 0xffff;
 
volatile uint8_t speedInput = 0;
 
volatile uint8_t speedOutput = 0;
 
volatile uint16_t current = 0;
 
volatile uint16_t gateVref = 0;
 
char incoming_byte = 0;
 
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
pidData_t pidParameters;
#endif
 
void setup(void)
{
  // Load motor configs
  ConfigsInit();
 
  // Initialize flags.
  FlagsInit();
 
  // Check if remote mode requested.
  RemoteUpdate();
 
  // Initialize peripherals.
  PortsInit(); // depends on motorFlags.remote
  ADCInit();   // include self-test + loop until board detected must be before TimersInit
  PLLInit();
  TimersInit();
 
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
  PIDInit(PID_K_P, PID_K_I, PID_K_D, &pidParameters);
#endif
 
  if (motorFlags.remote == TRUE)
  {
    // Start serial interface with 115200 bauds.
    Serial.begin(115200);
    // while (!Serial); // wait for serial to finish initializing
 
    // Initialise SCPI subsystem if remote mode.
    SCPI_Init(&scpi_context,
              scpi_commands,
              &scpi_interface,
              scpi_units_def,
              SCPI_IDN1, SCPI_IDN2, SCPI_IDN3, SCPI_IDN4,
              scpi_input_buffer, SCPI_INPUT_BUFFER_LENGTH,
              scpi_error_queue_data, SCPI_ERROR_QUEUE_SIZE);
  }
  else
  {
    // Update direction before enable flag.
    DesiredDirectionUpdate();
    // Do not update enable flag until everything is ready.
    EnableUpdate();
  }
 
  // Set up pin change interrupts.
  PinChangeIntInit();
 
  // Enable Timer4 overflow event interrupt.
  TIMSK4 |= (1 << TOIE4);
 
  // Enable interrupts globally and let motor driver take over.
  sei();
}
 
void loop()
{
  if (motorFlags.remote == TRUE)
  {
    // send data to SCPI parser only when you receive data:
    if (Serial.available() > 0)
    {
      incoming_byte = Serial.read();
      SCPI_Input(&scpi_context, &incoming_byte, 1);
    }
  }
  if (motorFlags.speedControllerRun)
  {
    SpeedController();
    motorFlags.speedControllerRun = FALSE;
  }
}
 
static void FlagsInit(void)
{
  // Initialize motorFlags with default values.
  motorFlags.speedControllerRun = FALSE;
  motorFlags.remote = FALSE;
  motorFlags.enable = FALSE;
  motorFlags.actualDirection = DIRECTION_UNKNOWN;
  motorFlags.desiredDirection = DIRECTION_FORWARD;
  motorFlags.driveWaveform = WAVEFORM_UNDEFINED;
 
  // Initialize faultFlags with default values. Set motorStopped to FALSE at
  // startup. This will make sure that the motor is not started if it is not
  // really stopped. If it is stopped, this variable will quickly be updated.
  faultFlags.motorStopped = FALSE;
  faultFlags.reverseDirection = FALSE;
  faultFlags.overCurrent = FALSE;
  faultFlags.noHallConnections = FALSE;
  faultFlags.userFlag1 = FALSE;
  faultFlags.userFlag2 = FALSE;
  faultFlags.userFlag3 = FALSE;
}
 
static void ConfigsInit(void)
{
  motorConfigs.tim4Freq = (uint32_t)TIM4_FREQ;
  motorConfigs.tim4Top = (uint16_t)TIM4_TOP(motorConfigs.tim4Freq);
  motorConfigs.tim4DeadTime = (uint16_t)DEAD_TIME;
  motorConfigs.speedInputSource = (uint8_t)SPEED_INPUT_SOURCE_LOCAL;
}
 
static void PLLInit(void)
{
  // Configure PLL Frequency Control Register to output 48MHz for USB Module and
  // 64MHz for the High-Speed Clock Timer with a base speed of 96MHz for PLL
  // Output Frequency.
 
  PLLFRQ = (0 << PINMUX) | (1 << PLLUSB) | PLL_POSTSCALER_DIV_1_5 | (1 << PDIV3) | (0 << PDIV2) | (1 << PDIV1) | (0 << PDIV0);
 
  // Enable PLL.
  PLLCSR = (1 << PINDIV) | (1 << PLLE);
 
  // Wait until PLOCK bit is set, indicating PLL is locked and stable.
  while ((PLLCSR & (1 << PLOCK)) == 0)
  {
    // Wait for PLL lock
    ;
  }
}
 
static void PortsInit(void)
{
#if (EMULATE_HALL == TRUE)
  // Configure and set hall sensor pins for motor emulation
  PORTB &= ~((1 << H1_PIN) | (1 << H2_PIN) | (1 << H3_PIN));
  PORTB |= (0x07 & pgm_read_byte_near(&expectedHallSequenceForward[1]));
  // Set hall sensor pins as outputs.
  DDRB |= (1 << H1_PIN) | (1 << H2_PIN) | (1 << H3_PIN);
#endif
 
#if ((HALL_PULLUP_ENABLE == TRUE) && (EMULATE_HALL != TRUE))
  // Configure and set hall sensor pins as input with pull-ups enabled
  PORTB |= (1 << H1_PIN) | (1 << H2_PIN) | (1 << H3_PIN);
#endif
 
  // Configure and set pins FAULT_PIN_3, FAULT_PIN_2, and FAULT_PIN_1 as outputs
  PORTB &= ~((1 << FAULT_PIN_3) | (1 << FAULT_PIN_2));
  DDRB |= (1 << FAULT_PIN_3) | (1 << FAULT_PIN_2);
  PORTD &= ~(1 << FAULT_PIN_1);
  DDRD |= (1 << FAULT_PIN_1);
 
  // If remote mode, set enable and direction pin as output to allow software
  // triggered interrupts
  if (motorFlags.remote == TRUE)
  {
    PORTD &= ~((1 << ENABLE_PIN) | (1 << DIRECTION_COMMAND_PIN));
    DDRD |= (1 << ENABLE_PIN) | (1 << DIRECTION_COMMAND_PIN);
  }
}
 
void TimersInit(void)
{
  // Set Timer1 accordingly.
  TCCR1A = (1 << WGM11) | (0 << WGM10);
  TCCR1B = (0 << WGM13) | (1 << WGM12);
  TIMSK1 = (1 << TOIE1);
 
  // Start Timer1.
  TCCR1B |= TIM1_CLOCK_DIV_64;
 
#if (EMULATE_HALL == TRUE)
  // Set Timer3 accordingly.
  TCCR3A = (1 << WGM31) | (1 << WGM30);
  TCCR3B = (1 << WGM33) | (1 << WGM32);
  TIMSK3 = (1 << TOIE3);
 
  // Set top value of Timer/counter3.
  OCR3AH = (uint8_t)(TIM3_TOP >> 8);
  OCR3AL = (uint8_t)(0xff & TIM3_TOP);
 
  // Start Timer3.
  TCCR3B |= TIM1_CLOCK_DIV_8;
#endif
  // Set Timer4 in "PWM6 / Dual-slope" mode. Does not enable outputs yet.
  TCCR4A = (0 << COM4A1) | (1 << COM4A0) | (0 << COM4B1) | (1 << COM4B0) | (1 << PWM4A) | (1 << PWM4B);
  TCCR4B = DT_PRESCALER_DIV_PATTERN(CHOOSE_DT_PRESCALER(motorConfigs.tim4DeadTime));
  TCCR4C |= (0 << COM4D1) | (1 << COM4D0) | (1 << PWM4D);
  TCCR4E = (1 << ENHC4);
 
  // Set top value of Timer/counter4.
  TC4H = (uint8_t)(motorConfigs.tim4Top >> 8);
  OCR4C = (uint8_t)(0xff & motorConfigs.tim4Top);
 
  // Set the dead time.
  DT4 = (DEAD_TIME_HALF(motorConfigs.tim4DeadTime) << 4) | DEAD_TIME_HALF(motorConfigs.tim4DeadTime);
 
  // Start Timer4.
  TCCR4B |= TIM4_PRESCALER_DIV_PATTERN(CHOOSE_TIM4_PRESCALER(TIM4_FREQ));
}
 
static void PinChangeIntInit(void)
{
  // Initialize external interrupt on shutdown pin (INT0) and direction input
  // (INT2) pin.
  EICRA = (0 << ISC21) | (1 << ISC20) | (0 << ISC01) | (1 << ISC00);
  EIMSK = (1 << INT2) | (1 << INT0);
 
  // Initialize pin change interrupt on hall sensor inputs (PCINT1..3).
  PCMSK0 = (1 << PCINT3) | (1 << PCINT2) | (1 << PCINT1);
 
  // Enable pin change interrupt on ports with pin change signals
  PCICR = (1 << PCIE0);
}
 
static void ADCInit(void)
{
  // Select initial AD conversion channel [0V for self-test].
  ADMUX = (ADC_REFERENCE_VOLTAGE | (1 << ADLAR) | ADC_MUX_L_0V);
  ADCSRB = ADC_MUX_H_0V;
  _delay_ms(1);
 
  // Enable ADC
  ADCSRA = (1 << ADEN);
 
  // Start ADC single conversion and discard first measurement.
  uint16_t adc_reading = ADCSingleConversion();
 
  // Start ADC single conversion to measure 0V, this time it is correct.
  adc_reading = ADCSingleConversion();
 
  // Check if ADC can measure 0V within 10mV.
  if (adc_reading > 2)
  {
    FatalError((uint8_t)0b0000111);
  }
 
  // Select next AD conversion channel [1V1 for self-test].
  ADMUX = (ADC_REFERENCE_VOLTAGE | (1 << ADLAR) | ADC_MUX_L_1V1);
  ADCSRB = ADC_MUX_H_1V1;
  _delay_ms(1);
 
  // Start ADC single conversion to measure 1V1.
  adc_reading = ADCSingleConversion();
 
  // Check if ADC can measure 1.1V within 1% (1.09 to 1.1V).
  if ((adc_reading < 223) || (adc_reading > 227))
  {
    FatalError((uint8_t)0b0000111);
  }
 
  // Select next AD conversion channel [BREF].
  ADMUX = (ADC_REFERENCE_VOLTAGE | (1 << ADLAR) | ADC_MUX_L_BREF);
  ADCSRB = ADC_MUX_H_BREF;
 
  // Enable pull up resistor
  PORTF |= (1 << PF0); 
 
  _delay_ms(1);
  SweepLEDsBlocking();
 
  // Start ADC single conversion to measure BREF.
  adc_reading = ADCSingleConversion();
 
  // Wait to check if any board is connected. Should be anything other than
  // 0x3ff if any board is connected assuming BREF of the board is not equal to
  // IOREF.
  while (adc_reading == 0x3ff)
  {
    SweepLEDsBlocking();
 
    // Start ADC single conversion to measure BREF.
    adc_reading = ADCSingleConversion();
  }
 
  // Disable pull up resistor
  PORTF &= ~(1 << PF0); 
 
  // Re-initialize ADC mux channel select.
  ADMUX &= ~ADC_MUX_L_BITS;
  ADMUX |= ADC_MUX_L_SPEED;
  // Set trigger source to ADC_TRIGGER.
  ADCSRB = ADC_MUX_H_SPEED | ADC_TRIGGER;
 
  // Re-initialize ADC to work with interrupts.
  ADCSRA = (1 << ADEN) | (1 << ADSC) | (1 << ADATE) | (1 << ADIF) | (1 << ADIE) | ADC_PRESCALER;
}
 
static uint16_t ADCSingleConversion(void)
{
  // Initialize ADC for one-time conversion.
  ADCSRA |= (1 << ADSC);
 
  // Wait for the conversion to complete.
  while (ADCSRA & (1 << ADSC))
  {
    // Wait until the conversion is finished.
  }
 
  // Read the ADC result and combine ADCH and ADCL into a 16-bit value.
  uint16_t value = (ADCL >> 6);
  value |= 0x3ff & (ADCH << 2);
 
  return value;
}
 
static void EnableUpdate(void)
{
  if ((PIND & (1 << ENABLE_PIN)) != 0)
  {
    motorFlags.enable = TRUE;
  }
  else
  {
    motorFlags.enable = FALSE;
 
#if (TURN_OFF_MODE == TURN_OFF_MODE_COAST)
    // Disable driver signals to let the motor coast.
    motorFlags.driveWaveform = WAVEFORM_UNDEFINED;
    DisablePWMOutputs();
    ClearPWMPorts();
    faultFlags.motorStopped = FALSE;
#endif
 
#if (TURN_OFF_MODE == TURN_OFF_MODE_BRAKE)
    // Set the motor in brake mode.
    faultFlags.motorStopped = FALSE;
    TimersSetModeBrake();
#endif
  }
}
 
static void RemoteUpdate(void)
{
  if ((PIND & (1 << REMOTE_PIN)) != 0)
  {
    motorFlags.remote = TRUE;
  }
  else
  {
    motorFlags.remote = FALSE;
  }
}
 
static void SpeedController(void)
{
  if (motorFlags.enable == TRUE)
  {
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
    // Calculate an increment set point from the analog speed input.
    int16_t incrementSetpoint = ((int32_t)speedInput * SPEED_CONTROLLER_MAX_SPEED) / SPEED_CONTROLLER_MAX_INPUT;
 
    // PID regulator with feed forward from speed input.
    uint16_t outputValue;
 
    outputValue = PIDController(incrementSetpoint, (motorConfigs.tim4Freq / (lastCommutationTicks * 3)) >> 1, &pidParameters);
 
    if (outputValue > 255)
    {
      outputValue = 255;
    }
 
    speedOutput = outputValue;
 
    // Without the delay PID does not reset when needed
    _delay_us(1);
#else
    // Calculate the delta in speedInput
    int16_t delta = speedInput - speedOutput;
    // If delta exceeds the maximum allowed change, limit it and update
    // speedOutput
    if (delta > SPEED_CONTROLLER_MAX_DELTA)
    {
      speedOutput += SPEED_CONTROLLER_MAX_DELTA;
    }
    else if (delta < -SPEED_CONTROLLER_MAX_DELTA)
    {
      speedOutput -= SPEED_CONTROLLER_MAX_DELTA;
    }
    else
    {
      speedOutput = speedInput;
    }
#endif
  }
  else
  {
    speedOutput = 0;
  }
}
 
static void FatalError(uint8_t code)
{
  // Detach all interrupts
  cli();
 
  // Disable outputs
  DisablePWMOutputs();
 
  // Set faultFlags based on the provided error code
  faultFlags.userFlag3 = (code & 0x01) != 0;
  faultFlags.userFlag2 = (code & 0x02) != 0;
  faultFlags.userFlag1 = (code & 0x04) != 0;
  faultFlags.reverseDirection = (code & 0x08) != 0;
  faultFlags.motorStopped = (code & 0x10) != 0;
  faultFlags.overCurrent = (code & 0x20) != 0;
  faultFlags.noHallConnections = (code & 0x40) != 0;
 
  // loop forever
  while (1)
  {
    faultSequentialStateMachine(&faultFlags, &motorFlags);
    _delay_ms(2);
  }
}
 
static FORCE_INLINE void SetDuty(const uint16_t duty)
{
  TC4H = duty >> 8;
  OCR4A = 0xFF & duty;
}
 
static FORCE_INLINE void TimersSetModeBlockCommutation(void)
{
  // Set PWM pins to input (High-Z) while changing modes.
  DisablePWMOutputs();
 
  // Sets up timers.
  TCCR4A = (0 << COM4A1) | (1 << COM4A0) | (0 << COM4B1) | (1 << COM4B0) | (1 << PWM4A) | (1 << PWM4B);
  TCCR4C |= (0 << COM4D1) | (1 << COM4D0) | (1 << PWM4D);
  TCCR4D = (1 << WGM41) | (1 << WGM40);
 
  // Set output duty cycle to zero for now.
  SetDuty(0);
 
  // Wait for the next PWM cycle to ensure that all outputs are updated.
  TimersWaitForNextPWMCycle();
 
  motorFlags.driveWaveform = WAVEFORM_BLOCK_COMMUTATION;
 
  // Change PWM pins to output again to allow PWM control.
  EnablePWMOutputs();
}
 
#if (TURN_OFF_MODE == TURN_OFF_MODE_BRAKE)
static FORCE_INLINE void TimersSetModeBrake(void)
{
  // Set PWM pins to input (High-Z) while changing modes.
  DisablePWMOutputs();
 
  // Sets up timers.
  TCCR4A = (0 << COM4A1) | (1 << COM4A0) | (0 << COM4B1) | (1 << COM4B0) | (1 << PWM4A) | (1 << PWM4B);
  TCCR4C |= (0 << COM4D1) | (1 << COM4D0) | (1 << PWM4D);
  TCCR4D = (1 << WGM41) | (1 << WGM40);
 
  // Set to 50% duty
  SetDuty((uint16_t)511);
 
  // PWM outputs on both high side and low side gates are turned enabled
  // (complementary)
  TCCR4E &= ~0b00111111;
  TCCR4E |= OC_ENABLE_PORTB | OC_ENABLE_PORTC | OC_ENABLE_PORTD;
 
  // Wait for the next PWM cycle to ensure that all outputs are updated.
  TimersWaitForNextPWMCycle();
 
  motorFlags.driveWaveform = WAVEFORM_BRAKING;
 
  EnablePWMOutputs();
}
#endif
 
static FORCE_INLINE void TimersWaitForNextPWMCycle(void)
{
  // Clear Timer1 Capture event flag.
  TIFR4 = (1 << TOV4);
 
  // Wait for new Timer1 Capture event flag.
  while (!(TIFR4 & (1 << TOV4)))
  {
  }
}
 
static FORCE_INLINE uint8_t GetDesiredDirection(void)
{
  return (uint8_t)motorFlags.desiredDirection;
}
 
static FORCE_INLINE uint8_t GetActualDirection(void)
{
  return motorFlags.actualDirection;
}
 
static FORCE_INLINE void BlockCommutate(const uint8_t direction, uint8_t hall)
{
  const uint8_t *tableAddress;
 
  if (direction == DIRECTION_FORWARD)
  {
    tableAddress = blockCommutationTableForward;
  }
  else
  {
    tableAddress = blockCommutationTableReverse;
  }
  tableAddress += (hall * 4);
 
  ClearPWMPorts();
  TCCR4E &= ~0b00111111;
 
  DisablePWMOutputs();
 
  PORTB |= (uint8_t)pgm_read_byte_near(tableAddress++);
  PORTC |= (uint8_t)pgm_read_byte_near(tableAddress++);
  PORTD |= (uint8_t)pgm_read_byte_near(tableAddress++);
  TCCR4E |= (uint8_t)pgm_read_byte_near(tableAddress);
 
  EnablePWMOutputs();
}
 
static FORCE_INLINE uint8_t GetHall(void)
{
  uint8_t hall;
 
  hall = HALL_PIN & ((1 << H3_PIN) | (1 << H2_PIN) | (1 << H1_PIN));
  hall >>= H1_PIN;
 
  return hall;
}
 
static FORCE_INLINE void DesiredDirectionUpdate(void)
{
  if ((PIND & (1 << DIRECTION_COMMAND_PIN)) != 0)
  {
    motorFlags.desiredDirection = DIRECTION_REVERSE;
  }
  else
  {
    motorFlags.desiredDirection = DIRECTION_FORWARD;
  }
}
 
static FORCE_INLINE void ActualDirectionUpdate(uint8_t lastHall, const uint8_t newHall)
{
  // Ensure that lastHall is within the bounds of the table. If not, set it to
  // 0, which is also an illegal hall value but a legal table index.
  if (lastHall > 6)
  {
    lastHall = 0;
  }
 
  if (pgm_read_byte_near(&expectedHallSequenceForward[lastHall]) == newHall)
  {
    motorFlags.actualDirection = DIRECTION_FORWARD;
  }
  else if (pgm_read_byte_near(&expectedHallSequenceReverse[lastHall]) == newHall)
  {
    motorFlags.actualDirection = DIRECTION_REVERSE;
  }
  else
  {
    motorFlags.actualDirection = DIRECTION_UNKNOWN;
  }
}
 
static FORCE_INLINE void ReverseRotationSignalUpdate(void)
{
  if (GetActualDirection() == GetDesiredDirection())
  {
    faultFlags.reverseDirection = FALSE;
  }
  else
  {
    faultFlags.reverseDirection = TRUE;
  }
}
 
static FORCE_INLINE void EnablePWMOutputs(void)
{
  DDRB |= PWM_PATTERN_PORTB;
  DDRC |= PWM_PATTERN_PORTC;
  DDRD |= PWM_PATTERN_PORTD;
}
 
static FORCE_INLINE void DisablePWMOutputs(void)
{
  DDRB &= ~PWM_PATTERN_PORTB;
  DDRC &= ~PWM_PATTERN_PORTC;
  DDRD &= ~PWM_PATTERN_PORTD;
}
 
static FORCE_INLINE void ClearPWMPorts(void)
{
  PORTB &= ~PWM_PATTERN_PORTB;
  PORTC &= ~PWM_PATTERN_PORTC;
  PORTD &= ~PWM_PATTERN_PORTD;
}
 
static FORCE_INLINE void CommutationTicksUpdate(void)
{
  if (commutationTicks < COMMUTATION_TICKS_STOPPED)
  {
    commutationTicks++;
  }
  else
  {
    faultFlags.motorStopped = TRUE;
    lastCommutationTicks = 0xffff;
    uint8_t hall = GetHall();
    if ((hall == 0) || (hall == 0b111))
    {
      faultFlags.noHallConnections = TRUE;
    }
    if (motorFlags.driveWaveform != WAVEFORM_BLOCK_COMMUTATION && motorFlags.enable == TRUE)
    {
      speedOutput = 0;
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
      PIDResetIntegrator(&pidParameters);
#endif
      TimersSetModeBlockCommutation();
      BlockCommutate(GetDesiredDirection(), GetHall());
    }
#if (TURN_OFF_MODE == TURN_OFF_MODE_BRAKE)
    else if (motorFlags.enable == FALSE)
    {
      motorFlags.driveWaveform = WAVEFORM_UNDEFINED;
      DisablePWMOutputs();
      ClearPWMPorts();
    }
#endif
  }
}
 
ISR(INT0_vect)
{
  EnableUpdate();
}
 
ISR(PCINT0_vect)
{
  static uint8_t lastHall = 0xff;
  uint8_t hall;
 
  hall = GetHall();
 
  if (motorFlags.driveWaveform == WAVEFORM_BLOCK_COMMUTATION)
  {
    BlockCommutate(GetDesiredDirection(), hall);
  }
 
  // Update flags that depend on hall sensor value.
  ActualDirectionUpdate(lastHall, hall);
  ReverseRotationSignalUpdate();
 
  lastHall = hall;
 
  // Reset commutation timer.
  lastCommutationTicks = calculateEMA(commutationTicks, lastCommutationTicks, 2);
  commutationTicks = 0;
 
  // Since the hall sensors are changing, the motor can not be stopped.
  faultFlags.motorStopped = FALSE;
  faultFlags.noHallConnections = FALSE;
}
 
ISR(INT2_vect)
{
  // Update desired direction flag.
  DesiredDirectionUpdate();
  if (motorFlags.desiredDirection == DIRECTION_FORWARD)
  {
  }
  else if (motorFlags.desiredDirection == DIRECTION_REVERSE)
  {
  };
 
#if (TURN_OFF_MODE == TURN_OFF_MODE_COAST)
  // Disable driver signals to let motor coast. The motor will automatically
  // start once it stopped.
  motorFlags.driveWaveform = WAVEFORM_UNDEFINED;
  DisablePWMOutputs();
  ClearPWMPorts();
  faultFlags.motorStopped = FALSE;
#endif
 
#if (TURN_OFF_MODE == TURN_OFF_MODE_BRAKE)
  // Set motor in brake mode. The motor will automatically start once it is
  // stopped.
  faultFlags.motorStopped = FALSE;
  TimersSetModeBrake(); // Automatically sets driveWaveform.
#endif
}
 
ISR(TIMER4_OVF_vect)
{
  if (motorFlags.driveWaveform == WAVEFORM_BLOCK_COMMUTATION)
  {
    uint16_t dutyCycle = ((uint32_t)speedOutput * motorConfigs.tim4Top) >> 7;
 
    if (dutyCycle > (uint16_t)(motorConfigs.tim4Top << 1))
    {
      dutyCycle = (uint16_t)(motorConfigs.tim4Top << 1);
    }
 
    SetDuty(dutyCycle);
  }
 
  CommutationTicksUpdate();
 
  {
    // Run the speed regulation loop with constant intervals.
    static uint8_t speedRegTicks = 0;
    speedRegTicks++;
    if (speedRegTicks >= SPEED_CONTROLLER_TIME_BASE)
    {
      motorFlags.speedControllerRun = TRUE;
      speedRegTicks -= SPEED_CONTROLLER_TIME_BASE;
    }
  }
}
 
#if (EMULATE_HALL == TRUE)
ISR(TIMER3_OVF_vect)
{
  if (motorFlags.enable == TRUE)
  {
    uint8_t hall = GetHall();
 
    if (GetDesiredDirection() == DIRECTION_FORWARD)
    {
      PORTB = (PORTB & ~((1 << H1_PIN) | (1 << H2_PIN) | (1 << H3_PIN))) | ((0x07 & pgm_read_byte_near(&expectedHallSequenceForward[hall])) << H1_PIN);
    }
    else
    {
      PORTB = (PORTB & ~((1 << H1_PIN) | (1 << H2_PIN) | (1 << H3_PIN))) | ((0x07 & pgm_read_byte_near(&expectedHallSequenceReverse[hall])) << H1_PIN);
    }
  }
}
#endif
 
ISR(TIMER1_OVF_vect)
{
  faultSequentialStateMachine(&faultFlags, &motorFlags);
}
 
ISR(ADC_vect)
{
  switch ((ADMUX & ADC_MUX_L_BITS) | (ADCSRB & ADC_MUX_H_BITS))
  {
  case (ADC_MUX_H_SPEED | ADC_MUX_L_SPEED):
    // Handle ADC conversion result for speed measurement.
    if (motorConfigs.speedInputSource == SPEED_INPUT_SOURCE_LOCAL)
    {
      speedInput = ADCH;
    }
    ADMUX &= ~ADC_MUX_L_BITS;
    ADMUX |= ADC_MUX_L_CURRENT;
    ADCSRB &= ~ADC_MUX_H_BITS;
    ADCSRB |= ADC_MUX_H_CURRENT;
    break;
  case (ADC_MUX_H_CURRENT | ADC_MUX_L_CURRENT):
    // Handle ADC conversion result for current measurement.
    current = ADCL >> 6;
    current |= (ADCH << 2);
    ADMUX &= ~ADC_MUX_L_BITS;
    ADMUX |= ADC_MUX_L_GATEVREF;
    ADCSRB &= ~ADC_MUX_H_BITS;
    ADCSRB |= ADC_MUX_H_GATEVREF;
 
    // Check for over current conditions and set fault flags.
    if (current > CURRENT_ERROR_THRESHOLD)
    {
      FatalError((uint8_t)0b0100111);
    }
    else if (current > CURRENT_WARNING_THRESHOLD)
    {
      faultFlags.overCurrent = TRUE;
    }
    else
    {
      faultFlags.overCurrent = FALSE;
    }
    break;
  case (ADC_MUX_H_GATEVREF | ADC_MUX_L_GATEVREF):
    // Handle ADC conversion result for gate voltage reference measurement.
    gateVref = ADCL >> 6;
    gateVref |= (ADCH << 2);
    ADMUX &= ~ADC_MUX_L_BITS;
    ADMUX |= ADC_MUX_L_SPEED;
    ADCSRB &= ~ADC_MUX_H_BITS;
    ADCSRB |= ADC_MUX_H_SPEED;
    break;
  default:
    // This is probably an error and should be handled.
    FatalError((uint8_t)0b0000111);
    break;
  }
 
  // Clear Timer/Counter0 overflow flag.
  TIFR0 = (1 << TOV0);
}