bldc.c File Reference

#include "bldc.h"
#include "sin_lut.h"

Include dependency graph for bldc.c:

Go to the source code of this file.

Functions
static void	adcerrorcallback (ADCDriver *adcp, adcerror_t err)
	Currently not used. More...
static uint16_t	encoderToLut (uint16_t position)
	Translates encoder position into a useable LUT value. More...
	THD_WORKING_AREA (wa_spiThread, THREAD_SIZE)
	Handles the SPI transaction, getting the position from the encoder. More...
	THD_FUNCTION (spiThread, arg)
	Prototype for spi thread function. More...
static sinctrl_t	scale (sinctrl_t duty_cycle)
	Scales the duty ccycle value from LUT 0 - 100%. More...
static void	pwmpcb (PWMDriver *pwmp)
	Periodic callback of the PWM driver. More...
void	bldcInit (bldc *pbldc)
	Sets up initial values for the BLDC object. More...
void	bldcStart (bldc *pbldc)
	Enables the three PWM channels, starting to go through the LUT. More...
void	bldcStop (bldc *pbldc)
	Stops BLDC control. More...
void	bldcSetDC (uint8_t channel, uint16_t dc)
	Changes duty cycle for a given channel. More...
void	bldcExit (bldc *pbldc)
	Function prototype with no return type. Takes bldc type as paramater. More...

Variables
bldc *	motor
static const ADCConversionGroup	adcgrpcfg
	ADC conversion group, used to configure the ADC driver Mode: Continuous, 1 sample of 1 channel, SW triggered. Channels: A0 Slowest sample rate possible, as putting it too high can lock other systems out. More...
static PWMConfig	pwmRWcfg
	Pwm driver configuration structure. More...

Function Documentation

adcerrorcallback()

static void adcerrorcallback ( ADCDriver *  adcp, adcerror_t  err  )

static

Currently not used.

                                                              {
    (void)adcp;
    (void)err;
}

bldcExit()

void bldcExit

(

bldc *

pbldc

)

Function prototype with no return type. Takes bldc type as paramater.

@ brief Tear down drivers in a sane way.

                                 {
    if(pbldc->started){
        bldcStop(pbldc);
    }
  adcStopConversion(&ADCD1);
  adcStop(&ADCD1); 
    chThdTerminate(motor->p_spi_thread);
    chThdWait(motor->p_spi_thread);
}

bldcInit()

void bldcInit

(

bldc *

pbldc

)

Sets up initial values for the BLDC object.

Function prototype with no return type. Takes bldc type as paramater.

                                 {
    motor = pbldc;
    motor->steps = STEPS;
    motor->stretch = STRETCH;
    motor->stretch_count = 0;
    motor->scale = SCALE;
    motor->skip = SKIP;
    motor->sinctrl = sinctrl360;
    motor->count = 0;
    motor->position = 0;
    motor->phase_shift = motor->steps/3;
    motor->u = 0;
    motor->v = motor->u + motor->phase_shift;
    motor->w = motor->v + motor->phase_shift;
  motor->openLoop = true;
    motor->started = FALSE;
    
    adcStart(&ADCD1, NULL); 
  adcStartConversion(&ADCD1, &adcgrpcfg, motor->samples, ADC_GRP_BUF_DEPTH);
    
    motor->p_spi_thread=chThdCreateStatic(
        wa_spiThread,
        sizeof(wa_spiThread),
        NORMALPRIO,
        spiThread,
        NULL
    );
}

bldcSetDC()

void bldcSetDC	(	uint8_t	channel,
		uint16_t	dc
	)

Changes duty cycle for a given channel.

Function prototype with no return type. Takes 8 bit unsigned integer and a 16 bit unsigned integer as argument.

                                                  {
    pwmEnableChannelI(
        &PWMD1,
        channel,
        PWM_PERCENTAGE_TO_WIDTH(&PWMD1,scale(dc))
    );
}

bldcStart()

void bldcStart

(

bldc *

pbldc

)

Enables the three PWM channels, starting to go through the LUT.

Function prototype with no return type. Takes bldc type as paramater.

                                  {
    if(pbldc->started){
        return; 
    }
    pwmStart(&PWMD1,&pwmRWcfg);
  pwmEnablePeriodicNotification(&PWMD1);
    
    pwmEnableChannel(&PWMD1,PWM_U,PWM_PERCENTAGE_TO_WIDTH(&PWMD1,motor->u));
  pwmEnableChannel(&PWMD1,PWM_V,PWM_PERCENTAGE_TO_WIDTH(&PWMD1,motor->v));
  pwmEnableChannel(&PWMD1,PWM_W,PWM_PERCENTAGE_TO_WIDTH(&PWMD1,motor->w));
    pbldc->started = TRUE;
}

bldcStop()

void bldcStop

(

bldc *

pbldc

)

Stops BLDC control.

Function prototype with no return type. Takes bldc type as paramater.

                                 {
    if(!pbldc->started){
        return;
    }
    pwmDisableChannel(&PWMD1,PWM_U);
  pwmDisableChannel(&PWMD1,PWM_V);
  pwmDisableChannel(&PWMD1,PWM_W);
  pwmDisablePeriodicNotification(&PWMD1);
    pwmStop(&PWMD1);
    pbldc->started = FALSE;
}

encoderToLut()

static uint16_t encoderToLut ( uint16_t  position )

static

Translates encoder position into a useable LUT value.

Since it takes 6 passes through the LUT to get one physical revolution of the motor, we need a way to index a value of 0 - 2^14 into a value of 0 - 360, in 6 separate ranges

                                               {
  uint16_t step = 0;
  uint8_t chunk = (position * CHUNK_AMOUNT) / ENCODER_MAX;
  step = ((position - chunk_low[chunk]) * (STEPS)) / CHUNK_SIZE;

  return step;
}

