main.ino File Reference

Motor control implementation. More...

#include <Arduino.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <stdint.h>
#include "main.h"
#include "tables.h"
#include "fault.h"
#include "scpi.h"
#include "filter.h"

Include dependency graph for main.ino:

Go to the source code of this file.

Macros
#define	__AVR_ATmega32U4__   1
	Define macro for ATmega32U4 micro controller.

Functions
void	setup (void)
	Main initialization function.
void	loop ()
	Main Loop Function.
static void	FlagsInit (void)
	Initializes motorFlags and faultFlags.
static void	ConfigsInit (void)
	Initializes motorConfigs.
static void	PLLInit (void)
	Initialize PLL (Phase-Locked Loop)
static void	PortsInit (void)
	Initialize I/O port directions and pull-up resistors.
void	TimersInit (void)
	Initializes and synchronizes Timers.
static void	PinChangeIntInit (void)
	Initialize pin change interrupts.
static void	ADCInit (void)
	Initializes the ADC.
static uint16_t	ADCSingleConversion (void)
	Perform a single ADC conversion.
static void	EnableUpdate (void)
	Check whether the enable pin is set and update flags accordingly.
static void	RemoteUpdate (void)
	Check whether the remote pin is set and update flags accordingly.
static void	SpeedController (void)
	Speed regulator loop.
static void	FatalError (uint8_t code)
	Handle a fatal error and enter a fault state.
static void	SetDuty (const uint16_t duty)
	Set duty cycle for TIM4.
static void	TimersSetModeBlockCommutation (void)
	Configures timers for block commutation.
static void	TimersWaitForNextPWMCycle (void)
	Wait for the start of the next PWM cycle.
static uint8_t	GetDesiredDirection (void)
	Retrieve the intended motor direction.
static uint8_t	GetActualDirection (void)
	Retrieve the current motor direction.
static void	BlockCommutate (const uint8_t direction, uint8_t hall)
	Perform block commutation based on direction and hall sensor input.
static uint8_t	GetHall (void)
	Read the hall sensor inputs and decode the hall state.
static void	DesiredDirectionUpdate (void)
	Updates global desired direction flag.
static void	ActualDirectionUpdate (uint8_t lastHall, const uint8_t newHall)
	Update the global actual direction flag based on the two latest hall values.
static void	ReverseRotationSignalUpdate (void)
	Update the reverse rotation flag.
static void	EnablePWMOutputs (void)
	Enable PWM output pins.
static void	DisablePWMOutputs (void)
	Disable PWM output pins.
static void	ClearPWMPorts (void)
	Clear PWM output ports.
static void	CommutationTicksUpdate (void)
	Update the 'tick' counter and check for a stopped motor.
	ISR (INT0_vect)
	Enable interrupt service routine.
	ISR (PCINT0_vect)
	Hall sensor change interrupt service routine.
	ISR (INT2_vect)
	Direction input change interrupt service routine.
	ISR (TIMER4_OVF_vect)
	Timer4 Overflow Event Interrupt Service Routine.
	ISR (TIMER1_OVF_vect)
	Timer1 Overflow Interrupt Service Routine.
	ISR (ADC_vect)
	ADC Conversion Complete Interrupt Service Routine.

Variables
volatile motorflags_t	motorFlags
	Motor control flags placed in I/O space for fast access.
volatile faultflags_t	faultFlags
	Fault flags placed in I/O space for fast access.
volatile motorconfigs_t	motorConfigs
	Motor Configs.
volatile uint16_t	commutationTicks = 0
	The number of 'ticks' between two hall sensor changes (counter).
volatile uint16_t	lastCommutationTicks = 0xffff
	The number of 'ticks' between two hall sensor changes (store).
volatile uint8_t	speedInput = 0
	The most recent "speed" input measurement.
volatile uint8_t	speedOutput = 0
	The most recent "speed" output from the speed controller.
volatile uint16_t	current = 0
	Current measurement (Register Value).
volatile uint16_t	gateVref = 0
	Gate voltage measurement (Register Value)
char	incoming_byte = 0
	Buffer for incoming serial data.

Detailed Description

Motor control implementation.

This file contains the full implementation of the motor control, except the PID-controller, filter, fault, SCPI and table implementations and definitions.

User Manual:

ANxxx: Trapezoidal Control of BLDC Motors Using Hall Effect Sensors

Documentation

For comprehensive code documentation, supported compilers, compiler settings and supported devices see readme.html

Author

Nexperia: http://www.nexperia.com

