main.c File Reference

---

Detailed Description

Motor control implementation.

This file contains the full implementation of the motor control, except the PID-controller.

Application note:

AVR449: Sinusoidal driving of three-phase permanent motor using ATtiny261/461/861.

Documentation

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

Author:

Atmel Corporation: http://www.atmel.com
Support email: avr@atmel.com

$Name$

Revision

2571

$RCSfile$

Date

2007-10-08 15:53:50 +0200 (ma, 08 okt 2007)

Definition in file main.c.

#include <ioavr.h>
#include <inavr.h>
#include "stdint.h"
#include "PMSM.h"
#include "PMSM_tables.h"
#include "TinyX61_macros.h"

Include dependency graph for main.c:

Go to the source code of this file.

Functions
static void	ActualDirectionUpdate (uint8_t lastHall, const uint8_t newHall)
	Updates global actual direction flag based on the two latest hall values.
static void	ADCInit (void)
	Sets up the ADC for speed reference input on PA7.
static void	AdjustSineTableIndex (const uint16_t increment)
	Adjusts the sine table index according to the current increment.
static void	BlockCommutate (const uint8_t direction, const uint8_t hall)
	Performs block commutation according to running direction and hall sensor input.
static void	BlockCommutationSetDuty (const uint16_t compareValue)
	Sets the duty cycle when operating in block commutation mode.
static void	CommutationTicksUpdate (void)
	Updates the 'tick' counter and checks for stopped motor.
static void	DesiredDirectionUpdate (void)
	Updates global desired direction flag.
static void	DisablePWMOutputs (void)
	Disable PWM outputs by setting the port direction to input.
static void	EnablePWMOutputs (void)
	Enable PWM outputs by setting the port direction to output.
__interrupt void	FaultProtectionISR ()
	Hardware fault protection interrupt.
static uint8_t	GetDesiredDirection (void)
	Returns the desired direction.
static uint8_t	GetHall (void)
	Reads the hall sensor inputs.
__interrupt void	HallChangeISR ()
	Updates the PWM outputs according to the current position and amplitude.Hall sensor change interrupt service routine.
static uint8_t	IsMotorSynchronized (void)
	Returns the motor synchronized flag.
void	main (void)
static void	MotorSynchronizedUpdate (void)
	Updates the global motor synchronized flag.
static unsigned int	MultiplyUS15x8 (const uint16_t m15, const uint8_t m8)
	Fast unsigned multiply of a 15 bit number with an 8 bit number with 15 bit result.
static void	PinChangeInit (void)
	Initialize Pin change interrupt for hall sensors.
static void	PLLInit (void)
	Initialize PLL.
static void	PortsInit (void)
	Initialize port pin directions and internal pull-ups.
static void	PWMInit (void)
	Initialize PWM on Timer/counter1.
static void	SetAdvanceCommutation (const uint8_t advanceCommutation)
	Sets the advance commutation.
static void	SineOutputUpdate (void)
	Get the sine table value from the small sine table.Updates the PWM outputs according to the current position and amplitude.
static uint16_t	SineTableIncrementCalculate (const uint16_t ticks)
	Calculates step size for sine table iteration.
static void	SpeedController (uint16_t speedReference)
	Speed controller loop.
__interrupt void	Timer1OverflowISR ()
	Timer/counter1 overflow interrupt service routine.
static void	TimerSetModeBlockCommutation (void)
	Configures Timer/counter1 in block commutation mode.
static void	TimerSetModeBrake (void)
	Configures Timer/Counter1 in braking mode.
static void	TimerSetModeSinusoidal (void)
	Configures Timer/Counter1 in Sinusoidal mode.
Variables
__no_init __regvar volatile uint8_t	advanceCommutationSteps
	The advance commutation angle.
__no_init __regvar volatile uint16_t	amplitude
	The amplitude of the generated sine waves.
__no_init __regvar volatile uint16_t	commutationTicks
	The number of 'ticks' between two hall sensor changes.
__no_init __regvar volatile uint16_t	sineTableIncrement
	Increment used for sine table iteration.
__no_init __regvar volatile uint16_t	sineTableIndex
	Index into sine table.
__no_init __regvar volatile uint8_t	sineTableNextSectorStart
	Index to the end of the current commutation sector.
__no_init __regvar volatile uint8_t	speedControllerTimer
	Time in ticks until the speed controller loop should be executed.
volatile __io PMSMflags_t fastFlags	x0a
	Motor control flags placed in I/O space for fast access.

---

Function Documentation

static void ActualDirectionUpdate	(	uint8_t	lastHall,
		const uint8_t	newHall
	)			[static]

Updates 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 last hall value.
	newHall	The current hall value.

Definition at line 521 of file main.c.

References PMSMflags::actualDirection, DIRECTION_FORWARD, DIRECTION_REVERSE, DIRECTION_UNKNOWN, expectedHallSequenceForward, expectedHallSequenceReverse, FALSE, and PMSMflags::motorSynchronized.

Referenced by HallChangeISR().

