main.ino File Reference

Motor control implementation. More...

#include "config.h"
#include "tables.h"
#include "fault.h"
#include "filter.h"
#include "scpi.h"

Include dependency graph for main.ino:

Go to the source code of this file.

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	DisableMotor (void)
	Disable motor.
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 ()
	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 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.
static void	SetFaultFlag (fault_flag_t flag, uint8_t value)
	Sets a fault flag value.

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	ibus = 0
	Hi-side Current (IBUS) measurement (Register Value).
volatile int16_t	iphaseU = 0
	In-line Phase U current current measurement (Register Value).
volatile int16_t	iphaseV = 0
	In-line Phase V current current measurement (Register Value).
volatile int16_t	iphaseW = 0
	In-line Phase W current current measurement (Register Value).
volatile uint16_t	vbusVref = 0
	VBUS voltage measurement (Register Value)

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.

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 943 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.

Note

ADC_TRIGGER is set to ADC_TRIGGER_TIMER0_OVF. This triggers the ADC at a rate of ~977 samples per second. The ADC prescaler is set to ADC_PRESCALER_DIV_128 as this gives a 125kHz ADC clock. It is recommended to have the ADC clock between 50kHz and 200kHz to get maximum ADC resolution.

See also

ADC_TRIGGER

Definition at line 536 of file main.ino.