Support Page

For additional support, visit: https://www.nexperia.com/support

Author

Aanas Sayed

Date

2024/03/08

Definition in file main.ino.

Macro Definition Documentation

__AVR_ATmega32U4__

#define __AVR_ATmega32U4__   1

Define macro for ATmega32U4 micro controller.

Definition at line 31 of file main.ino.

Function Documentation

ActualDirectionUpdate()

static void ActualDirectionUpdate ( uint8_t lastHall, const uint8_t newHall )

static

Update the global actual direction flag based on the two latest hall values.

Calling this function with the last two hall sensor values as parameters triggers an update of the global actualDirection flag.

Parameters

lastHall	The previous hall sensor value.
newHall	The current hall sensor value.

Definition at line 982 of file main.ino.

{
  // 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;
  }
}

Here is the caller graph for this function:

ADCInit()

static void ADCInit ( void )

static

Initializes the ADC.

This function initializes the ADC for speed reference, current and gate voltage measurements.

The function performs self-tests to ensure the ADC's accuracy:

• It measures 0V to verify the ADC's ability to read close to zero.
• It measures 1.1V to ensure the ADC's accuracy within a specified range.
• It measures BREF and waits for any board to be connected.

If any of the self-tests fail, a fatal error is indicated.

After self-testing, the ADC is configured for speed reference measurements and set to trigger on ADC_TRIGGER.

See also

ADC_TRIGGER

Definition at line 481 of file main.ino.