{
  //Make sure that lastHall is within bounds of table. If not, set to an
  //illegal hall value, but legal table index.
  if (lastHall > 7)
  {
    lastHall = 0;
  }
  if (expectedHallSequenceForward[lastHall] == newHall)
  {
    fastFlags.actualDirection = DIRECTION_FORWARD;
  }
  else if (expectedHallSequenceReverse[lastHall] == newHall)
  {
   fastFlags.actualDirection = DIRECTION_REVERSE;
  }
  else
  {
    PMSMflags_t tempFlags = fastFlags;
    tempFlags.actualDirection = DIRECTION_UNKNOWN;
    tempFlags.motorSynchronized = FALSE;
    fastFlags = tempFlags;
  }
}

static void ADCInit

(

void

)

[static]

Sets up the ADC for speed reference input on PA7.

This function initializes the ADC for speed reference measurements. The ADC will operate in single conversion mode.

Definition at line 239 of file main.c.

Referenced by main().

{
  //Use PA7 as ADC input, 2.56V internal voltage reference without bypass capacitor.
  ADMUX = (1 << REFS1) | (0 << MUX4) | (0 << MUX3) | (1 << MUX2) | (1 << MUX1) | (0 << MUX0);

  ADCSRA = (1 << ADEN) |                  //Enable the ADC.
           (1 << ADSC) |                  //Start the first converssion.
           (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);   // Prescaler CK/128.
  ADCSRB = (1 << REFS2); //2.56V internal reference.
}

static void AdjustSineTableIndex

(

const uint16_t

increment

)

[static]

Adjusts the sine table index according to the current increment.

This function increases the sine table index with the given increment The index is then adjusted to be within the table length.

Parameters:

increment

The increment (in 8.8 format) added to the sine table index.

Definition at line 572 of file main.c.

References SINE_TABLE_LENGTH, sineTableIndex, and sineTableNextSectorStart.

Referenced by Timer1OverflowISR().

{
  sineTableIndex += increment;

  // If the table index is out of bounds, wrap the index around the table end
  // to continue from the beginning. Also wrap the next sector start index.
  if ((sineTableIndex >> 8) >= SINE_TABLE_LENGTH)
  {
    sineTableIndex -= (SINE_TABLE_LENGTH << 8);
    sineTableNextSectorStart -= SINE_TABLE_LENGTH;
  }

  //Make copy of sineNextSectorStart to specify order of volatile access.
  uint8_t nextSectorStart = sineTableNextSectorStart;
  if ((sineTableIndex >> 8) > nextSectorStart)
  {
    sineTableIndex = (nextSectorStart << 8);
  }
}

static void BlockCommutate	(	const uint8_t	direction,
		const uint8_t	hall
	)			[static]

Performs block commutation according to running direction and hall sensor input.

This function performs a block commutation according to the specified running direction and hall sensor input.

Note:

Do not use this function while the timers are configured for sine wave driving.

Parameters:

	direction	Direction of rotation.
	hall	Hall sensor value at the same form as returned by GetHall().

Definition at line 454 of file main.c.

References blockCommutationTableForward, blockCommutationTableReverse, and DIRECTION_FORWARD.

Referenced by CommutationTicksUpdate(), and HallChangeISR().

{
  if (direction == DIRECTION_FORWARD)
  {
    TCCR1E = blockCommutationTableForward[hall];
  }
  else
  {
    TCCR1E = blockCommutationTableReverse[hall];
  }
}

static void BlockCommutationSetDuty

(

const uint16_t

compareValue

)

[static]

Sets the duty cycle when operating in block commutation mode.

Calling this function sets the duty cycle when operating in block commutation mode (PWM6 mode). Do not use this function when Timer/counter1 is not operated in PWM6 mode.

Note that the argument specifies the output compare value, not the duty cycle in percent. The duty cycle in percent can be calculated as duty = (compareValue / PWM_TOP_VALUE) * 100.

Parameters:

compareValue

Ouput compare value.

Definition at line 419 of file main.c.

References TC1_PWM6_SET_DUTY_CYCLE.

Referenced by Timer1OverflowISR(), and TimerSetModeBlockCommutation().

{
  TC1_PWM6_SET_DUTY_CYCLE(compareValue);
}

static void CommutationTicksUpdate

(

void

)

[static]

Updates the 'tick' counter and checks for stopped motor.

This function should be run at every PWM timer overflow to ensure that all 'ticks' are counted. It increases the 'tick' counter until it reaches the maximum tick limit that corresponds to what is considered a stopped or stalled motor. In that case, the global motor stopped flag is set.

Definition at line 642 of file main.c.

References BlockCommutate(), COMMUTATION_TICKS_STOPPED, commutationTicks, FALSE, GetDesiredDirection(), GetHall(), pid_Reset_Integrator(), sineTableIncrement, TimerSetModeBlockCommutation(), TRUE, and WAVEFORM_BLOCK_COMMUTATION.

Referenced by Timer1OverflowISR().