{
#if (WAIT_FOR_BOARD == TRUE)
  // Select initial AD conversion channel [IBUS] to check if board is connected.
  ADMUX = (ADC_REFERENCE_VOLTAGE | (1 << ADLAR) | ADC_MUX_L_IBUS);
  ADCSRB = ADC_MUX_H_IBUS;
  _delay_ms(1);
 
  // Enable ADC
  ADCSRA = (1 << ADEN);
 
  // Start ADC single conversion and discard first measurement.
  uint16_t adc_reading = ADCSingleConversion();
 
  // Enable pull up resistor
  PORTF |= (1 << IBUS_PIN);
 
  _delay_ms(10);
  SweepLEDsBlocking();
 
  // Start ADC single conversion to measure BREF.
  adc_reading = ADCSingleConversion();
 
  // Wait to check if any board is connected. Should be less than
  // 0x3C0 if the inverter board is connected
  while (adc_reading > 0x3C0)
  {
    SweepLEDsBlocking();
 
    // Start ADC single conversion to measure BREF.
    adc_reading = ADCSingleConversion();
 
    _delay_ms(10);
  }
 
  // Disable pull up resistor
  PORTF &= ~(1 << IBUS_PIN);
 
  _delay_ms(10);
 
#else
  // Select AD reference voltage and left adjust result.
  ADMUX = (ADC_REFERENCE_VOLTAGE | (1 << ADLAR));
 
  SweepLEDsBlocking();
#endif
 
  // 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 600 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 865 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 1018 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 1040 of file main.ino.

{
  // If the motor is not stopped, increment the tick counter.
  if (commutationTicks < COMMUTATION_TICKS_STOPPED)
  {
    commutationTicks++;
  }
  // If motor is stopped, set the stopped flag and clear the tick counter.
  else
  {
    // Set flags to notify that the motor is stopped.
    SetFaultFlag(FAULT_MOTOR_STOPPED, TRUE);
    lastCommutationTicks = 0xffff;
 
    // Get the current hall value.
    uint8_t hall = GetHall();
    if ((hall == 0) || (hall == 0b111))
    {
      SetFaultFlag(FAULT_NO_HALL_CONNECTIONS, TRUE);
    }
 
    // If the motor is in a fatal fault, motor is now stopped so loop forever.
    if (motorFlags.fatalFault == TRUE)
    {
      while (1)
      {
        faultSequentialStateMachine(&faultFlags, &motorFlags);
        _delay_ms(2);
      }
    }
    // If the motor is supposed to be enabled, and the drive method is not block commutation,
    // reset the speed output and set the drive waveform.
    else if (motorFlags.driveWaveform != WAVEFORM_BLOCK_COMMUTATION && motorFlags.enable == TRUE)
    {
      speedOutput = 0;
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
      PIDResetIntegrator(&pidParameters);
#endif
      TimersSetModeBlockCommutation();
      BlockCommutate(motorFlags.desiredDirection, GetHall());
    }
    // If the motor is supposed to be stopped, (and it has stopped now) ...
    else if (motorFlags.enable == FALSE)
    {
#if (TURN_OFF_MODE == TURN_OFF_MODE_RAMP)
      // ... unset the drive waveform and disable PWM outputs.
      motorFlags.driveWaveform = WAVEFORM_UNDEFINED;
      DisablePWMOutputs();
      ClearPWMPorts();
#endif
      // ... update the desired direction flag as this would not have been
      // updated if the direction was changed while the motor was running.
      DesiredDirectionUpdate();
    }
  }
}

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 366 of file main.ino.

{
  motorConfigs.tim4Freq = (uint32_t)F_MOSFET;
  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 918 of file main.ino.

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

Here is the caller graph for this function:

DisableMotor()

static void DisableMotor ( void )

static

Disable motor.

This function disables the motor by clearing the enable flag and performing 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_RAMP, it sets the motor to ramp down before disabling driver signals.

Note

The behavior of this function depends on the TURN_OFF_MODE configuration.

See also

TURN_OFF_MODE

Definition at line 659 of file main.ino.

{
  motorFlags.enable = FALSE;
  SetFaultFlag(FAULT_MOTOR_STOPPED, FALSE);
 
#if (TURN_OFF_MODE == TURN_OFF_MODE_COAST)
  // Disable driver signals to let the motor coast.
  motorFlags.driveWaveform = WAVEFORM_UNDEFINED;
  DisablePWMOutputs();
  ClearPWMPorts();
#endif
}

Here is the call graph for this function:

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 1005 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 992 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_RAMP, it sets the motor to ramp down before disabling driver signals.

Note

The behavior of this function depends on the TURN_OFF_MODE configuration.

See also

TURN_OFF_MODE

Definition at line 633 of file main.ino.

{
  if ((PIND & (1 << ENABLE_PIN)) != 0)
  {
    motorFlags.enable = TRUE;
  }
  else
  {
    DisableMotor();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

FatalError()

static void FatalError ( )

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:

• Sets the motor to stop rotation.
• Once the motor is stopped, it will loop indefinitely inside CommutationTicksUpdate().

Definition at line 781 of file main.ino.

{
  // Stop the motor.
  DisableMotor();
 
  // Once this is set no more faults will be registered creating a snapshot
  // of the failure point.
  motorFlags.fatalFault = TRUE;
}

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 339 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;
  motorFlags.fatalFault = FALSE;
 
  // 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:

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 903 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 1263 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_IBUS;
    ADCSRB &= ~ADC_MUX_H_BITS;
    ADCSRB |= ADC_MUX_H_IBUS;
    break;
  case (ADC_MUX_H_IBUS | ADC_MUX_L_IBUS):
    // Handle ADC conversion result for current measurement.
    ibus = ADCL >> 6;
    ibus |= (ADCH << 2);
    ADMUX &= ~ADC_MUX_L_BITS;
    ADMUX |= ADC_MUX_L_IPHASE_U;
    ADCSRB &= ~ADC_MUX_H_BITS;
    ADCSRB |= ADC_MUX_H_IPHASE_U;
 
#if (IBUS_FAULT_ENABLE == TRUE)
    // Debounce current error flags.
    static uint8_t currentErrorCount = 0;
    if (ibus > IBUS_ERROR_THRESHOLD)
    {
      if (currentErrorCount < 3)
      {
        currentErrorCount++;
      }
      else
      {
        SetFaultFlag(FAULT_OVER_CURRENT, TRUE);
        SetFaultFlag(FAULT_USER_FLAG1, TRUE);
        SetFaultFlag(FAULT_USER_FLAG2, TRUE);
        SetFaultFlag(FAULT_USER_FLAG3, TRUE);
        FatalError();
      }
    }
    else
#endif
        if (ibus > IBUS_WARNING_THRESHOLD)
    {
      SetFaultFlag(FAULT_OVER_CURRENT, TRUE);
#if (IBUS_FAULT_ENABLE == TRUE)
      currentErrorCount = 0;
#endif
    }
    else
    {
      SetFaultFlag(FAULT_OVER_CURRENT, FALSE);
#if (IBUS_FAULT_ENABLE == TRUE)
      currentErrorCount = 0;
#endif
    }
    break;
  case (ADC_MUX_H_IPHASE_U | ADC_MUX_L_IPHASE_U):
    // Handle ADC conversion result for phase current measurement.
    iphaseU = ADCL >> 6;
    iphaseU |= (ADCH << 2);
    ADMUX &= ~ADC_MUX_L_BITS;
    ADMUX |= ADC_MUX_L_IPHASE_V;
    ADCSRB &= ~ADC_MUX_H_BITS;
    ADCSRB |= ADC_MUX_H_IPHASE_V;
    break;
  case (ADC_MUX_H_IPHASE_V | ADC_MUX_L_IPHASE_V):
    // Handle ADC conversion result for phase current measurement.
    iphaseV = ADCL >> 6;
    iphaseV |= (ADCH << 2);
    ADMUX &= ~ADC_MUX_L_BITS;
    ADMUX |= ADC_MUX_L_IPHASE_W;
    ADCSRB &= ~ADC_MUX_H_BITS;
    ADCSRB |= ADC_MUX_H_IPHASE_W;
    break;
  case (ADC_MUX_H_IPHASE_W | ADC_MUX_L_IPHASE_W):
    // Handle ADC conversion result for phase current measurement.
    iphaseW = ADCL >> 6;
    iphaseW |= (ADCH << 2);
    ADMUX &= ~ADC_MUX_L_BITS;
    ADMUX |= ADC_MUX_L_VBUSVREF;
    ADCSRB &= ~ADC_MUX_H_BITS;
    ADCSRB |= ADC_MUX_H_VBUSVREF;
    break;
  case (ADC_MUX_H_VBUSVREF | ADC_MUX_L_VBUSVREF):
    // Handle ADC conversion result for gate voltage reference measurement.
    vbusVref = ADCL >> 6;
    vbusVref |= (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.
    SetFaultFlag(FAULT_USER_FLAG1, TRUE);
    SetFaultFlag(FAULT_USER_FLAG2, TRUE);
    SetFaultFlag(FAULT_USER_FLAG3, TRUE);
    FatalError();
    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 1101 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 motor is stopped and the desired direction flag is updated accordingly. The motor will not start again until the enable pin is turned on again.

Note

Depending on the TURN_OFF_MODE configuration, it will either coast or ramp down the motor.

See also

TURN_OFF_MODE

Definition at line 1156 of file main.ino.

{
  // Update desired direction flag.
  DesiredDirectionUpdate();
 
  // Stop the motor.
  DisableMotor();
}

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 1115 of file main.ino.

{
  static uint8_t lastHall = 0xff;
  uint8_t hall;
 
  hall = GetHall();
 
  if (motorFlags.driveWaveform == WAVEFORM_BLOCK_COMMUTATION)
  {
    BlockCommutate(motorFlags.desiredDirection, 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.
  // For fast access, SetFaultFlag() is not used to update this flag.
  // Instead, the flag is updated directly.
  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 1244 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.

See also

TimersInit(), F_MOSFET

Definition at line 1173 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 321 of file main.ino.

{
  if (motorFlags.remote == TRUE)
  {
    ScpiInput(Serial);
  }
  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 500 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 381 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 407 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 679 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.

Note

For fast access, SetFaultFlag() is not used to update this flag. Instead, the flag is updated directly.

Definition at line 974 of file main.ino.

{
  if (motorFlags.actualDirection == motorFlags.desiredDirection)
  {
    faultFlags.reverseDirection = FALSE;
  }
  else
  {
    faultFlags.reverseDirection = TRUE;
  }
}

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 799 of file main.ino.

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

Here is the caller graph for this function:

SetFaultFlag()

static void SetFaultFlag ( fault_flag_t flag, uint8_t value )

static

Sets a fault flag value.

This function sets the specified fault flag to the value given.

Parameters

[in]	flags	Pointer to a faultflags_t structure.
[in]	flag	The fault flag to set as defined in the fault_flag_t enumeration.
[in]	value	The boolean value to set the fault flag to.

See also

faultflags_t, fault_flag_t

Definition at line 1382 of file main.ino.

{
  if (motorFlags.fatalFault)
  {
    // Fatal fault active, cannot set any more flags.
    return;
  }
 
  switch (flag)
  {
  case FAULT_RESERVED:
    faultFlags.reserved = value;
    break;
  case FAULT_REVERSE_DIRECTION:
    faultFlags.reverseDirection = value;
    break;
  case FAULT_MOTOR_STOPPED:
    faultFlags.motorStopped = value;
    break;
  case FAULT_OVER_CURRENT:
    faultFlags.overCurrent = value;
    break;
  case FAULT_NO_HALL_CONNECTIONS:
    faultFlags.noHallConnections = value;
    break;
  case FAULT_USER_FLAG1:
    faultFlags.userFlag1 = value;
    break;
  case FAULT_USER_FLAG2:
    faultFlags.userFlag2 = value;
    break;
  case FAULT_USER_FLAG3:
    faultFlags.userFlag3 = value;
    break;
  default:
    return; // Invalid flag
  }
 
  return; // Success
}

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 267 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.
    ScpiInit();
  }
  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 716 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
  {
    if (speedOutput > 0)
    {
      if (speedOutput > SPEED_CONTROLLER_MAX_DELTA)
      {
        speedOutput -= SPEED_CONTROLLER_MAX_DELTA;
      }
      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.

Timer 0 is used by the Ardiono core to generate interrupts. For reference, it is set up in mode 3 (Fast PWM, TOP=0xFF) with a prescaler of 64. This means ovwerflow occurs ~977 times per second. The overflow interrupt is used to trigger the ADC conversion unless changed by the user.

See also

EMULATE_HALL, TIM3_FREQ, TimersSetModeBlockCommutation()

Definition at line 455 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(F_MOSFET));
}

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 817 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 844 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 81 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 GPIOR0 register, which allows usage of several fast bit manipulation/branch instructions.

Warning

This variable can only have a maximum size of 1 byte.

Definition at line 60 of file main.ino.

ibus

volatile uint16_t ibus = 0

Hi-side Current (IBUS) 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.004888 \times 1000000}{\text{IBUS_GAIN} \times \text{IBUS_SENSE_RESISTOR}} \]

Where:

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

The NEVB-MTR1-I56-1 comes with a current op-amp with a gain factor of 50 and a current sense resistor of value 4 mΩ. This corresponds to approximately 0.0244 amperes (A) per register value.

See also

IBUS_WARNING_THRESHOLD, IBUS_ERROR_THRESHOLD

Definition at line 137 of file main.ino.

iphaseU

volatile int16_t iphaseU = 0

In-line Phase U current 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.004888 \times 1000000}{\text{IBUS_GAIN} \times \text{IBUS_SENSE_RESISTOR}} \]

Where:

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

The NEVB-MTR1-I56-1 comes with a current op-amp with a gain factor of 20 and a current sense resistor of value 2.5 mΩ. This corresponds to approximately TODO: amperes (A) per register value.

Note

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

Definition at line 167 of file main.ino.

iphaseV

volatile int16_t iphaseV = 0

In-line Phase V current 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.004888 \times 1000000}{\text{IBUS_GAIN} \times \text{IBUS_SENSE_RESISTOR}} \]

Where:

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

The NEVB-MTR1-I56-1 comes with a current op-amp with a gain factor of 20 and a current sense resistor of value 2.5 mΩ. This corresponds to approximately TODO: amperes (A) per register value.

Note

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

Definition at line 196 of file main.ino.

iphaseW

volatile int16_t iphaseW = 0

In-line Phase W current 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.004888 \times 1000000}{\text{IBUS_GAIN} \times \text{IBUS_SENSE_RESISTOR}} \]

Where:

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

The NEVB-MTR1-I56-1 comes with a current op-amp with a gain factor of 20 and a current sense resistor of value 2.5 mΩ. This corresponds to approximately TODO: amperes (A) per register value.

Note

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

Definition at line 226 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 94 of file main.ino.

motorConfigs

volatile motorconfigs_t motorConfigs

Motor Configs.

This variable contains some of the motor configurations.

Definition at line 66 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 GPIOR1 and GPIOR2 registers, which allows usage of several fast bit manipulation/branch instructions.

Warning

This variable can only have a maximum size of 2 bytes.

Definition at line 50 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 101 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 108 of file main.ino.

vbusVref

volatile uint16_t vbusVref = 0

VBUS voltage measurement (Register Value)

The most recent VBUS 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 VBUS voltage in volts, you can use the formula:

\[ \text{Voltage (V)} = \frac{\text{REGISTER_VALUE} \times 0.004888 \times (\text{VBUS_RTOP} + \text{VBUS_RBOTTOM})}{\text{VBUS_RBOTTOM}} \]

Where:

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

The NEVB-MTR1-C-1 has a resistor divider with RTOP of 100 kΩ and RBOTTOM of 6.2 kΩ, so it corresponds to approximately 0.0837 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 255 of file main.ino.