pwmpcb()

static void pwmpcb ( PWMDriver *  pwmp )

static

Periodic callback of the PWM driver.

At the end of each period, we call this, and go to the next step in the LUT, which changes absed off of closed or open loop control. Holds the logic for stretching, skipping, and repeating, to modify the LUT values on the fly.

If open loop, ignore encoder feedback.

Calculate the difference between the current step in the LUT and the next step in the LUT, and break it up into the desired amount of steps in between the two

                                    {
  (void)pwmp;
  
    if(motor->openLoop){
        motor->u += motor->skip;
        motor->v += motor->skip;
        motor->w += motor->skip;

        motor->u = motor->u % 360;
        motor->v = motor->v % 360;
        motor->w = motor->w % 360;
                
        motor->current_sin_u = motor->sinctrl[motor->u];
        motor->current_sin_v = motor->sinctrl[motor->v];
        motor->current_sin_w = motor->sinctrl[motor->w];
    }else{
        if (motor->stretch_count == 0){
            motor->u = encoderToLut(motor->position);
            motor->v = (motor->u + motor->phase_shift) % 360;
            motor->w = (motor->v + motor->phase_shift) % 360;
            motor->current_sin_u = motor->sinctrl[motor->u];
            motor->current_sin_v = motor->sinctrl[motor->v];
            motor->current_sin_w = motor->sinctrl[motor->w];
            motor->next_sin_u = motor->sinctrl[motor->u+1];
            motor->next_sin_v = motor->sinctrl[motor->v+1];
            motor->next_sin_w = motor->sinctrl[motor->w+1];

            motor->sin_diff = (motor->current_sin_u > motor->next_sin_u)?
                                                (motor->current_sin_u - motor->next_sin_u) : 
                                                (motor->next_sin_u - motor->current_sin_u);
            motor->sin_diff = motor->sin_diff / motor->stretch;
            motor->stretch_count = motor->stretch;
        }

        motor->current_sin_u += motor->sin_diff;
        motor->current_sin_v += motor->sin_diff;
        motor->current_sin_w += motor->sin_diff;

        motor->stretch_count = motor->stretch_count - 1;
    }

    bldcSetDC(PWM_U,motor->current_sin_u);
    bldcSetDC(PWM_V,motor->current_sin_v);
    bldcSetDC(PWM_W,motor->current_sin_w);
}

scale()

static sinctrl_t scale ( sinctrl_t  duty_cycle )

static

Scales the duty ccycle value from LUT 0 - 100%.

                                            {
    return ((duty_cycle*motor->scale)/100) + ((10000*(motor->scale/2))/100);    
}

THD_FUNCTION()

THD_FUNCTION	(	spiThread	,
		arg
	)

Prototype for spi thread function.

                           {
  (void)arg;
    chRegSetThreadName("spiThread");

  spiStart(&SPID1,&spicfg);             // Start driver.
  spiAcquireBus(&SPID1);                // Gain ownership of bus.

  while (!chThdShouldTerminateX()) {
        motor->spi_rxbuf[0] = 0;
        spiSelect(&SPID1);                  // Select slave.

        while(SPID1.state != SPI_READY) {}   
        spiReceive(&SPID1,1,motor->spi_rxbuf); // Receive 1 frame (16 bits).
        spiUnselect(&SPID1);                // Unselect slave.

        motor->position = 0x3FFF & motor->spi_rxbuf[0];
     
  }

    spiReleaseBus(&SPID1);    // Release ownership of bus.
    spiStop(&SPID1);          // Stop driver.
}

THD_WORKING_AREA()

THD_WORKING_AREA	(	wa_spiThread	,
		THREAD_SIZE
	)

Handles the SPI transaction, getting the position from the encoder.

Variable Documentation

adcgrpcfg

const ADCConversionGroup adcgrpcfg

static

Initial value:

= {
    TRUE,
    ADC_GRP_NUM_CHANNELS,
    NULL,
    adcerrorcallback,
    ADC_CFGR1_CONT | ADC_CFGR1_RES_12BIT,      
    ADC_TR(0, 0),                              
    ADC_SMPR_SMP_239P5,                        
    ADC_CHSELR_CHSEL0                          
}

ADC conversion group, used to configure the ADC driver Mode: Continuous, 1 sample of 1 channel, SW triggered. Channels: A0 Slowest sample rate possible, as putting it too high can lock other systems out.

Todo:

: combine this with a timer to not spam interrupts so much?

motor

bldc* motor

pwmRWcfg

PWMConfig pwmRWcfg

static

Initial value:

= {
  PWM_TIMER_FREQ,   
  PWM_PERIOD,   
  pwmpcb,
  {
   {PWM_OUTPUT_ACTIVE_HIGH|PWM_COMPLEMENTARY_OUTPUT_ACTIVE_HIGH, NULL},
   {PWM_OUTPUT_ACTIVE_HIGH|PWM_COMPLEMENTARY_OUTPUT_ACTIVE_HIGH, NULL},
   {PWM_OUTPUT_ACTIVE_HIGH|PWM_COMPLEMENTARY_OUTPUT_ACTIVE_HIGH, NULL},
   {PWM_OUTPUT_DISABLED, NULL}
  },
  0,
    0,
  0
}

Pwm driver configuration structure.

PWM_TIMER_FREQ is our timer clock in Hz

PWM_PERIOD period in ticks

Configured with pwmpcb as the periodic callback PWM channels 0,1,2 are all active high, with a complementary output and no channel callback