{
  if (commutationTicks < COMMUTATION_TICKS_STOPPED)
  {
    commutationTicks++;
  }
  else
  {
    fastFlags.motorStopped = TRUE;
    fastFlags.motorSynchronized = FALSE;
    sineTableIncrement = 0;
    if (fastFlags.driveWaveform != WAVEFORM_BLOCK_COMMUTATION)
    {
      TimerSetModeBlockCommutation();
      BlockCommutate(GetDesiredDirection(), GetHall());

#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
      pid_Reset_Integrator(&pidParameters);
#endif
    }
  }
}

Here is the call graph for this function:

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 499 of file main.c.

References DIRECTION_FORWARD, DIRECTION_PIN, and DIRECTION_REVERSE.

Referenced by main(), and Timer1OverflowISR().

{
  if ( (PINA & (1 << DIRECTION_PIN)) != 0 )
  {
    fastFlags.desiredDirection = DIRECTION_REVERSE;
  }
  else
  {
    fastFlags.desiredDirection = DIRECTION_FORWARD;
  }
}

static void DisablePWMOutputs

(

void

)

[static]

Disable PWM outputs by setting the port direction to input.

Disables PWM outputs by setting the port direction to input for the PWM pins.

Definition at line 627 of file main.c.

References PWM_PIN_MASK_PORTB.

Referenced by Timer1OverflowISR(), TimerSetModeBlockCommutation(), TimerSetModeBrake(), and TimerSetModeSinusoidal().

{
  DDRB &= (~PWM_PIN_MASK_PORTB);
}

static void EnablePWMOutputs

(

void

)

[static]

Enable PWM outputs by setting the port direction to output.

Enables PWM outputs by setting the port direction to output for the PWM pins.

Definition at line 616 of file main.c.

References PWM_PIN_MASK_PORTB.

Referenced by TimerSetModeBlockCommutation(), TimerSetModeBrake(), and TimerSetModeSinusoidal().

{
  DDRB |= PWM_PIN_MASK_PORTB;
}

__interrupt void FaultProtectionISR

(

)

Hardware fault protection interrupt.

This ISR will be run every time the hardware fault protection disables the PWM outputs. The required action to this event will be different from application to application. Here, a delay is inserted, before the PWM outputs are once again enabled.

Definition at line 1028 of file main.c.

References pid_Reset_Integrator().

{
  __delay_cycles(10000000);
  TCCR1D |= (1 << FPEN1);
#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
  pid_Reset_Integrator(&pidParameters);
#endif
}

Here is the call graph for this function:

static uint8_t GetDesiredDirection

(

void

)

[static]

Returns the desired direction.

This function returns the current desired direction.

Note:

The direction input is not read at this time. A separate pin change interrupt is responsible for reading the input.

Return values:

	DIRECTION_FORWARD	Forward direction is requested.
	DIRECTION_REVERSE	Reverse direction is requested.

Definition at line 436 of file main.c.

Referenced by CommutationTicksUpdate(), HallChangeISR(), and SineOutputUpdate().

{
  return (uint8_t)fastFlags.desiredDirection;
}

static uint8_t GetHall

(

void

)

[static]

Reads the hall sensor inputs.

This function reads the hall sensor inputs and converts it to a number from 1 to 6 by combining the hall sensors as bits: H3|H2|H1.

Note:

It is possible to change the physical placement of hall sensor inputs, but the recommended configuration is the one used in this example, since it requires very little code to decode the hall values.

Returns:

The decoded hall sensor value.

Return values:

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

Definition at line 483 of file main.c.

References H1_PIN, H2_PIN, and H3_PIN.

Referenced by CommutationTicksUpdate(), and HallChangeISR().

{
  uint8_t hall;

  hall = (PINA) & ((1 << H3_PIN) | (1 << H2_PIN) | (1 << H1_PIN));
  hall >>= H1_PIN;
  return hall;
}

__interrupt void HallChangeISR

(

)

Updates the PWM outputs according to the current position and amplitude.Hall sensor change interrupt service routine.

This ISR is run every time one of the hall sensor inputs changes value. The responsibilities of this ISR are:

• Synchronize sine wave generation to hall sensors.
• Block commutation.
• Direction control.
• Synchronization control.
• Sine table increment calculation.
• Stop detection.

Definition at line 887 of file main.c.

References ActualDirectionUpdate(), advanceCommutationSteps, BlockCommutate(), commutationTicks, CSOffsetsForward, CSOffsetsReverse, DIRECTION_FORWARD, FALSE, GetDesiredDirection(), GetHall(), IsMotorSynchronized(), MotorSynchronizedUpdate(), sineTableIncrement, SineTableIncrementCalculate(), sineTableIndex, sineTableNextSectorStart, TABLE_ELEMENTS_PER_COMMUTATION_SECTOR, TimerSetModeSinusoidal(), WAVEFORM_BLOCK_COMMUTATION, and WAVEFORM_SINUSOIDAL.

