instaspin_foc
proj_lab09.c
Go to the documentation of this file.
1 /* --COPYRIGHT--,BSD
2  * Copyright (c) 2012, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * * Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * * Neither the name of Texas Instruments Incorporated nor the names of
17  * its contributors may be used to endorse or promote products derived
18  * from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  * --/COPYRIGHT--*/
36 
38 
39 
44 
45 // **************************************************************************
46 // the includes
47 
48 // system includes
49 #include <math.h>
50 #include "main.h"
51 
52 #ifdef FLASH
53 #pragma CODE_SECTION(mainISR,"ramfuncs");
54 #endif
55 
56 // Include header files used in the main function
57 
58 
59 // **************************************************************************
60 // the defines
61 
62 #define LED_BLINK_FREQ_Hz 5
63 
64 
65 // **************************************************************************
66 // the globals
67 
68 uint_least16_t gCounter_updateGlobals = 0;
69 
71 
73 
74 #ifdef F2802xF
75 #pragma DATA_SECTION(halHandle,"rom_accessed_data");
76 #endif
78 
79 #ifdef F2802xF
80 #pragma DATA_SECTION(gUserParams,"rom_accessed_data");
81 #endif
83 
84 HAL_PwmData_t gPwmData = {_IQ(0.0), _IQ(0.0), _IQ(0.0)};
85 
87 
89 
90 #ifdef FAST_ROM_V1p6
92 #else
93 #ifdef F2802xF
94 #pragma DATA_SECTION(ctrl,"rom_accessed_data");
95 #endif
96 CTRL_Obj ctrl; //v1p7 format
97 #endif
98 
99 uint16_t gLEDcnt = 0;
100 
102 
103 #ifdef FLASH
104 // Used for running BackGround in flash, and ISR in RAM
105 extern uint16_t *RamfuncsLoadStart, *RamfuncsLoadEnd, *RamfuncsRunStart;
106 
107 #ifdef F2802xF
108 extern uint16_t *econst_start, *econst_end, *econst_ram_load;
109 extern uint16_t *switch_start, *switch_end, *switch_ram_load;
110 #endif
111 
112 #endif
113 
116 
118 
119 
120 #ifdef DRV8301_SPI
121 // Watch window interface to the 8301 SPI
122 DRV_SPI_8301_Vars_t gDrvSpi8301Vars;
123 #endif
124 
125 #ifdef DRV8305_SPI
126 // Watch window interface to the 8305 SPI
127 DRV_SPI_8305_Vars_t gDrvSpi8305Vars;
128 #endif
129 
131 
133 
135 
137 
138 // **************************************************************************
139 // the functions
140 
141 void main(void)
142 {
143  uint_least8_t estNumber = 0;
144 
145 #ifdef FAST_ROM_V1p6
146  uint_least8_t ctrlNumber = 0;
147 #endif
148 
149  // Only used if running from FLASH
150  // Note that the variable FLASH is defined by the project
151  #ifdef FLASH
152  // Copy time critical code and Flash setup code to RAM
153  // The RamfuncsLoadStart, RamfuncsLoadEnd, and RamfuncsRunStart
154  // symbols are created by the linker. Refer to the linker files.
155  memCopy((uint16_t *)&RamfuncsLoadStart,(uint16_t *)&RamfuncsLoadEnd,(uint16_t *)&RamfuncsRunStart);
156 
157  #ifdef F2802xF
158  //copy .econst to unsecure RAM
159  if(*econst_end - *econst_start)
160  {
161  memCopy((uint16_t *)&econst_start,(uint16_t *)&econst_end,(uint16_t *)&econst_ram_load);
162  }
163 
164  //copy .switch ot unsecure RAM
165  if(*switch_end - *switch_start)
166  {
167  memCopy((uint16_t *)&switch_start,(uint16_t *)&switch_end,(uint16_t *)&switch_ram_load);
168  }
169  #endif
170 
171  #endif
172 
173  // initialize the hardware abstraction layer
174  halHandle = HAL_init(&hal,sizeof(hal));
175 
176 
177  // check for errors in user parameters
178  USER_checkForErrors(&gUserParams);
179 
180 
181  // store user parameter error in global variable
182  gMotorVars.UserErrorCode = USER_getErrorCode(&gUserParams);
183 
184 
185  // do not allow code execution if there is a user parameter error
186  if(gMotorVars.UserErrorCode != USER_ErrorCode_NoError)
187  {
188  for(;;)
189  {
190  gMotorVars.Flag_enableSys = false;
191  }
192  }
193 
194 
195  // initialize the user parameters
196  USER_setParams(&gUserParams);
197 
198 
199  // set the hardware abstraction layer parameters
200  HAL_setParams(halHandle,&gUserParams);
201 
202 
203  // initialize the controller
204 #ifdef FAST_ROM_V1p6
205  ctrlHandle = CTRL_initCtrl(ctrlNumber, estNumber); //v1p6 format (06xF and 06xM devices)
206  controller_obj = (CTRL_Obj *)ctrlHandle;
207 #else
208  ctrlHandle = CTRL_initCtrl(estNumber,&ctrl,sizeof(ctrl)); //v1p7 format default
209 #endif
210 
211 
212  {
213  CTRL_Version version;
214 
215  // get the version number
216  CTRL_getVersion(ctrlHandle,&version);
217 
218  gMotorVars.CtrlVersion = version;
219  }
220 
221 
222  // set the default controller parameters
223  CTRL_setParams(ctrlHandle,&gUserParams);
224 
225 
226  // Initialize field weakening
227  fwHandle = FW_init(&fw,sizeof(fw));
228 
229 
230  // Disable field weakening
231  FW_setFlag_enableFw(fwHandle, false);
232 
233 
234  // Clear field weakening counter
235  FW_clearCounter(fwHandle);
236 
237 
238  // Set the number of ISR per field weakening ticks
240 
241 
242  // Set the deltas of field weakening
244 
245 
246  // Set initial output of field weakening to zero
247  FW_setOutput(fwHandle, _IQ(0.0));
248 
249 
250  // Set the field weakening controller limits
252 
253 
254  // setup faults
255  HAL_setupFaults(halHandle);
256 
257 
258  // initialize the interrupt vector table
259  HAL_initIntVectorTable(halHandle);
260 
261 
262  // enable the ADC interrupts
263  HAL_enableAdcInts(halHandle);
264 
265 
266  // enable global interrupts
267  HAL_enableGlobalInts(halHandle);
268 
269 
270  // enable debug interrupts
271  HAL_enableDebugInt(halHandle);
272 
273 
274  // disable the PWM
275  HAL_disablePwm(halHandle);
276 
277 
278 #ifdef DRV8301_SPI
279  // turn on the DRV8301 if present
280  HAL_enableDrv(halHandle);
281  // initialize the DRV8301 interface
282  HAL_setupDrvSpi(halHandle,&gDrvSpi8301Vars);
283 #endif
284 
285 #ifdef DRV8305_SPI
286  // turn on the DRV8305 if present
287  HAL_enableDrv(halHandle);
288  // initialize the DRV8305 interface
289  HAL_setupDrvSpi(halHandle,&gDrvSpi8305Vars);
290 #endif
291 
292 
293  // enable DC bus compensation
294  CTRL_setFlag_enableDcBusComp(ctrlHandle, true);
295 
296 
297  // compute scaling factors for flux and torque calculations
302 
303 
304  for(;;)
305  {
306  // Waiting for enable system flag to be set
307  while(!(gMotorVars.Flag_enableSys));
308 
310 
311  // Enable the Library internal PI. Iq is referenced by the speed PI now
312  CTRL_setFlag_enableSpeedCtrl(ctrlHandle, true);
313 
314  // loop while the enable system flag is true
315  while(gMotorVars.Flag_enableSys)
316  {
317  CTRL_Obj *obj = (CTRL_Obj *)ctrlHandle;
318 
319  // increment counters
321 
322  // enable/disable the use of motor parameters being loaded from user.h
324 
325  // enable/disable Rs recalibration during motor startup
327 
328  // enable/disable automatic calculation of bias values
329  CTRL_setFlag_enableOffset(ctrlHandle,gMotorVars.Flag_enableOffsetcalc);
330 
331 
332  if(CTRL_isError(ctrlHandle))
333  {
334  // set the enable controller flag to false
335  CTRL_setFlag_enableCtrl(ctrlHandle,false);
336 
337  // set the enable system flag to false
338  gMotorVars.Flag_enableSys = false;
339 
340  // disable the PWM
341  HAL_disablePwm(halHandle);
342  }
343  else
344  {
345  // update the controller state
346  bool flag_ctrlStateChanged = CTRL_updateState(ctrlHandle);
347 
348  // enable or disable the control
349  CTRL_setFlag_enableCtrl(ctrlHandle, gMotorVars.Flag_Run_Identify);
350 
351  if(flag_ctrlStateChanged)
352  {
353  CTRL_State_e ctrlState = CTRL_getState(ctrlHandle);
354 
355  if(ctrlState == CTRL_State_OffLine)
356  {
357  // enable the PWM
358  HAL_enablePwm(halHandle);
359  }
360  else if(ctrlState == CTRL_State_OnLine)
361  {
362  if(gMotorVars.Flag_enableOffsetcalc == true)
363  {
364  // update the ADC bias values
365  HAL_updateAdcBias(halHandle);
366  }
367  else
368  {
369  // set the current bias
370  HAL_setBias(halHandle,HAL_SensorType_Current,0,_IQ(I_A_offset));
371  HAL_setBias(halHandle,HAL_SensorType_Current,1,_IQ(I_B_offset));
372  HAL_setBias(halHandle,HAL_SensorType_Current,2,_IQ(I_C_offset));
373 
374  // set the voltage bias
375  HAL_setBias(halHandle,HAL_SensorType_Voltage,0,_IQ(V_A_offset));
376  HAL_setBias(halHandle,HAL_SensorType_Voltage,1,_IQ(V_B_offset));
377  HAL_setBias(halHandle,HAL_SensorType_Voltage,2,_IQ(V_C_offset));
378  }
379 
380  // Return the bias value for currents
381  gMotorVars.I_bias.value[0] = HAL_getBias(halHandle,HAL_SensorType_Current,0);
382  gMotorVars.I_bias.value[1] = HAL_getBias(halHandle,HAL_SensorType_Current,1);
383  gMotorVars.I_bias.value[2] = HAL_getBias(halHandle,HAL_SensorType_Current,2);
384 
385  // Return the bias value for voltages
386  gMotorVars.V_bias.value[0] = HAL_getBias(halHandle,HAL_SensorType_Voltage,0);
387  gMotorVars.V_bias.value[1] = HAL_getBias(halHandle,HAL_SensorType_Voltage,1);
388  gMotorVars.V_bias.value[2] = HAL_getBias(halHandle,HAL_SensorType_Voltage,2);
389 
390  // enable the PWM
391  HAL_enablePwm(halHandle);
392  }
393  else if(ctrlState == CTRL_State_Idle)
394  {
395  // disable the PWM
396  HAL_disablePwm(halHandle);
397  gMotorVars.Flag_Run_Identify = false;
398  }
399 
400  if((CTRL_getFlag_enableUserMotorParams(ctrlHandle) == true) &&
401  (ctrlState > CTRL_State_Idle) &&
402  (gMotorVars.CtrlVersion.minor == 6))
403  {
404  // call this function to fix 1p6
405  USER_softwareUpdate1p6(ctrlHandle);
406  }
407 
408  }
409  }
410 
411 
413  {
414  _iq Is_Max_squared_pu = _IQ((USER_MOTOR_MAX_CURRENT*USER_MOTOR_MAX_CURRENT)/ \
416  _iq Id_squared_pu = _IQmpy(CTRL_getId_ref_pu(ctrlHandle),CTRL_getId_ref_pu(ctrlHandle));
417 
418  // Take into consideration that Iq^2+Id^2 = Is^2
419  Iq_Max_pu = _IQsqrt(Is_Max_squared_pu-Id_squared_pu);
420 
421  //Set new max trajectory
422  CTRL_setSpdMax(ctrlHandle, Iq_Max_pu);
423 
424  // set the current ramp
426  gMotorVars.Flag_MotorIdentified = true;
427 
428  // set the speed reference
429  CTRL_setSpd_ref_krpm(ctrlHandle,gMotorVars.SpeedRef_krpm);
430 
431  // set the speed acceleration
433 
435  {
437 
438  USER_calcPIgains(ctrlHandle);
439 
440  // initialize the watch window kp and ki current values with pre-calculated values
441  gMotorVars.Kp_Idq = CTRL_getKp(ctrlHandle,CTRL_Type_PID_Id);
442  gMotorVars.Ki_Idq = CTRL_getKi(ctrlHandle,CTRL_Type_PID_Id);
443  }
444 
445  }
446  else
447  {
449 
450  // initialize the watch window kp and ki values with pre-calculated values
451  gMotorVars.Kp_spd = CTRL_getKp(ctrlHandle,CTRL_Type_PID_spd);
452  gMotorVars.Ki_spd = CTRL_getKi(ctrlHandle,CTRL_Type_PID_spd);
453 
454 
455  // the estimator sets the maximum current slope during identification
457  }
458 
459 
460  // when appropriate, update the global variables
462  {
463  // reset the counter
465 
466  updateGlobalVariables_motor(ctrlHandle);
467  }
468 
469 
470  // update Kp and Ki gains
471  updateKpKiGains(ctrlHandle);
472 
473  // set field weakening enable flag depending on user's input
474  FW_setFlag_enableFw(fwHandle,gMotorVars.Flag_enableFieldWeakening);
475 
476  // enable/disable the forced angle
478 
479  // enable or disable power warp
480  CTRL_setFlag_enablePowerWarp(ctrlHandle,gMotorVars.Flag_enablePowerWarp);
481 
482 #ifdef DRV8301_SPI
483  HAL_writeDrvData(halHandle,&gDrvSpi8301Vars);
484 
485  HAL_readDrvData(halHandle,&gDrvSpi8301Vars);
486 #endif
487 #ifdef DRV8305_SPI
488  HAL_writeDrvData(halHandle,&gDrvSpi8305Vars);
489 
490  HAL_readDrvData(halHandle,&gDrvSpi8305Vars);
491 #endif
492  } // end of while(gFlag_enableSys) loop
493 
494 
495  // disable the PWM
496  HAL_disablePwm(halHandle);
497 
498  // set the default controller parameters (Reset the control to re-identify the motor)
499  CTRL_setParams(ctrlHandle,&gUserParams);
500  gMotorVars.Flag_Run_Identify = false;
501 
502  } // end of for(;;) loop
503 
504 } // end of main() function
505 
506 
507 interrupt void mainISR(void)
508 {
509  // toggle status LED
510  if(gLEDcnt++ > (uint_least32_t)(USER_ISR_FREQ_Hz / LED_BLINK_FREQ_Hz))
511  {
512  HAL_toggleLed(halHandle,(GPIO_Number_e)HAL_Gpio_LED2);
513  gLEDcnt = 0;
514  }
515 
516 
517  // acknowledge the ADC interrupt
518  HAL_acqAdcInt(halHandle,ADC_IntNumber_1);
519 
520 
521  // convert the ADC data
522  HAL_readAdcData(halHandle,&gAdcData);
523 
524 
525  // run the controller
526  CTRL_run(ctrlHandle,halHandle,&gAdcData,&gPwmData);
527 
528 
529  // write the PWM compare values
530  HAL_writePwmData(halHandle,&gPwmData);
531 
532 
533  if(FW_getFlag_enableFw(fwHandle) == true)
534  {
535  FW_incCounter(fwHandle);
536 
537  if(FW_getCounter(fwHandle) > FW_getNumIsrTicksPerFwTick(fwHandle))
538  {
539  _iq refValue;
540  _iq fbackValue;
541  _iq output;
542 
543  FW_clearCounter(fwHandle);
544 
545  refValue = gMotorVars.VsRef;
546 
547  fbackValue = gMotorVars.Vs;
548 
549  FW_run(fwHandle, refValue, fbackValue, &output);
550 
551  CTRL_setId_ref_pu(ctrlHandle, output);
552 
554  }
555  }
556  else
557  {
558  CTRL_setId_ref_pu(ctrlHandle, _IQmpy(gMotorVars.IdRef_A, _IQ(1.0/USER_IQ_FULL_SCALE_CURRENT_A)));
559  }
560 
561  // setup the controller
562  CTRL_setup(ctrlHandle);
563 
564 
565  return;
566 } // end of mainISR() function
567 
568 
570 {
571  CTRL_Obj *obj = (CTRL_Obj *)handle;
572 
573  // get the speed estimate
574  gMotorVars.Speed_krpm = EST_getSpeed_krpm(obj->estHandle);
575 
576  // get the real time speed reference coming out of the speed trajectory generator
578 
579  // get the torque estimate
581 
582  // get the magnetizing current
583  gMotorVars.MagnCurr_A = EST_getIdRated(obj->estHandle);
584 
585  // get the rotor resistance
586  gMotorVars.Rr_Ohm = EST_getRr_Ohm(obj->estHandle);
587 
588  // get the stator resistance
589  gMotorVars.Rs_Ohm = EST_getRs_Ohm(obj->estHandle);
590 
591  // get the stator inductance in the direct coordinate direction
592  gMotorVars.Lsd_H = EST_getLs_d_H(obj->estHandle);
593 
594  // get the stator inductance in the quadrature coordinate direction
595  gMotorVars.Lsq_H = EST_getLs_q_H(obj->estHandle);
596 
597  // get the flux in V/Hz in floating point
598  gMotorVars.Flux_VpHz = EST_getFlux_VpHz(obj->estHandle);
599 
600  // get the flux in Wb in fixed point
601  gMotorVars.Flux_Wb = USER_computeFlux(handle, gFlux_pu_to_Wb_sf);
602 
603  // get the controller state
604  gMotorVars.CtrlState = CTRL_getState(handle);
605 
606  // get the estimator state
607  gMotorVars.EstState = EST_getState(obj->estHandle);
608 
609  // read Vd and Vq vectors per units
610  gMotorVars.Vd = CTRL_getVd_out_pu(ctrlHandle);
611  gMotorVars.Vq = CTRL_getVq_out_pu(ctrlHandle);
612 
613  // calculate vector Vs in per units
614  gMotorVars.Vs = _IQsqrt(_IQmpy(gMotorVars.Vd, gMotorVars.Vd) + _IQmpy(gMotorVars.Vq, gMotorVars.Vq));
615 
616  // read Id and Iq vectors in amps
617  gMotorVars.Id_A = _IQmpy(CTRL_getId_in_pu(ctrlHandle), _IQ(USER_IQ_FULL_SCALE_CURRENT_A));
618  gMotorVars.Iq_A = _IQmpy(CTRL_getIq_in_pu(ctrlHandle), _IQ(USER_IQ_FULL_SCALE_CURRENT_A));
619 
620  // calculate vector Is in amps
621  gMotorVars.Is_A = _IQsqrt(_IQmpy(gMotorVars.Id_A, gMotorVars.Id_A) + _IQmpy(gMotorVars.Iq_A, gMotorVars.Iq_A));
622 
623  // Get the DC buss voltage
624  gMotorVars.VdcBus_kV = _IQmpy(gAdcData.dcBus,_IQ(USER_IQ_FULL_SCALE_VOLTAGE_V/1000.0));
625 
626  return;
627 } // end of updateGlobalVariables_motor() function
628 
629 
631 {
632  if((gMotorVars.CtrlState == CTRL_State_OnLine) && (gMotorVars.Flag_MotorIdentified == true) && (Flag_Latch_softwareUpdate == false))
633  {
634  // set the kp and ki speed values from the watch window
635  CTRL_setKp(handle,CTRL_Type_PID_spd,gMotorVars.Kp_spd);
636  CTRL_setKi(handle,CTRL_Type_PID_spd,gMotorVars.Ki_spd);
637 
638  // set the kp and ki current values for Id and Iq from the watch window
639  CTRL_setKp(handle,CTRL_Type_PID_Id,gMotorVars.Kp_Idq);
640  CTRL_setKi(handle,CTRL_Type_PID_Id,gMotorVars.Ki_Idq);
641  CTRL_setKp(handle,CTRL_Type_PID_Iq,gMotorVars.Kp_Idq);
642  CTRL_setKi(handle,CTRL_Type_PID_Iq,gMotorVars.Ki_Idq);
643  }
644 
645  return;
646 } // end of updateKpKiGains() function
647 
648 
650 // end of file
651 
652 
653 
float_t EST_getFlux_VpHz(EST_Handle handle)
void EST_setFlag_enableForceAngle(EST_Handle handle, const bool state)
#define MAX_ACCEL_KRPMPS_SF
Defines the speed acceleration scale factor.
Definition: float/main.h:37
void HAL_enableGlobalInts(HAL_Handle handle)
void HAL_enableAdcInts(HAL_Handle handle)
USER_ErrorCode_e UserErrorCode
Definition: main.h:150
bool Flag_MotorIdentified
Definition: main.h:138
#define USER_MAX_NEGATIVE_ID_REF_CURRENT_A
LIMITS.
Definition: user.h:239
void CTRL_run(CTRL_Handle handle, HAL_Handle halHandle, const HAL_AdcData_t *pAdcData, HAL_PwmData_t *pPwmData)
float_t Lsq_H
Definition: main.h:172
_iq USER_computeFlux_pu_to_VpHz_sf(void)
Computes the scale factor needed to convert from per unit to V/Hz.
#define _IQ(A)
HAL_PwmData_t gPwmData
Defines the PWM data.
Definition: proj_lab09.c:84
_iq Iq_A
Definition: main.h:195
#define FW_INC_DELTA
bool Flag_Run_Identify
Definition: main.h:137
_iq EST_getSpeed_krpm(EST_Handle handle)
#define FW_DEC_DELTA
FW_Handle FW_init(void *pMemory, const size_t numBytes)
void USER_calcPIgains(CTRL_Handle handle)
Updates Id and Iq PI gains.
static bool FW_getFlag_enableFw(FW_Handle fwHandle)
CTRL_State_e CtrlState
Definition: main.h:147
static uint32_t FW_getNumIsrTicksPerFwTick(FW_Handle fwHandle)
_iq Iq_Max_pu
Definition: proj_lab09.c:117
bool Flag_enablePowerWarp
Definition: main.h:144
static void HAL_writePwmData(HAL_Handle handle, HAL_PwmData_t *pPwmData)
static void FW_setOutput(FW_Handle fwHandle, const _iq output)
void EST_setMaxCurrentSlope_pu(EST_Handle handle, const _iq maxCurrentSlope_pu)
_iq value[3]
#define NUM_MAIN_TICKS_FOR_GLOBAL_VARIABLE_UPDATE
Defines the number of main iterations before global variables are updated.
Definition: float/main.h:48
_iq CTRL_getId_in_pu(CTRL_Handle handle)
void HAL_writeDrvData(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars)
bool CTRL_isError(CTRL_Handle handle)
_iq gFlux_pu_to_Wb_sf
Definition: proj_lab09.c:130
void USER_softwareUpdate1p6(CTRL_Handle handle)
Recalculates Inductances with the correct Q Format.
static void HAL_acqAdcInt(HAL_Handle handle, const ADC_IntNumber_e intNumber)
bool Flag_Latch_softwareUpdate
Definition: proj_lab09.c:70
_iq EST_get_pu_to_krpm_sf(EST_Handle handle)
#define USER_IQ_FULL_SCALE_VOLTAGE_V
Defines full scale value for the IQ30 variable of Voltage inside the system.
Definition: user.h:88
static void FW_run(FW_Handle fwHandle, const _iq refValue, const _iq fbackValue, _iq *pOutValue)
void memCopy(uint16_t *srcStartAddr, uint16_t *srcEndAddr, uint16_t *dstAddr)
EST_Handle estHandle
void CTRL_setKi(CTRL_Handle handle, const CTRL_Type_e ctrlType, const _iq Ki)
FW_Obj fw
Definition: proj_lab09.c:114
bool Flag_enableForceAngle
Definition: main.h:139
uint_least16_t gCounter_updateGlobals
A counter that is denotes when to update the global variables.
Definition: proj_lab09.c:68
void CTRL_setFlag_enableCtrl(CTRL_Handle handle, const bool state)
void CTRL_setFlag_enableSpeedCtrl(CTRL_Handle handle, const bool state)
CTRL_Obj ctrl
Defines the CTRL object.
Definition: proj_lab09.c:96
#define V_B_offset
Definition: user.h:133
USER_Params gUserParams
The user parameters.
Definition: proj_lab09.c:82
long _iq
void USER_setParams(USER_Params *pUserParams)
Sets the user parameter values.
EST_State_e EstState
Definition: main.h:148
_iq gTorque_Ls_Id_Iq_pu_to_Nm_sf
Definition: proj_lab09.c:134
float_t Rs_Ohm
Definition: main.h:169
#define HAL_toggleLed
#define V_A_offset
ADC voltage offsets for A, B, and C phases.
Definition: user.h:132
#define I_A_offset
ADC current offsets for A, B, and C phases.
Definition: user.h:125
Defines the structures, global initialization, and functions used in MAIN.
void CTRL_setMaxAccel_pu(CTRL_Handle handle, const _iq maxAccel_pu)
_iq USER_computeFlux(CTRL_Handle handle, const _iq sf)
Computes Flux in Wb or V/Hz depending on the scale factor sent as parameter.
void HAL_setupFaults(HAL_Handle handle)
_iq Kp_Idq
Definition: main.h:185
float_t EST_getLs_d_H(EST_Handle handle)
void EST_setFlag_enableRsRecalc(EST_Handle handle, const bool state)
_iq CTRL_getIq_in_pu(CTRL_Handle handle)
static void HAL_enablePwm(HAL_Handle handle)
void CTRL_setParams(CTRL_Handle handle, USER_Params *pUserParams)
#define _IQmpy(A, B)
USER_ErrorCode_e USER_getErrorCode(USER_Params *pUserParams)
Gets the error code in the user parameters.
void HAL_enableDrv(HAL_Handle handle)
void updateGlobalVariables_motor(CTRL_Handle handle)
Updates the global motor variables.
Definition: proj_lab09.c:569
_iq VdcBus_kV
Definition: main.h:192
_iq Torque_Nm
Definition: main.h:165
_iq SpeedRef_krpm
Definition: main.h:157
_iq IdRef_A
Definition: main.h:154
_iq VsRef
Definition: main.h:191
_iq Ki_spd
Definition: main.h:183
void HAL_setupDrvSpi(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars)
float_t EST_getLs_q_H(EST_Handle handle)
bool CTRL_getFlag_enableUserMotorParams(CTRL_Handle handle)
void HAL_enableDebugInt(HAL_Handle handle)
static void FW_incCounter(FW_Handle fwHandle)
CTRL_State_e CTRL_getState(CTRL_Handle handle)
#define I_C_offset
Definition: user.h:127
float_t Flux_VpHz
Definition: main.h:173
bool Flag_enableUserParams
Definition: main.h:142
#define FW_NUM_ISR_TICKS_PER_CTRL_TICK
EST_State_e EST_getState(EST_Handle handle)
bool Flag_enableOffsetcalc
Definition: main.h:143
#define LED_BLINK_FREQ_Hz
Definition: proj_lab09.c:62
#define I_B_offset
Definition: user.h:126
_iq CTRL_getKp(CTRL_Handle handle, const CTRL_Type_e ctrlType)
void CTRL_setup(CTRL_Handle handle)
MATH_vec3 V_bias
Definition: main.h:199
#define MOTOR_Vars_INIT
Initialization values of global variables.
Definition: main.h:76
_iq CTRL_getVd_out_pu(CTRL_Handle handle)
CTRL_State_e
uint16_t gLEDcnt
Definition: proj_lab09.c:99
#define V_C_offset
Definition: user.h:134
_iq USER_computeTorque_Flux_Iq_pu_to_Nm_sf(void)
Computes the scale factor needed to convert from torque created by flux and Iq, from per unit to Nm...
_iq Speed_krpm
Definition: main.h:160
float_t EST_getIdRated(EST_Handle handle)
_iq Is_A
Definition: main.h:196
_iq Ki_Idq
Definition: main.h:186
void CTRL_setSpdMax(CTRL_Handle handle, const _iq spdMax)
float_t Rr_Ohm
Definition: main.h:168
float_t EST_getRs_Ohm(EST_Handle handle)
CTRL_Handle CTRL_initCtrl(const uint_least8_t estNumber, void *pMemory, const size_t numBytes)
HAL_Handle halHandle
The hal handle.
Definition: proj_lab09.c:77
float_t Lsd_H
Definition: main.h:171
_iq CTRL_getId_ref_pu(CTRL_Handle handle)
_iq gMaxCurrentSlope
Definition: proj_lab09.c:88
void CTRL_setFlag_enablePowerWarp(CTRL_Handle handle, const bool state)
static void FW_setFlag_enableFw(FW_Handle fwHandle, const bool state)
#define USER_ISR_FREQ_Hz
Defines the Interrupt Service Routine (ISR) frequency, Hz.
Definition: user.h:173
static void FW_clearCounter(FW_Handle fwHandle)
bool CTRL_updateState(CTRL_Handle handle)
_iq CTRL_getKi(CTRL_Handle handle, const CTRL_Type_e ctrlType)
static void HAL_disablePwm(HAL_Handle handle)
static void FW_setDeltas(FW_Handle fwHandle, const _iq delta_inc, const _iq delta_dec)
bool EST_isMotorIdentified(EST_Handle handle)
_iq USER_computeTorque_Nm(CTRL_Handle handle, const _iq torque_Flux_sf, const _iq torque_Ls_sf)
Computes Torque in Nm.
interrupt void mainISR(void)
The main interrupt service (ISR) routine.
Definition: proj_lab09.c:507
void CTRL_setFlag_enableOffset(CTRL_Handle handle, const bool state)
HAL_Handle HAL_init(void *pMemory, const size_t numBytes)
CTRL_Handle ctrlHandle
The controller handle.
Definition: proj_lab09.c:72
void CTRL_setFlag_enableDcBusComp(CTRL_Handle handle, const bool state)
#define _IQsqrt(A)
_iq EST_getMaxCurrentSlope_pu(EST_Handle handle)
void CTRL_setFlag_enableUserMotorParams(CTRL_Handle handle, const bool state)
_iq SpeedTraj_krpm
Definition: main.h:158
#define USER_IQ_FULL_SCALE_CURRENT_A
Defines the full scale current for the IQ variables, A.
Definition: user.h:102
HAL_AdcData_t gAdcData
Defines the ADC data.
Definition: proj_lab09.c:86
void updateKpKiGains(CTRL_Handle handle)
Updates Kp and Ki gains in the controller object.
Definition: proj_lab09.c:630
float_t MagnCurr_A
Definition: main.h:167
static void HAL_readAdcData(HAL_Handle handle, HAL_AdcData_t *pAdcData)
HAL_Obj hal
_iq gFlux_pu_to_VpHz_sf
Definition: proj_lab09.c:132
static _iq HAL_getBias(HAL_Handle handle, const HAL_SensorType_e sensorType, uint_least8_t sensorNumber)
bool Flag_enableSys
Definition: main.h:136
_iq Id_A
Definition: main.h:194
_iq MaxAccel_krpmps
Definition: main.h:159
_iq CTRL_getSpd_int_ref_pu(CTRL_Handle handle)
void CTRL_setId_ref_pu(CTRL_Handle handle, const _iq Id_ref_pu)
FW_Handle fwHandle
Definition: proj_lab09.c:115
static uint32_t FW_getCounter(FW_Handle fwHandle)
MATH_vec3 I_bias
Definition: main.h:198
bool Flag_enableRsRecalc
Definition: main.h:141
static void HAL_initIntVectorTable(HAL_Handle handle)
_iq Kp_spd
Definition: main.h:182
static void HAL_setBias(HAL_Handle handle, const HAL_SensorType_e sensorType, uint_least8_t sensorNumber, const _iq bias)
static void FW_setNumIsrTicksPerFwTick(FW_Handle fwHandle, const uint32_t numIsrTicksPerFwTick)
static void HAL_updateAdcBias(HAL_Handle handle)
void CTRL_getVersion(CTRL_Handle handle, CTRL_Version *pVersion)
uint16_t minor
CTRL_Version CtrlVersion
Definition: main.h:152
void main(void)
Definition: proj_lab09.c:141
float_t EST_getRr_Ohm(EST_Handle handle)
void HAL_setParams(HAL_Handle handle, const USER_Params *pUserParams)
volatile MOTOR_Vars_t gMotorVars
Definition: proj_lab09.c:101
void HAL_readDrvData(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars)
_iq gTorque_Flux_Iq_pu_to_Nm_sf
Definition: proj_lab09.c:136
bool Flag_enableFieldWeakening
Definition: main.h:140
#define USER_MOTOR_MAX_CURRENT
Definition: user.h:407
static void FW_setMinMax(FW_Handle fwHandle, const _iq outMin, const _iq outMax)
void USER_checkForErrors(USER_Params *pUserParams)
Checks for errors in the user parameter values.
CTRL_Obj * controller_obj
Definition: proj_lab10c.c:84
_iq CTRL_getVq_out_pu(CTRL_Handle handle)
_iq Flux_Wb
Definition: main.h:164
GPIO_Number_e
_iq USER_computeTorque_Ls_Id_Iq_pu_to_Nm_sf(void)
Computes the scale factor needed to convert from torque created by Ld, Lq, Id and Iq...
void CTRL_setSpd_ref_krpm(CTRL_Handle handle, const _iq spd_ref_krpm)
_iq USER_computeFlux_pu_to_Wb_sf(void)
Computes the scale factor needed to convert from per unit to Wb.
void CTRL_setKp(CTRL_Handle handle, const CTRL_Type_e ctrlType, const _iq Kp)