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
volatile motorflags_t motorFlags	__attribute__ ((address(0x4A)))
	Motor control flags placed in I/O space for fast access.
volatile faultflags_t faultFlags	__attribute__ ((address(0x3E)))
	Fault flags placed in I/O space for fast access.
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	__attribute__ ((always_inline)) void SetDuty(const uint16_t duty)
	Set duty cycle for TIM4.
	if (direction==0)
	ClearPWMPorts ()
TCCR4E &	DisablePWMOutputs ()
	EnablePWMOutputs ()

Variables
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)
static uint8_t	hall
	else
	tableAddress = (hall * 4)
	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)

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

__attribute__() [1/3]

volatile faultflags_t faultFlags __attribute__

(

(address(0x3E))

)

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.

__attribute__() [2/3]

volatile motorflags_t motorFlags __attribute__

(

(address(0x4A))

)

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.

__attribute__() [3/3]

static __attribute__ ( (always_inline) ) const

inlinestatic

Set duty cycle for TIM4.

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

Updates global desired direction flag.

Read the hall sensor inputs and decode the hall state.

Perform block commutation based on direction and hall sensor input.

Wait for the start of the next PWM cycle.

Configures timers for block commutation.

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.

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.

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

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.

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.

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

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

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

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:

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:

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 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 799 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:

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:

if()

if

(

direction

= = 0

)

Definition at line 887 of file main.ino.

  {
    tableAddress = blockCommutationTableForward;
  }

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:

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

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.

Before running the regulator, the function checks vbusVref against VBUS_MIN_THRESHOLD. If VBUS is below the threshold (e.g. motor power supply not yet applied), the PID integrator is reset, speedOutput is held at zero, and the function returns immediately. This prevents integrator wind-up and unintended drive output at startup.

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, PID_OUTPUT_MAX, VBUS_MIN_THRESHOLD

Definition at line 722 of file main.ino.

{
  if (motorFlags.enable == TRUE)
  {
    // Inhibit drive output if VBUS is not sufficiently powered. This prevents
    // PID integrator wind-up and unintended PWM when the motor power rail is
    // absent at startup.
    if (vbusVref < VBUS_MIN_THRESHOLD)
    {
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
      PIDResetIntegrator(&pidParameters);
#endif
      speedOutput = 0;
      return;
    }
 
#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 > PID_OUTPUT_MAX)
    {
      outputValue = PID_OUTPUT_MAX;
    }
 
    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:

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.

else

else

Initial value:

{
    tableAddress = blockCommutationTableReverse

Definition at line 891 of file main.ino.

hall

uint8_t hall

Initial value:

{
  const uint8_t *tableAddress

Definition at line 883 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.

PORTB

PORTB = (uint8_t)pgm_read_byte_near(tableAddress++)

Definition at line 902 of file main.ino.

PORTC

PORTC = (uint8_t)pgm_read_byte_near(tableAddress++)

Definition at line 903 of file main.ino.

PORTD

PORTD = (uint8_t)pgm_read_byte_near(tableAddress++)

Definition at line 904 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.

tableAddress

tableAddress = (hall * 4)

Definition at line 895 of file main.ino.

TCCR4E

TCCR4E = (uint8_t)pgm_read_byte_near(tableAddress)

Definition at line 905 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.