{
  static uint8_t lastHall = 0xff;
  uint8_t hall;

  hall = GetHall();

  //Make sure that the hall sensors really changed.
  if (hall == lastHall)
  {
    return;
  }

  MotorSynchronizedUpdate();
  uint8_t synch = IsMotorSynchronized();
  if ((fastFlags.driveWaveform != WAVEFORM_SINUSOIDAL) && (synch))
  {
    TimerSetModeSinusoidal();
  }

  //If sinusoidal driving is used, synchronize sine wave generation to the
  //current hall sensor value. Advance commutation (lead angle) is also
  //added in the process.
  if (fastFlags.driveWaveform == WAVEFORM_SINUSOIDAL)
  {
    uint16_t tempIndex;
    if (GetDesiredDirection() == DIRECTION_FORWARD)
    {
      tempIndex = (CSOffsetsForward[hall] + advanceCommutationSteps) << 8;
    }
    else
    {
      tempIndex = (CSOffsetsReverse[hall] + advanceCommutationSteps) << 8;
    }
    sineTableIndex = tempIndex;

    //Adjust next sector start index. It might be set to a value larger than
    //SINE_TABLE_LENGTH at this point. This is adjusted in AdjustSineTableIndex
    //and should not be done here, as it will cause problems when advance
    //commutation is used.
    sineTableNextSectorStart = (tempIndex >> 8) + TABLE_ELEMENTS_PER_COMMUTATION_SECTOR;

  }
  //If block commutation is used. Commutate according to hall signal.
  else if (fastFlags.driveWaveform == WAVEFORM_BLOCK_COMMUTATION)
  {
    BlockCommutate(GetDesiredDirection(), hall);
  }

  //Update the actual direction flag.
  ActualDirectionUpdate(lastHall, hall);

  lastHall = hall;


  //Calculate new step size for sine wave generation and reset commutation
  //timer.
  sineTableIncrement = SineTableIncrementCalculate(commutationTicks);
  commutationTicks = 0;

  //Since the hall sensors are changing, the motor can not be stopped.
  fastFlags.motorStopped = FALSE;
}

Here is the call graph for this function:

static uint8_t IsMotorSynchronized

(

void

)

[static]

Returns the motor synchronized flag.

This function returns the motor synchronized flag.

Returns:

The motor synchronized flag.

Return values:

	TRUE	Motor control is synchronized with motor.
	FALSE	Motor control is not yet synchronized with motor.

Definition at line 708 of file main.c.

Referenced by HallChangeISR().

{
  return (uint8_t)(fastFlags.motorSynchronized);
}

void main

(

void

)

Definition at line 120 of file main.c.

References PMSMflags::actualDirection, ADCInit(), PMSMflags::desiredDirection, DesiredDirectionUpdate(), DIRECTION_UNKNOWN, PMSMflags::driveWaveform, FALSE, PMSMflags::motorStopped, PMSMflags::motorSynchronized, pid_Init(), PID_K_D, PID_K_I, PID_K_P, PinChangeInit(), PLLInit(), PortsInit(), PWMInit(), SetAdvanceCommutation(), SPEED_CONTROLLER_TIME_BASE, SpeedController(), speedControllerTimer, and WAVEFORM_UNDEFINED.

{
  PortsInit();
  PLLInit();
  PWMInit();
  PinChangeInit();
  ADCInit();

#if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)
  pid_Init(PID_K_P, PID_K_I, PID_K_D, &pidParameters);
#endif

  speedControllerTimer= SPEED_CONTROLLER_TIME_BASE;
  SetAdvanceCommutation(0);

  //Initialize fastflags. Use temporary variable to avoid several accesses to
  //volatile variable.
  {
    PMSMflags_t fastFlagsInitial;

    // 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.
    fastFlagsInitial.motorStopped = FALSE;

    // Set motorSyncronized to FALSE at startup. This will prevent the motor from being
    // driven until the motor is in synch or stopped.
    fastFlagsInitial.motorSynchronized = FALSE;
    fastFlagsInitial.actualDirection = DIRECTION_UNKNOWN;
    fastFlagsInitial.desiredDirection = 0;
    fastFlagsInitial.driveWaveform = WAVEFORM_UNDEFINED;

    fastFlags = fastFlagsInitial;
  }

  DesiredDirectionUpdate();

  //Enable Timer/counter1 overflow.
  TIMSK |= (1 << TOV1);

  //Enable interrupts globally and let motor driver take over.
  __enable_interrupt();

  for (;;)
  {
    uint16_t speedReference;

    if ( !(ADCSRA & (1 << ADSC)) )
    {
      speedReference = ADC;
      ADCSRA |= (1 << ADSC);
    }

    if (speedControllerTimer == 0)
    {
      speedControllerTimer = SPEED_CONTROLLER_TIME_BASE;
      SpeedController(speedReference);
    }
  }
}

Here is the call graph for this function:

static void MotorSynchronizedUpdate

(

void

)

[static]

Updates the global motor synchronized flag.

This function updates the global motor synchronized flag. The motor control is considered to be synchronized with the motor when it is not stopped and the driver has detected a direction of rotation that corresponds to the desired direction a predefined number of times.

Definition at line 674 of file main.c.

References PMSMflags::actualDirection, PMSMflags::desiredDirection, FALSE, PMSMflags::motorStopped, PMSMflags::motorSynchronized, SYNCHRONIZATION_COUNT, and TRUE.

