motor_controller.h

/*
  @file motor_controller.h
*/

#ifndef __MOTOR_CONTROLLER_H__
#define __MOTOR_CONTROLLER_H__

typedef enum mc_directions{
  MC_POSITIVE = 1, 
  MC_NEGATIVE = -1  
} MOTOR_DIRECTION;
typedef enum mc_controls{
  MC_STOP = 0, 
  MC_START = 1 
} MOTOR_CONTROL;
typedef enum mc_direction_multipliers {
  MC_NORMAL = 1, 
  MC_BACKWARDS = -1 
} MC_OPERATION;

typedef enum mc_safety_causes{
  MC_NONE = 0,
  MC_THERM = 1, 
  MC_MECH = 2 
} MC_SAFETY_CAUSE;

typedef struct mc_data{
  float motor_voltage_max; 
  fixed current_max; 
  fixed current_min; 
  fixed target_max; 
  fixed target_min; 
  fixed thermal_safe; 
  fixed thermal_limit; 
  fixed tau_inv; 
  fixed thermal_diff; 
  fixed dt; 
  unsigned int error_limit; 
  fixed smart_error_limit; 
  fixed smart_error_limit_inverse; 
  fixed kp; 
  fixed ki; 
  fixed kd; 
  fixed integral; 
  fixed max_integral; 
  int max_pwm; 
  MC_OPERATION operation; 
  FIXED_VOID_F get_current; 
  FLOAT_VOID_F get_position; 
  FLOAT_VOID_F get_velocity; 
} MC_DATA;



// *********************** Function Declarations ************************
// Public Functions

//initializes the motor controller
void mc_init(float max_volts, //the maximum voltage the mc can take
  float max_current, //max current that can safely be put through the motor
  float min_current, //ditto, but in negative direction
  float max_target,
  float min_target,
  float thermal_current_limit,
  float thermal_time_constant,
  float kp,
  float ki,
  float kd,
  int max_pwm,
  int error_limit,
  float smart_error_limit,
  MC_OPERATION op,
  FIXED_VOID_F current,
  FLOAT_VOID_F position,
  FLOAT_VOID_F velocity);
  
//Control Functions
void mc_pid_current(void); //PID controller for current
void mc_set_target_current(float new_current);//sets the target_current of the pwm controller to new_current
MC_DATA* mc_get_parameters(void); //to set/update/read parameters
int mc_get_pwm(void);//returns the current pwm 
void mc_set_pwm(int pwm); //sets the pwm
void mc_run_no_control(void); //checks current and feeds watchdog; for debugging
void mc_set_error_level(unsigned long int error_level); //sets the error reporting level

//Safety Functions
static fixed mc_get_thermal_limiter(fixed current);
static fixed mc_smart_check_current(fixed current);
void mc_direction_control(MOTOR_DIRECTION dir, //the direction being controlled, either positive or negative
  MOTOR_CONTROL command); //controls whether the motor is allowed to turn in a given direction (MC_STOP or MC_START)
void mc_set_sleep(int sleep); //sets pwm to 0 if sleep
void mc_set_shutdown(int shutdown); //doesn't update watchdog timer if shutdown
static int mc_is_running(void); //returns true (1) if the motor controller is running, 0 otherwise
void mc_set_unsafe_target_current(float new_current);
float mc_get_mult(void);
static void mc_turnoff(MC_SAFETY_CAUSE reason);
static void mc_turnon(MC_SAFETY_CAUSE reason);

//Compliant control stuff
void mc_compliant_control(void);
void mc_set_command_current(float new_command);
void mc_set_stiffness(float new_c1);
void mc_set_dampness(float new_c2);
float mc_get_stiffness(void);
float mc_get_dampness(void);
float mc_get_command_current(void);

//Private Functions
static void mc_set_target_current_fixed(fixed new_current);
void mc_update_watchdog(void);//feeds the watchdog. Call this every ms or so
static void mc_check_current(fixed current); //checks the motor current; if the current is out of bounds for too long, calls mc_shutdown

/* HARDWARE SETUP
  // *******************************************************************************
  // Motor Controller Setup
  // *******************************************************************************
  //Motor control initialization
  //FIO0DIR |= (1<<9);    // set P0.9 to be output (PWM A)
  //FIO0DIR |= (1<<7);     // set P0.7 to be output (PWM B)
  FIO0DIR |= (1<<11);     // set P0.11 to be output (Low side enable A)
  FIO1DIR |= (1<<17);     // set P1.17 to be output (Low side enable B)
  FIO0DIR |= (1<<6);      // set P0.6 to be output (Watchdog timer) 
  //FIO0CLR = (1<<9);   // turn off PWM A output
  //FIO0CLR = (1<<7);   // turn off PWM B output
  FIO0SET = (1<<11);    // turn on low side A enable output
  FIO1SET = (1<<17);    // turn on low side B enable output
  FIO0CLR = (1<<6);   // turn off watchdog timer output
  //Initializes the PWM registers and PWM2 and PWM6 outputs
  //Pin Function Select
  PINSEL0 &= ~(3<<14);
  PINSEL0 |= (2<<14);  //PWM 2 on Pin P0.7 Enabled (bits 14/15)
  PINSEL0 &= ~(3<<18);
  PINSEL0 |= (2<<18);  //PWM 6 on Pin P0.9 Enabled (bits 18/19)
  //PWM Prescale Register. Controls number of PClK cycles per Timer Counter Cycle
  PWMPR= 0; //Will run at maximum rate
  //PWM Match Registers
  //PWM Match Register 0. Resets Timer Counter and sets all PWM outputs to 1.
  PWMMR0= 600; //100 kHz PWM frequency (60000000/600 = 100,000)
  PWMMR1= 0;
  PWMMR2= 0;
  PWMMR3= 0;
  PWMMR4= 0;
  PWMMR5= 0;
  PWMMR6= 0;
  //PWM Match Control Register
  PWMMCR= (PWMMCR|0x2) & ~PWMMCR_RB; //Should set Timer Counter to reset upon reaching Match Register 0
  //PWM Timer Control Register.
  PWMTCR= (PWMTCR|0x1) // Enable Timer Counter
      | (PWMTCR|0x8) // Enable PWM Mode
      & ~PWMTCR_RB; 
               //Must Occur after Initialization of Match Register 0.
  //PWM Control Register. Enables individual PWM types and outputs.
  PWMPCR= (PWMPCR|0x4400) & ~PWMPCR_RB; //Should mean the same thing as next 4 lines (PWM Control Register)
  //PWMSEL2= 0; //Enables Single Edge PWM 2 Control
  //PWMSEL6= 0; //Enables Single Edge PWM 6 Control
  //PWMENA2= 1; //PWM 2 Output Enabled
  //PWMENA6= 1; //PWM 6 Output Enabled
  //PWM Latch Enable Register. Updates Match values.
  //Each bit directly relates to a Match Register
  //PWMLER= 0;  //Latch Register to zero
  PWMMR2= 0;       // out of 600  -ve   
  PWMMR6= 0;       // out of 600  +ve        
  // Latch enable reg automatically cleared once PWM match values are set
  PWMLER= (PWMLER|0x45) & ~PWMLER_RB;  //Enable update of PWM match registers 0, 2 and 6.  0x45 --> bit0, bit2, bit6
*/

#endif // MOTOR_CONTROLLER_H