{
  // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ADCSingleConversion()

static uint16_t ADCSingleConversion ( void )

static

Perform a single ADC conversion.

This function initiates a single ADC conversion to measure a voltage. It waits for the conversion to complete and then reads the ADC result.

Returns

The 16-bit ADC result representing the measured voltage.

Definition at line 561 of file main.ino.

{
  // 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;
}

Here is the caller graph for this function:

BlockCommutate()

static void BlockCommutate ( const uint8_t direction, uint8_t hall )

static

Perform block commutation based on direction and hall sensor input.

This function performs block commutation according to the specified direction of rotation and the hall sensor input. Block commutation is used to control motor phases during operation.

Parameters

direction	Direction of rotation (DIRECTION_FORWARD or DIRECTION_REVERSE).
hall	Hall sensor input value corresponding to the rotor position.

Definition at line 908 of file main.ino.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ClearPWMPorts()

static void ClearPWMPorts ( void )

static

Clear PWM output ports.

This function clears the PWM output ports by setting the corresponding bits of the port registers to low. It effectively turns off the PWM signals on the specified ports while leaving the port directions unchanged.

Definition at line 1054 of file main.ino.

{
  PORTB &= ~PWM_PATTERN_PORTB;
  PORTC &= ~PWM_PATTERN_PORTC;
  PORTD &= ~PWM_PATTERN_PORTD;
}

Here is the caller graph for this function:

CommutationTicksUpdate()

static void CommutationTicksUpdate ( void )

static

Update the 'tick' counter and check for a stopped motor.

This function should be called at every PWM timer overflow to update the 'tick' counter. It increments the 'tick' counter until it reaches the maximum tick limit, indicating a potentially stopped or stalled motor. If the limit is reached, the global motor stopped flag is set.

Note

This function can be used to detect a stalled motor and take appropriate actions.

If the motor is determined to be stopped, it may change the motor drive waveform and disable PWM outputs as necessary.

See also

COMMUTATION_TICKS_STOPPED, TURN_OFF_MODE

Definition at line 1076 of file main.ino.

{
  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
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigsInit()

static void ConfigsInit ( void )

static

Initializes motorConfigs.

This function initializes motorConfigs to their default values.

Definition at line 320 of file main.ino.

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

Here is the caller graph for this function:

DesiredDirectionUpdate()

static void DesiredDirectionUpdate ( void )

static

Updates global desired direction flag.

Running this function triggers a reading of the direction input pin. The desiredDirection flag is set accordingly.

Definition at line 961 of file main.ino.

{
  if ((PIND & (1 << DIRECTION_COMMAND_PIN)) != 0)
  {
    motorFlags.desiredDirection = DIRECTION_REVERSE;
  }
  else
  {
    motorFlags.desiredDirection = DIRECTION_FORWARD;
  }
}

Here is the caller graph for this function:

DisablePWMOutputs()

static void DisablePWMOutputs ( void )

static

Disable PWM output pins.

This function disables PWM outputs by setting the port direction for all PWM pins as inputs. This action overrides the PWM signals, effectively stopping the generation of PWM. The PWM configuration itself remains unchanged.

Definition at line 1041 of file main.ino.

{
  DDRB &= ~PWM_PATTERN_PORTB;
  DDRC &= ~PWM_PATTERN_PORTC;
  DDRD &= ~PWM_PATTERN_PORTD;
}

Here is the caller graph for this function:

EnablePWMOutputs()

static void EnablePWMOutputs ( void )

static

Enable PWM output pins.

This function sets the port direction for all PWM pins as output, allowing PWM signals to be generated on these pins. It does not modify the PWM configuration itself.

Definition at line 1028 of file main.ino.

{
  DDRB |= PWM_PATTERN_PORTB;
  DDRC |= PWM_PATTERN_PORTC;
  DDRD |= PWM_PATTERN_PORTD;
}

Here is the caller graph for this function:

EnableUpdate()

static void EnableUpdate ( void )

static

Check whether the enable pin is set and update flags accordingly.

This function checks the state of the enable pin and updates the motorFlags and faultFlags accordingly. If the enable pin is not set, it can perform specific actions based on the TURN_OFF_MODE configuration:

• If TURN_OFF_MODE is set to TURN_OFF_MODE_COAST, it disables driver signals, allowing the motor to coast.
• If TURN_OFF_MODE is set to TURN_OFF_MODE_BRAKE, it sets the motor in brake mode.

Note

The behavior of this function depends on the TURN_OFF_MODE configuration.

See also

TURN_OFF_MODE, TimersSetModeBrake()

Definition at line 594 of file main.ino.

{
  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
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

FatalError()

static void FatalError ( uint8_t code )

static

Handle a fatal error and enter a fault state.

This function is called in response to a fatal error condition. It performs the following actions:

• Detaches all interrupts to prevent further operation.
• Disables PWM outputs.
• Sets fault flags based on the provided error code.
• Enters a loop, continuously executing the fault sequential state machine and delaying for 2 milliseconds between each iteration.

Parameters

code	The error code indicating the nature of the fatal error. Each bit of the code corresponds to a specific fault condition: - Bit 0: User Flag 3 - Bit 1: User Flag 2 - Bit 2: User Flag 1 - Bit 3: Reverse Direction - Bit 4: Motor Stopped - Bit 5: Over Current - Bit 6: No Hall Connections

Definition at line 728 of file main.ino.

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

Here is the call graph for this function:

Here is the caller graph for this function:

FlagsInit()

static void FlagsInit ( void )

static

Initializes motorFlags and faultFlags.

This function initializes both motorFlags and faultFlags to their default values.

Definition at line 294 of file main.ino.

{
  // 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;
}

Here is the caller graph for this function:

GetActualDirection()

static uint8_t GetActualDirection ( void )

static

Retrieve the current motor direction.

This function returns the current operating direction of the motor.

Note

To accurately determine the direction, two consecutive hall sensor changes in the same direction are required.

Returns

The current motor direction.

Return values

DIRECTION_FORWARD	Motor is currently running forward.
DIRECTION_REVERSE	Motor is currently running in reverse.
DIRECTION_UNKNOWN	The current motor direction cannot be determined, which may indicate the motor is stopped, changing direction, or that the hall sensors are providing incorrect information.

Definition at line 893 of file main.ino.

{
  return motorFlags.actualDirection;
}

Here is the caller graph for this function:

GetDesiredDirection()

static uint8_t GetDesiredDirection ( void )

static

Retrieve the intended motor direction.

This function provides the current intended direction for the motor.

Note

The direction input is not directly read at this point. Instead, a separate pin change interrupt is responsible for monitoring the input.

Return values

DIRECTION_FORWARD	Forward direction is the intended direction.
DIRECTION_REVERSE	Reverse direction is the intended direction.

Definition at line 873 of file main.ino.

{
  return (uint8_t)motorFlags.desiredDirection;
}

Here is the caller graph for this function:

GetHall()

static uint8_t GetHall ( void )

static

Read the hall sensor inputs and decode the hall state.

This function reads the hall sensor inputs and converts them into a number ranging from 1 to 6, where the hall sensors' states are represented as bits: H3|H2|H1.

Returns

The decoded hall sensor value.

Return values

0	Illegal hall state. Possible hardware error.
1-6	Valid hall sensor values.
7	Illegal hall state. Possible hardware error.

Definition at line 946 of file main.ino.

{
  uint8_t hall;
 
  hall = HALL_PIN & ((1 << H3_PIN) | (1 << H2_PIN) | (1 << H1_PIN));
  hall >>= H1_PIN;
 
  return hall;
}

Here is the caller graph for this function:

ISR() [1/6]

ISR

(

ADC_vect

)

ADC Conversion Complete Interrupt Service Routine.

This interrupt service routine is automatically executed every time an AD conversion is finished, and the converted result is available in the ADC data register.

The switch/case construct ensures that the converted value is stored in the variable corresponding to the selected channel and changes the channel for the next ADC measurement.

Additional ADC measurements can be added to the cycle by extending the switch/case construct.

Definition at line 1292 of file main.ino.

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

Here is the call graph for this function:

ISR() [2/6]

ISR

(

INT0_vect

)

Enable interrupt service routine.

This interrupt service routine is called if the enable pin changes state.

Definition at line 1115 of file main.ino.

{
  EnableUpdate();
}

Here is the call graph for this function:

ISR() [3/6]

ISR

(

INT2_vect

)

Direction input change interrupt service routine.

This interrupt service routine is called every time the direction input pin changes state. The desired direction flag is updated accordingly. The motor control then goes into a state where it needs a stopped motor before any driving of the motor is performed.

Note

Depending on the TURN_OFF_MODE configuration, it will either coast or brake.

See also

TURN_OFF_MODE

Definition at line 1168 of file main.ino.

{
  // 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
}

Here is the call graph for this function:

ISR() [4/6]

ISR

(

PCINT0_vect

)

Hall sensor change interrupt service routine.

This interrupt service routine is called every time any of the hall sensors change. The actual direction, the reverse rotation and no hall connections flags are updated.

The motor stopped flag is also set to FALSE, since the motor is obviously not stopped when there is a hall change.

Definition at line 1129 of file main.ino.

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

Here is the call graph for this function:

ISR() [5/6]

ISR

(

TIMER1_OVF_vect

)

Timer1 Overflow Interrupt Service Routine.

This interrupt service routine (ISR) is triggered on Timer1 overflow. It calls the faultSequentialStateMachine() function to handle motor fault reporting.

See also

faultSequentialStateMachine()

Definition at line 1273 of file main.ino.

{
  faultSequentialStateMachine(&faultFlags, &motorFlags);
}

Here is the call graph for this function:

ISR() [6/6]

ISR

(

TIMER4_OVF_vect

)

Timer4 Overflow Event Interrupt Service Routine.

This interrupt service routine is trigger on Timer4 overflow. It manages the commutation ticks, which determines motor status. It also controls the execution of the speed regulation loop at constant intervals.

Definition at line 1202 of file main.ino.

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

Here is the call graph for this function:

loop()

void loop

(

)

Main Loop Function.

The main loop function is executed continuously in normal operation after the program has configured everything. It continually checks if the speed controller needs to be run.

Definition at line 271 of file main.ino.

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

Here is the call graph for this function:

PinChangeIntInit()

static void PinChangeIntInit ( void )

static

Initialize pin change interrupts.

This function initializes pin change interrupt on hall sensor input pins input, shutdown input and motor direction control input.

Definition at line 450 of file main.ino.

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

Here is the caller graph for this function:

PLLInit()

static void PLLInit ( void )

static

Initialize PLL (Phase-Locked Loop)

This function configures and initializes the PLL for clock generation. It sets the PLL frequency control register and waits until the PLL is locked and stable before returning.

Definition at line 335 of file main.ino.

{
  // 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
    ;
  }
}

Here is the caller graph for this function:

PortsInit()

static void PortsInit ( void )

static

Initialize I/O port directions and pull-up resistors.

This function initializes all I/O ports with the correct directions and enables pull-up resistors, if needed, for various pins and signals used in the motor control.

Definition at line 361 of file main.ino.

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

Here is the caller graph for this function:

RemoteUpdate()

static void RemoteUpdate ( void )

static

Check whether the remote pin is set and update flags accordingly.

This function checks the state of the remote pin and updates the motorFlags.

Note

This is only called during setup so any further pin changes are not detected.

Definition at line 627 of file main.ino.

{
  if ((PIND & (1 << REMOTE_PIN)) != 0)
  {
    motorFlags.remote = TRUE;
  }
  else
  {
    motorFlags.remote = FALSE;
  }
}

Here is the caller graph for this function:

ReverseRotationSignalUpdate()

static void ReverseRotationSignalUpdate ( void )

static

Update the reverse rotation flag.

This function compares the actual and desired direction flags to determine if the motor is running in the opposite direction of what is requested.

Definition at line 1010 of file main.ino.

{
  if (GetActualDirection() == GetDesiredDirection())
  {
    faultFlags.reverseDirection = FALSE;
  }
  else
  {
    faultFlags.reverseDirection = TRUE;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetDuty()

static void SetDuty ( const uint16_t duty )

static

Set duty cycle for TIM4.

This function sets the duty cycle for block commutation, where the duty range is 0-1023 (not in percentage). To convert to percentage, use: duty * 100 / 1023.

Parameters

duty	New duty cycle, range 0-1023.

Definition at line 761 of file main.ino.

{
  TC4H = duty >> 8;
  OCR4A = 0xFF & duty;
}

Here is the caller graph for this function:

setup()

void setup

(

void

)

Main initialization function.

The main initialization function initializes all subsystems needed for motor control.

Definition at line 211 of file main.ino.

{
  // 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();
}

Here is the call graph for this function:

SpeedController()

static void SpeedController ( void )

static

Speed regulator loop.

This function is called periodically every SPEED_CONTROLLER_TIME_BASE ticks. In this implementation, a simple PID controller loop is called, but this function could be replaced by any speed or other regulator.

If the SPEED_CONTROL_METHOD is set to SPEED_CONTROL_CLOSED_LOOP, a PID controller is used to regulate the speed. The speed input is converted into an increment set point, and a PID controller computes the output value. The output is limited to a maximum value of 255.

If the SPEED_CONTROL_METHOD is not set to SPEED_CONTROL_CLOSED_LOOP, a simple speed control mechanism is applied. If the motor is enabled, the function calculates the delta between the speed input and the current speed output. If the delta exceeds the maximum allowed change, it limits the change to SPEED_CONTROLLER_MAX_DELTA. If the motor is disabled, the speed output is set to 0.

Note

The behavior of this function depends on the SPEED_CONTROL_METHOD configuration.

See also

SPEED_CONTROL_METHOD, SPEED_CONTROLLER_TIME_BASE, SPEED_CONTROLLER_MAX_DELTA, SPEED_CONTROLLER_MAX_SPEED, PID_K_P, PID_K_I, PID_K_D_ENABLE, PID_K_D

Definition at line 664 of file main.ino.

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

Here is the call graph for this function:

Here is the caller graph for this function:

TimersInit()

void TimersInit

(

void

)

Initializes and synchronizes Timers.

This function sets the correct pre-scaler and starts all required timers.

Timer 1 is used to trigger the fault multiplexing on overflow. Timer 3 is used, if EMULATE_HALL is set, to trigger the change in hall output on overflow. Timer 4 is used to generate PWM outputs for the gates and trigger the commutation tick counter and check if the motor is spinning on overflow. The overflow event interrupt for Timer 4 is set outside this function at the end of the main initialization function.

See also

EMULATE_HALL, TIM3_FREQ, TimersSetModeBlockCommutation(), TimersSetModeBrake()

Definition at line 405 of file main.ino.

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

Here is the caller graph for this function:

TimersSetModeBlockCommutation()

static void TimersSetModeBlockCommutation ( void )

static

Configures timers for block commutation.

This function is called every time the drive waveform is changed and block commutation is needed. PWM outputs are safely disabled while configuration registers are changed to avoid unintended driving or shoot-through.

The function sets the PWM pins to input (High-Z) while changing modes and configures the timers. The output duty cycle is set to zero initially. It waits for the next PWM cycle to ensure that all outputs are updated, and then the motor drive waveform is set to block commutation. Finally, the PWM pins are changed back to output mode to allow PWM control.

Definition at line 779 of file main.ino.

{
  // 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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

TimersWaitForNextPWMCycle()

static void TimersWaitForNextPWMCycle ( void )

static

Wait for the start of the next PWM cycle.

This function waits for the beginning of the next PWM cycle to ensure smooth transitions between different PWM modes and avoid shoot-through conditions.

Definition at line 852 of file main.ino.

{
  // Clear Timer1 Capture event flag.
  TIFR4 = (1 << TOV4);
 
  // Wait for new Timer1 Capture event flag.
  while (!(TIFR4 & (1 << TOV4)))
  {
  }
}

Here is the caller graph for this function:

Variable Documentation

commutationTicks

volatile uint16_t commutationTicks = 0

The number of 'ticks' between two hall sensor changes (counter).

This variable is used to count the number of 'ticks' between each hall sensor change. It is cleared when the hall sensor change occurs. One 'tick' is one PWM period.

Note

The speed of the motor is inversely proportional to this value, but this variable is also reset to 0 when a hall sensor change is detected, so cannot be used to infer speed of the motor.

See also

lastCommutationTicks

Definition at line 105 of file main.ino.

current

volatile uint16_t current = 0

Current measurement (Register Value).

The most recent current measurement is stored in this variable.

The range is 0-1023.

This value is not scaled and represents the raw ADC register value. To obtain the scaled current value in amperes, you can use the formula:

\[ \text{Current (A)} = \frac{\text{REGISTER_VALUE} \times 0.004887586 \times 1000000}{\text{CURRENT_GAIN} \times \text{CURRENT_SENSE_RESISTOR}} \]

Where:

• REGISTER_VALUE : The raw ADC register value stored in this variable.
• 0.004887586 : The conversion factor for a 10-bit ADC with a Vref of 5V.
• CURRENT_GAIN : The gain of the current sense operational amplifier.
• CURRENT_SENSE_RESISTOR : The value of the shunt resistor in micro-ohms (μΩ).

The NEVB-3INV-001-01 comes with a current op-amp with a gain factor of 50 and a current sense resistor of value 2 mΩ. This corresponds to approximately 0.049 amperes (A) per register value.

See also

CURRENT_WARNING_THRESHOLD, CURRENT_ERROR_THRESHOLD

Definition at line 161 of file main.ino.

faultFlags

volatile faultflags_t faultFlags

Fault flags placed in I/O space for fast access.

This variable contains all the flags used for faults. It is placed in GPIOR1 register, which allows usage of several fast bit manipulation/branch instructions.

Definition at line 84 of file main.ino.

gateVref

volatile uint16_t gateVref = 0

Gate voltage measurement (Register Value)

The most recent gate voltage measurement is stored in this variable.

The range is 0-1023.

This value is not scaled and represents the raw ADC register value. To obtain the scaled gate voltage in volts, you can use the formula:

\[ \text{Voltage (V)} = \frac{\text{REGISTER_VALUE} \times 0.004887586 \times (\text{GATE_RTOP} + \text{GATE_RBOTTOM})}{\text{GATE_RBOTTOM}} \]

Where:

• REGISTER_VALUE : The raw ADC register value stored in this variable.
• 0.004887586 : The conversion factor for a 10-bit ADC with a Vref of 5V.
• GATE_RTOP : The top resistor value in ohms (Ω) in the potential divider.
• GATE_RBOTTOM : The bottom resistor value in ohms (Ω) in the potential divider.

NEVB-3INV-001-01 has a resistor divider with RTOP of 1 MΩ and RBOTTOM of 71.5 kΩ, so it corresponds to approximately 0.0732 volts (V) per register value.

Note

It is not used for any significant purpose in this implementation, but the measurement is updated.

Definition at line 190 of file main.ino.

incoming_byte

char incoming_byte = 0

Buffer for incoming serial data.

This variable is used to store the latest byte received from the serial interface. It's intended to temporarily hold data as it's being read from the serial buffer.

Definition at line 199 of file main.ino.

lastCommutationTicks

volatile uint16_t lastCommutationTicks = 0xffff

The number of 'ticks' between two hall sensor changes (store).

This variable is used to store the number of 'ticks' between each hall sensor change. It is set to the value in commutationTicks before it is cleared when the hall sensor change occurs.

One 'tick' is one PWM period. The speed of the motor is inversely proportional to this value.

See also

commutationTicks

Definition at line 118 of file main.ino.

motorConfigs

volatile motorconfigs_t motorConfigs

Motor Configs.

This variable contains some of the motor configurations.

Definition at line 90 of file main.ino.

motorFlags

volatile motorflags_t motorFlags

Motor control flags placed in I/O space for fast access.

This variable contains all the flags used for motor control. It is placed in GPIOR0 register, which allows usage of several fast bit manipulation/branch instructions.

Definition at line 76 of file main.ino.

speedInput

volatile uint8_t speedInput = 0

The most recent "speed" input measurement.

This variable is set by the ADC from the speed input reference pin. The range is 0-255.

Definition at line 125 of file main.ino.

speedOutput

volatile uint8_t speedOutput = 0

The most recent "speed" output from the speed controller.

This variable controls the duty cycle of the generated PWM signals. The range is 0-255.

Definition at line 132 of file main.ino.