Referenced by HallChangeISR().

{
  static uint8_t synchCount = 0;

  PMSMflags_t tempFlags;

  tempFlags = fastFlags;

  if ((tempFlags.desiredDirection == tempFlags.actualDirection) &&
      (tempFlags.motorStopped == FALSE) && (tempFlags.motorSynchronized == FALSE))
  {
    synchCount++;
    if (synchCount >= SYNCHRONIZATION_COUNT)
    {
      fastFlags.motorSynchronized = TRUE;
    }
  }
  else
  {
    synchCount = 0;
  }
}

static unsigned int MultiplyUS15x8	(	const uint16_t	m15,
		const uint8_t	m8
	)			[static]

Fast unsigned multiply of a 15 bit number with an 8 bit number with 15 bit result.

This function performs a fast unsigned multiply of a 15 bit number with an 8 bit number. The lower byte of the result is discarded in the process, returning the 15 most significant bytes as result. The function has a fixed execution time of 50 CPU clock cycles.

Parameters:

	m15	15 bit unsigned value (0x0000-0x7fff)
	m8	8 bit unsigned value (0x00-0xff)

Returns:

15 most significant bits of m15 * m8 (m15 * m8 / 256)

Definition at line 1051 of file main.c.

Referenced by SineOutputUpdate().

{
  unsigned int result = 0x0000;

  if (m8 & (1 << 0))
  {
    result += m15;
  }
  result >>= 1;

  if (m8 & (1 << 1))
  {
    result += m15;
  }
  result >>= 1;
  if (m8 & (1 << 2))
  {
    result += m15;
  }
  result >>= 1;

  if (m8 & (1 << 3))
  {
    result += m15;
  }
  result >>= 1;

  if (m8 & (1 << 4))
  {
    result += m15;
  }
  result >>= 1;

  if (m8 & (1 << 5))
  {
    result += m15;
  }
  result >>= 1;
  if (m8 & (1 << 6))
  {
    result += m15;
  }
  result >>= 1;

  if (m8 & (1 << 7))
  {
    result += m15;
  }
  result >>= 1;

  return result;
}

static void PinChangeInit

(

void

)

[static]

Initialize Pin change interrupt for hall sensors.

Initializes the pin change interrupt for hall sensors.

Definition at line 255 of file main.c.

Referenced by main().

{
  //Initialize hall change interrupt
  PCMSK0 = (1 << PCINT2) | (1 << PCINT1) | (1 << PCINT0);
  //Clear all other pin change interrupts.
  PCMSK1 = 0x00;

  //
  GIMSK |= (1 << PCIE1);

  //Force the pin change interrupt to be triggered.
  DDRA |= ((1 << PA2) | (1 << PA1) | (1 << PA0));
  DDRA &= ~((1 << PA2) | (1 << PA1) | (1 << PA0));
}

static void PLLInit

(

void

)

[static]

Initialize PLL.

Waits for PLL lock and enables the PLL. This function does not enable the PLL clock. This should be done by setting the CKSEL fuses to 0001. Otherwise, the application will hang here forever.

Definition at line 203 of file main.c.

Referenced by main().

{
  //Wait for PLL lock
  while ( !(PLLCSR & (1 << PLOCK)) )
  {

  }
  PLLCSR = (1 << PCKE);
}

static void PortsInit

(

void

)

[static]

Initialize port pin directions and internal pull-ups.

Initializes port pin directions and internal pull-ups if needed.

Definition at line 187 of file main.c.

References H1_PIN, H2_PIN, and H3_PIN.

Referenced by main().

{
#if (HALL_PULL_UP_ENABLE)
  PORTA = (1 << H1_PIN) | (1 << H2_PIN) | (1 << H3_PIN);
#endif

  DDRA = (1 << PA4);
}

static void PWMInit

(

void

)

[static]

Initialize PWM on Timer/counter1.

Initializes PWM on Timer/counter1.

Definition at line 218 of file main.c.

References DEAD_TIME, PWM1X, PWM_INVERT_OUTPUT, PWM_TOP_VALUE, and TC1_WRITE_10_BIT_REGISTER.

Referenced by main().

{
  //Start TCNT1 with prescaler 1.
  TCCR1B = (PWM_INVERT_OUTPUT << PWM1X) | (1 << CS10);

  //Enable fault protection input on INT0 pin, falling edge.
  TCCR1D = (1 << FPIE1) | (1 << FPEN1) | (0 << FPES1);

  //Set dead-time.
  DT1 = (DEAD_TIME << 4) | (DEAD_TIME);

  //Set PWM top value.
  TC1_WRITE_10_BIT_REGISTER(OCR1C, PWM_TOP_VALUE);
}

static void SetAdvanceCommutation

(

const uint8_t

advanceCommutation

)

[static]

Sets the advance commutation.

This function sets the advance commutation to be used during sine wave operation. An increase of one equals 1.875 degrees.

Note:

There is no checking of the advanceCommutation input parameter, but this should not be set to a value above 40 to avoid overflow in the sine table index.

Parameters:

advanceCommutation

The advance commutation. (1 equals 1.875 degrees)

Definition at line 605 of file main.c.

References advanceCommutationSteps.

Referenced by main().

{
  advanceCommutationSteps = advanceCommutation;
}

static void SineOutputUpdate

(

void

)

[static]

Get the sine table value from the small sine table.Updates the PWM outputs according to the current position and amplitude.

This functon uses the current position and amplitude setting to update the PWM outputs. This version uses the large sine table (3 * 192 elements).

Definition at line 749 of file main.c.

References amplitude, COMPARE_REGISTER_PHASE_U, COMPARE_REGISTER_PHASE_V, COMPARE_REGISTER_PHASE_W, DIRECTION_FORWARD, GetDesiredDirection(), MultiplyUS15x8(), sineTable, sineTableIndex, and TC1_WRITE_10_BIT_REGISTER.

Referenced by Timer1OverflowISR().

{
  uint8_t const __flash * sineTablePtr = sineTable;
  uint16_t temp;

  //Add sine table offset to pointer. Must be multiplied by 3, since one
  //value for each phase is stored in the table.
  //sineTablePtr += (uint8_t)(sineTableIndex >> 8) * 3;
  {
    uint8_t tempIndex = (uint8_t)(sineTableIndex >> 8);
    sineTablePtr += tempIndex;
    sineTablePtr += tempIndex;
    sineTablePtr += tempIndex;
  }

  //Calculate output duty cycles. Since one phase is always zero, the scaling
  //is only performed on the two non-zero phases, saving one multiply.

  //Calculate U phase output duty cycle.
  temp = *sineTablePtr++;
  if (temp != 0)
  {
    temp = MultiplyUS15x8(amplitude, temp);
  }
  TC1_WRITE_10_BIT_REGISTER(COMPARE_REGISTER_PHASE_U, temp);

  //Calculate U + 240 degree phase output duty cycle.
  temp = *sineTablePtr++;
  if (temp != 0)
  {
    temp = MultiplyUS15x8(amplitude, temp);
  }
  if (GetDesiredDirection() == DIRECTION_FORWARD)
  {
    TC1_WRITE_10_BIT_REGISTER(COMPARE_REGISTER_PHASE_V, temp);
  }
  else
  {
    TC1_WRITE_10_BIT_REGISTER(COMPARE_REGISTER_PHASE_W, temp);
  }

  //Calculate U + 120 degree phase output duty cycle.
  temp = *sineTablePtr++;
  if (temp != 0)
  {
    temp = MultiplyUS15x8(amplitude, temp);
  }
  if (GetDesiredDirection() == DIRECTION_FORWARD)
  {
    TC1_WRITE_10_BIT_REGISTER(COMPARE_REGISTER_PHASE_W, temp);
  }
  else
  {
    TC1_WRITE_10_BIT_REGISTER(COMPARE_REGISTER_PHASE_V, temp);
  }
}

Here is the call graph for this function:

static uint16_t SineTableIncrementCalculate

(

const uint16_t

ticks

)

[static]

Calculates step size for sine table iteration.

This function calculates the step size to be used for sine table iteration, based on the number of 'ticks' used for each electrical revolution.

Parameters:

ticks

The number of ticks in one electrical revolution.

Returns:

The step size in 8.8 format to be used for sine table iteration.

Definition at line 558 of file main.c.

References SINE_TABLE_LENGTH.

Referenced by HallChangeISR().

{
  return (uint16_t)(((SINE_TABLE_LENGTH / 6) << 8) / ticks);
}

static void SpeedController

(

uint16_t

speedReference

)

[static]

Speed controller loop.

This function is called 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) controller.

Definition at line 277 of file main.c.

References amplitude, pid_Controller(), PWM_TOP_VALUE, sineTableIncrement, SPEED_CONTROLLER_MAX_INCREMENT, and SPEED_CONTROLLER_MAX_INPUT.

Referenced by main().

{
  #if (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP)

  //Calculate an increment setpoint from the analog speed input.
  int16_t incrementSetpoint = ((uint32_t)speedReference * SPEED_CONTROLLER_MAX_INCREMENT) / SPEED_CONTROLLER_MAX_INPUT;

  //PID controller with feed forward from speed input.
  int32_t outputValue;
  outputValue = (uint32_t)speedReference;
  outputValue += pid_Controller(incrementSetpoint, (int16_t)sineTableIncrement, &pidParameters);

  if (outputValue < 0)
  {
    outputValue = 0;
  }
  else if (outputValue > PWM_TOP_VALUE)
  {
    outputValue = PWM_TOP_VALUE;
  }
  __disable_interrupt();
  amplitude = outputValue;
  __enable_interrupt();
#else
  __disable_interrupt();
  amplitude = speedReference;
  __enable_interrupt();
#endif
}

Here is the call graph for this function:

__interrupt void Timer1OverflowISR

(

)

Timer/counter1 overflow interrupt service routine.

This ISR is run every time Timer/counter1 overflows. This is the same moment as the double buffered PWM outputs are updated.

The responsibilities of this ISR are:

• Sine wave modulation update.
• Direction command input.
• Stop detection.
• Speed controller timing.

Definition at line 964 of file main.c.

References AdjustSineTableIndex(), amplitude, BLOCK_COMMUTATION_DUTY_MULTIPLIER, BlockCommutationSetDuty(), CommutationTicksUpdate(), DesiredDirectionUpdate(), DIRECTION_UNKNOWN, DisablePWMOutputs(), FALSE, PWM_TOP_VALUE, SineOutputUpdate(), sineTableIncrement, speedControllerTimer, TimerSetModeBrake(), WAVEFORM_BLOCK_COMMUTATION, WAVEFORM_SINUSOIDAL, and WAVEFORM_UNDEFINED.

{
  PORTA |= (1 << PA4);
  if (fastFlags.driveWaveform == WAVEFORM_SINUSOIDAL)
  {
    AdjustSineTableIndex(sineTableIncrement);
    SineOutputUpdate();
  }
  else if (fastFlags.driveWaveform == WAVEFORM_BLOCK_COMMUTATION)
  {
    uint16_t blockCommutationDuty = amplitude * BLOCK_COMMUTATION_DUTY_MULTIPLIER;

    if (blockCommutationDuty > PWM_TOP_VALUE)
    {
      blockCommutationDuty = PWM_TOP_VALUE;
    }
    BlockCommutationSetDuty(blockCommutationDuty);
  }

  //Update desired direction flag.
  DesiredDirectionUpdate();

  static uint8_t lastDesiredDirection = 0xff;
  if ( (fastFlags.desiredDirection != lastDesiredDirection))
  {
#if (TURN_MODE == TURN_MODE_COAST)
    //Disable driver signals to let motor coast. The motor will automatically
    //start once it is synchronized or stopped.
    DisablePWMOutputs();
    fastFlags.motorSynchronized = FALSE;
    fastFlags.driveWaveform = WAVEFORM_UNDEFINED;
#endif

#if (TURN_MODE == TURN_MODE_BRAKE)
    //Set motor in brake mode. The motor will automatically start once it is
    //synchronized or stopped.
      fastFlags.motorSynchronized = FALSE;
    if (fastFlags.actualDirection != DIRECTION_UNKNOWN)
    {
      TimerSetModeBrake(); // Automatically sets driveWaveform.
    }
#endif

    lastDesiredDirection = fastFlags.desiredDirection;
  }

  CommutationTicksUpdate();

  if (speedControllerTimer > 0)
  {
    speedControllerTimer--;
  }
  PORTA &= ~(1 << PA4);
}

Here is the call graph for this function:

static void TimerSetModeBlockCommutation

(

void

)

[static]

Configures Timer/counter1 in block commutation mode.

This function configures Timer/counter1 in block commutation mode in a safe way by disabling all output before any configuration bits are changed. After running this function, Timer/counter1 will be in dual slop PWM6 mode. Commutations can be performed by running 'BlockCommutate'. The duty cycle can be adjusted by calling 'BlockCommutationSetDuty'.

Definition at line 352 of file main.c.

References BlockCommutationSetDuty(), DisablePWMOutputs(), EnablePWMOutputs(), and WAVEFORM_BLOCK_COMMUTATION.

Referenced by CommutationTicksUpdate().

{
  //Set PWM pins to input (Hi-Z) while changing modes.
  DisablePWMOutputs();

  //Set Timer/counter1 in dual slope PWM6 mode, clear on upcounting, set on downcounting (non-inverting).
  TCCR1A = (1 << COM1A1) | (0 << COM1A0) | (1 << COM1B1) | (0 << COM1B0) | (1 << PWM1A) | (1 << PWM1B);
  TCCR1C = (1 << COM1A1S) | (0 << COM1A0S) | (1 << COM1B1S) | (0 << COM1B0S) | (1 << COM1D1) | (0 << COM1D0) | (1 << PWM1D);
  TCCR1D |= (1 << WGM11) | (1 << WGM10);

  TCCR1E = 0x00;

  //Set output duty cycle to 0.
  BlockCommutationSetDuty(0x0000);

  fastFlags.driveWaveform = WAVEFORM_BLOCK_COMMUTATION;

    //Change PWM pins to output again to allow PWM control.
  EnablePWMOutputs();
}

Here is the call graph for this function:

static void TimerSetModeBrake

(

void

)

[static]

Configures Timer/Counter1 in braking mode.

This function configures Timer/counter1 in sinusoidal mode in a safe way way by disabling all output before any configuration bits are changed. After running this function, Timer/counter1 will be in phase and frequency correct mode with a duty cycle of 0 on all three phases, resulting in low side braking.

Definition at line 384 of file main.c.

References DisablePWMOutputs(), EnablePWMOutputs(), TC1_SET_ALL_COMPARE_VALUES, and WAVEFORM_BRAKING.

Referenced by Timer1OverflowISR().

{
  //Set PWM pins to input (Hi-Z) while changing modes.
  DisablePWMOutputs();

  //Set Timer/counter1 in phase and frequency correct mode.
  TCCR1A = (0 << COM1A1) | (1 << COM1A0) | (0 << COM1B1) | (1 << COM1B0) | (1 << PWM1A) | (1 << PWM1B);
  TCCR1C =  (0 << COM1A1S) | (1 << COM1A0S) | (0 << COM1B1S) | (1 << COM1B0S) | (0 << COM1D1) | (1 << COM1D0) | (1 << PWM1D);
  TCCR1D &= ~((1 << WGM11) | (1 << WGM10));
  TCCR1D |= (0 << WGM11) | (1 << WGM10);

  //All output duty cycles at 0 creates a braking force. (Low side braking)
  TC1_SET_ALL_COMPARE_VALUES(0x0000);

  fastFlags.driveWaveform = WAVEFORM_BRAKING;

  //Change PWM pins to output again to allow PWM control.
  EnablePWMOutputs();
}

Here is the call graph for this function:

static void TimerSetModeSinusoidal

(

void

)

[static]

Configures Timer/Counter1 in Sinusoidal mode.

This function configures Timer/counter1 in sinusoidal mode in a safe way way by disabling all output before any configuration bits are changed. After running this function, Timer/counter1 will be in phase and frequency correct mode used for sine wave generation.

Definition at line 316 of file main.c.

References DisablePWMOutputs(), EnablePWMOutputs(), TC1_SET_ALL_COMPARE_VALUES, and WAVEFORM_SINUSOIDAL.

Referenced by HallChangeISR().

{
  //Set PWM pins to input (Hi-Z) while changing modes.
  DisablePWMOutputs();

  //Set Timer/counter1 in phase and frequency correct mode.
  TCCR1A = (0 << COM1A1) | (1 << COM1A0) | (0 << COM1B1) | (1 << COM1B0) | (1 << PWM1A) | (1 << PWM1B);
  TCCR1C =  (0 << COM1A1S) | (1 << COM1A0S) | (0 << COM1B1S) | (1 << COM1B0S) | (0 << COM1D1) | (1 << COM1D0) | (1 << PWM1D);
  TCCR1D &= ~((1 << WGM11) | (1 << WGM10));
  TCCR1D |= (0 << WGM11) | (1 << WGM10);

  TC1_SET_ALL_COMPARE_VALUES(0x0000);

  fastFlags.driveWaveform = WAVEFORM_SINUSOIDAL;

  //Wait for the PWM cycle to complete.
  TIFR = TIFR;
  while ( ! (TIFR & (1 << TOV1)) )
  {

  }

  //Change PWM pins to output again to allow PWM control.
  EnablePWMOutputs();
}

Here is the call graph for this function:

---

Variable Documentation

__no_init __regvar volatile uint8_t advanceCommutationSteps

The advance commutation angle.

This variable specifies a shift in the sine table that will generate a lead angle. For a 192 element sine table, an increase of one in advanceCommutationSteps will result in 1.875 degrees lead angle.

Definition at line 92 of file main.c.

Referenced by HallChangeISR(), and SetAdvanceCommutation().

__no_init __regvar volatile uint16_t amplitude

The amplitude of the generated sine waves.

This variable controls the amplitude of the generated sine waves. The range is 0-0x03ff.

Definition at line 82 of file main.c.

Referenced by SineOutputUpdate(), SpeedController(), and Timer1OverflowISR().

__no_init __regvar volatile uint16_t commutationTicks

The number of 'ticks' between two hall sensor changes.

This variable is used to count the number of 'ticks' between each hall sensor change. One 'tick' is one PWM period, 510 CPU clock cycles. This is used to calculate sine table increment. The speed of the motor is inversely proportional to this value.

Definition at line 74 of file main.c.

Referenced by CommutationTicksUpdate(), and HallChangeISR().

__no_init __regvar volatile uint16_t sineTableIncrement

Increment used for sine table iteration.

This variable holds the increment used for sine table iteration. It is stored in an 8.8 fixed point format.

Definition at line 55 of file main.c.

Referenced by CommutationTicksUpdate(), HallChangeISR(), SpeedController(), and Timer1OverflowISR().

__no_init __regvar volatile uint16_t sineTableIndex

Index into sine table.

This variable is used as an index into the sine table. It is stored in a 8.8 fixed point format, so it can be directly incremented by sineTableIncrement. Only the high byte is used as table index.

Definition at line 64 of file main.c.

Referenced by AdjustSineTableIndex(), HallChangeISR(), and SineOutputUpdate().

__no_init __regvar volatile uint8_t sineTableNextSectorStart

Index to the end of the current commutation sector.

This variable holds the index where the next commutation sector starts, including the advance commutation angle.

It is used to prevent the output from going further until the hall sensors changes.

Definition at line 103 of file main.c.

Referenced by AdjustSineTableIndex(), and HallChangeISR().

__no_init __regvar volatile uint8_t speedControllerTimer

Time in ticks until the speed controller loop should be executed.

This variable holds the number of ticks until the speed controller should be executed.

Definition at line 111 of file main.c.

Referenced by main(), and Timer1OverflowISR().

volatile __io PMSMflags_t fastFlags x0a

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 47 of file main.c.

---