instaspin_foc
proj_lab10c.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 
75 
77 
78 HAL_PwmData_t gPwmData = {_IQ(0.0), _IQ(0.0), _IQ(0.0)};
79 
81 
83 
85 
86 #ifndef FAST_ROM_V1p6
87 CTRL_Obj ctrl; //v1p7 format
88 #endif
89 
90 uint16_t gLEDcnt = 0;
91 
93 
94 
95 #ifdef FLASH
96 // Used for running BackGround in flash, and ISR in RAM
97 extern uint16_t *RamfuncsLoadStart, *RamfuncsLoadEnd, *RamfuncsRunStart;
98 #endif
99 
100 
103 
104 // set the offset, default value of 1 microsecond
105 int16_t gCmpOffset = (int16_t)(1.0 * USER_SYSTEM_FREQ_MHz);
106 
107 MATH_vec3 gIavg = {_IQ(0.0), _IQ(0.0), _IQ(0.0)};
108 uint16_t gIavg_shift = 1;
109 
110 
111 #ifdef DRV8301_SPI
112 // Watch window interface to the 8301 SPI
113 DRV_SPI_8301_Vars_t gDrvSpi8301Vars;
114 #endif
115 
116 #ifdef DRV8305_SPI
117 // Watch window interface to the 8305 SPI
118 DRV_SPI_8305_Vars_t gDrvSpi8305Vars;
119 #endif
120 
122 
124 
126 
128 
129 // **************************************************************************
130 // the functions
131 
132 void main(void)
133 {
134  uint_least8_t estNumber = 0;
135 
136 #ifdef FAST_ROM_V1p6
137  uint_least8_t ctrlNumber = 0;
138 #endif
139 
140  // Only used if running from FLASH
141  // Note that the variable FLASH is defined by the project
142  #ifdef FLASH
143  // Copy time critical code and Flash setup code to RAM
144  // The RamfuncsLoadStart, RamfuncsLoadEnd, and RamfuncsRunStart
145  // symbols are created by the linker. Refer to the linker files.
146  memCopy((uint16_t *)&RamfuncsLoadStart,(uint16_t *)&RamfuncsLoadEnd,(uint16_t *)&RamfuncsRunStart);
147  #endif
148 
149 
150  // initialize the hardware abstraction layer
151  halHandle = HAL_init(&hal,sizeof(hal));
152 
153 
154  // check for errors in user parameters
155  USER_checkForErrors(&gUserParams);
156 
157 
158  // store user parameter error in global variable
159  gMotorVars.UserErrorCode = USER_getErrorCode(&gUserParams);
160 
161 
162  // do not allow code execution if there is a user parameter error
163  if(gMotorVars.UserErrorCode != USER_ErrorCode_NoError)
164  {
165  for(;;)
166  {
167  gMotorVars.Flag_enableSys = false;
168  }
169  }
170 
171 
172  // initialize the user parameters
173  USER_setParams(&gUserParams);
174 
175 
176  // set the hardware abstraction layer parameters
177  HAL_setParams(halHandle,&gUserParams);
178 
179 
180  // initialize the controller
181 #ifdef FAST_ROM_V1p6
182  ctrlHandle = CTRL_initCtrl(ctrlNumber, estNumber); //v1p6 format (06xF and 06xM devices)
183 #else
184  ctrlHandle = CTRL_initCtrl(estNumber,&ctrl,sizeof(ctrl)); //v1p7 format default
185 #endif
186 
187  controller_obj = (CTRL_Obj *)ctrlHandle;
188 
189 
190  {
191  CTRL_Version version;
192 
193  // get the version number
194  CTRL_getVersion(ctrlHandle,&version);
195 
196  gMotorVars.CtrlVersion = version;
197  }
198 
199 
200  // set the default controller parameters
201  CTRL_setParams(ctrlHandle,&gUserParams);
202 
203 
204  // Initialize and setup the 100% SVM generator
205  svgencurrentHandle = SVGENCURRENT_init(&svgencurrent,sizeof(svgencurrent));
206 
207  // setup svgen current
208  {
209  float_t minWidth_microseconds = 2.0;
210  uint16_t minWidth_counts = (uint16_t)(minWidth_microseconds * USER_SYSTEM_FREQ_MHz);
211 
212  SVGENCURRENT_setMinWidth(svgencurrentHandle, minWidth_counts);
213  SVGENCURRENT_setIgnoreShunt(svgencurrentHandle, use_all);
214  }
215 
216 
217  // set overmodulation to maximum value
218  gMotorVars.OverModulation = _IQ(MATH_TWO_OVER_THREE);
219 
220 
221  // setup faults
222  HAL_setupFaults(halHandle);
223 
224 
225  // initialize the interrupt vector table
226  HAL_initIntVectorTable(halHandle);
227 
228 
229  // enable the ADC interrupts
230  HAL_enableAdcInts(halHandle);
231 
232 
233  // enable global interrupts
234  HAL_enableGlobalInts(halHandle);
235 
236 
237  // enable debug interrupts
238  HAL_enableDebugInt(halHandle);
239 
240 
241  // disable the PWM
242  HAL_disablePwm(halHandle);
243 
244 
245 #ifdef DRV8301_SPI
246  // turn on the DRV8301 if present
247  HAL_enableDrv(halHandle);
248  // initialize the DRV8301 interface
249  HAL_setupDrvSpi(halHandle,&gDrvSpi8301Vars);
250 #endif
251 
252 #ifdef DRV8305_SPI
253  // turn on the DRV8305 if present
254  HAL_enableDrv(halHandle);
255  // initialize the DRV8305 interface
256  HAL_setupDrvSpi(halHandle,&gDrvSpi8305Vars);
257 #endif
258 
259 
260  // enable DC bus compensation
261  CTRL_setFlag_enableDcBusComp(ctrlHandle, true);
262 
263 
264  // compute scaling factors for flux and torque calculations
265  gFlux_pu_to_Wb_sf = USER_computeFlux_pu_to_Wb_sf();
266  gFlux_pu_to_VpHz_sf = USER_computeFlux_pu_to_VpHz_sf();
267  gTorque_Ls_Id_Iq_pu_to_Nm_sf = USER_computeTorque_Ls_Id_Iq_pu_to_Nm_sf();
268  gTorque_Flux_Iq_pu_to_Nm_sf = USER_computeTorque_Flux_Iq_pu_to_Nm_sf();
269 
270 
271  for(;;)
272  {
273  // Waiting for enable system flag to be set
274  while(!(gMotorVars.Flag_enableSys));
275 
276  // Enable the Library internal PI. Iq is referenced by the speed PI now
277  CTRL_setFlag_enableSpeedCtrl(ctrlHandle, true);
278 
279  // loop while the enable system flag is true
280  while(gMotorVars.Flag_enableSys)
281  {
282  CTRL_Obj *obj = (CTRL_Obj *)ctrlHandle;
283 
284  // increment counters
286 
287  // enable/disable the use of motor parameters being loaded from user.h
289 
290  // enable/disable Rs recalibration during motor startup
292 
293  // enable/disable automatic calculation of bias values
294  CTRL_setFlag_enableOffset(ctrlHandle,gMotorVars.Flag_enableOffsetcalc);
295 
296 
297  if(CTRL_isError(ctrlHandle))
298  {
299  // set the enable controller flag to false
300  CTRL_setFlag_enableCtrl(ctrlHandle,false);
301 
302  // set the enable system flag to false
303  gMotorVars.Flag_enableSys = false;
304 
305  // disable the PWM
306  HAL_disablePwm(halHandle);
307  }
308  else
309  {
310  // update the controller state
311  bool flag_ctrlStateChanged = CTRL_updateState(ctrlHandle);
312 
313  // enable or disable the control
314  CTRL_setFlag_enableCtrl(ctrlHandle, gMotorVars.Flag_Run_Identify);
315 
316  if(flag_ctrlStateChanged)
317  {
318  CTRL_State_e ctrlState = CTRL_getState(ctrlHandle);
319 
320  if(ctrlState == CTRL_State_OffLine)
321  {
322  // enable the PWM
323  HAL_enablePwm(halHandle);
324  }
325  else if(ctrlState == CTRL_State_OnLine)
326  {
327  if(gMotorVars.Flag_enableOffsetcalc == true)
328  {
329  // update the ADC bias values
330  HAL_updateAdcBias(halHandle);
331  }
332  else
333  {
334  // set the current bias
335  HAL_setBias(halHandle,HAL_SensorType_Current,0,_IQ(I_A_offset));
336  HAL_setBias(halHandle,HAL_SensorType_Current,1,_IQ(I_B_offset));
337  HAL_setBias(halHandle,HAL_SensorType_Current,2,_IQ(I_C_offset));
338 
339  // set the voltage bias
340  HAL_setBias(halHandle,HAL_SensorType_Voltage,0,_IQ(V_A_offset));
341  HAL_setBias(halHandle,HAL_SensorType_Voltage,1,_IQ(V_B_offset));
342  HAL_setBias(halHandle,HAL_SensorType_Voltage,2,_IQ(V_C_offset));
343  }
344 
345  // Return the bias value for currents
346  gMotorVars.I_bias.value[0] = HAL_getBias(halHandle,HAL_SensorType_Current,0);
347  gMotorVars.I_bias.value[1] = HAL_getBias(halHandle,HAL_SensorType_Current,1);
348  gMotorVars.I_bias.value[2] = HAL_getBias(halHandle,HAL_SensorType_Current,2);
349 
350  // Return the bias value for voltages
351  gMotorVars.V_bias.value[0] = HAL_getBias(halHandle,HAL_SensorType_Voltage,0);
352  gMotorVars.V_bias.value[1] = HAL_getBias(halHandle,HAL_SensorType_Voltage,1);
353  gMotorVars.V_bias.value[2] = HAL_getBias(halHandle,HAL_SensorType_Voltage,2);
354 
355  // enable the PWM
356  HAL_enablePwm(halHandle);
357  }
358  else if(ctrlState == CTRL_State_Idle)
359  {
360  // disable the PWM
361  HAL_disablePwm(halHandle);
362  gMotorVars.Flag_Run_Identify = false;
363  }
364 
365  if((CTRL_getFlag_enableUserMotorParams(ctrlHandle) == true) &&
366  (ctrlState > CTRL_State_Idle) &&
367  (gMotorVars.CtrlVersion.minor == 6))
368  {
369  // call this function to fix 1p6
370  USER_softwareUpdate1p6(ctrlHandle);
371  }
372 
373  }
374  }
375 
376 
378  {
379  _iq Id_squared_pu = _IQmpy(CTRL_getId_ref_pu(ctrlHandle),CTRL_getId_ref_pu(ctrlHandle));
380 
381 
382  //Set the maximum current controller output for the Iq and Id current controllers to enable
383  //over-modulation.
384  //An input into the SVM above 1/SQRT(3) = 0.5774 is in the over-modulation region. An input of 0.5774 is where
385  //the crest of the sinewave touches the 100% duty cycle. At an input of 2/3, the SVM generator
386  //produces a trapezoidal waveform touching every corner of the hexagon
387  CTRL_setMaxVsMag_pu(ctrlHandle,gMotorVars.OverModulation);
388 
389  // set the current ramp
391  gMotorVars.Flag_MotorIdentified = true;
392 
393  // set the speed reference
394  CTRL_setSpd_ref_krpm(ctrlHandle,gMotorVars.SpeedRef_krpm);
395 
396  // set the speed acceleration
398 
399  // set the Id reference
400  CTRL_setId_ref_pu(ctrlHandle, _IQmpy(gMotorVars.IdRef_A, _IQ(1.0/USER_IQ_FULL_SCALE_CURRENT_A)));
401 
403  {
405 
406  USER_calcPIgains(ctrlHandle);
407 
408  // initialize the watch window kp and ki current values with pre-calculated values
409  gMotorVars.Kp_Idq = CTRL_getKp(ctrlHandle,CTRL_Type_PID_Id);
410  gMotorVars.Ki_Idq = CTRL_getKi(ctrlHandle,CTRL_Type_PID_Id);
411  }
412 
413  }
414  else
415  {
417 
418  // initialize the watch window kp and ki values with pre-calculated values
419  gMotorVars.Kp_spd = CTRL_getKp(ctrlHandle,CTRL_Type_PID_spd);
420  gMotorVars.Ki_spd = CTRL_getKi(ctrlHandle,CTRL_Type_PID_spd);
421 
422 
423  // the estimator sets the maximum current slope during identification
425  }
426 
427 
428  // when appropriate, update the global variables
430  {
431  // reset the counter
433 
434  updateGlobalVariables_motor(ctrlHandle);
435  }
436 
437 
438  // update Kp and Ki gains
439  updateKpKiGains(ctrlHandle);
440 
441  // enable/disable the forced angle
443 
444  // enable or disable power warp
445  CTRL_setFlag_enablePowerWarp(ctrlHandle,gMotorVars.Flag_enablePowerWarp);
446 
447 #ifdef DRV8301_SPI
448  HAL_writeDrvData(halHandle,&gDrvSpi8301Vars);
449 
450  HAL_readDrvData(halHandle,&gDrvSpi8301Vars);
451 #endif
452 #ifdef DRV8305_SPI
453  HAL_writeDrvData(halHandle,&gDrvSpi8305Vars);
454 
455  HAL_readDrvData(halHandle,&gDrvSpi8305Vars);
456 #endif
457  } // end of while(gFlag_enableSys) loop
458 
459 
460  // disable the PWM
461  HAL_disablePwm(halHandle);
462 
463  // set the default controller parameters (Reset the control to re-identify the motor)
464  CTRL_setParams(ctrlHandle,&gUserParams);
465  gMotorVars.Flag_Run_Identify = false;
466 
467  } // end of for(;;) loop
468 
469 } // end of main() function
470 
471 
472 interrupt void mainISR(void)
473 {
474  SVGENCURRENT_IgnoreShunt_e ignoreShuntThisCycle = SVGENCURRENT_getIgnoreShunt(svgencurrentHandle);
475 
476  // toggle status LED
477  if(gLEDcnt++ > (uint_least32_t)(USER_ISR_FREQ_Hz / LED_BLINK_FREQ_Hz))
478  {
479  HAL_toggleLed(halHandle,(GPIO_Number_e)HAL_Gpio_LED2);
480  gLEDcnt = 0;
481  }
482 
483 
484  // acknowledge the ADC interrupt
485  HAL_acqAdcInt(halHandle,ADC_IntNumber_1);
486 
487 
488  // convert the ADC data
489  HAL_readAdcData(halHandle,&gAdcData);
490 
491 
492  // run the current reconstruction algorithm
493  SVGENCURRENT_RunRegenCurrent(svgencurrentHandle, (MATH_vec3 *)(gAdcData.I.value));
494 
495  gIavg.value[0] += (gAdcData.I.value[0] - gIavg.value[0])>>gIavg_shift;
496  gIavg.value[1] += (gAdcData.I.value[1] - gIavg.value[1])>>gIavg_shift;
497  gIavg.value[2] += (gAdcData.I.value[2] - gIavg.value[2])>>gIavg_shift;
498 
499  if(ignoreShuntThisCycle == ignore_ab)
500  {
501  gAdcData.I.value[0] = gIavg.value[0];
502  gAdcData.I.value[1] = gIavg.value[1];
503  }
504  else if(ignoreShuntThisCycle == ignore_ac)
505  {
506  gAdcData.I.value[0] = gIavg.value[0];
507  gAdcData.I.value[2] = gIavg.value[2];
508  }
509  else if(ignoreShuntThisCycle == ignore_bc)
510  {
511  gAdcData.I.value[1] = gIavg.value[1];
512  gAdcData.I.value[2] = gIavg.value[2];
513  }
514 
515 
516  // run the controller
517  CTRL_run(ctrlHandle,halHandle,&gAdcData,&gPwmData);
518 
519 
520  // write the PWM compare values
521  HAL_writePwmData(halHandle,&gPwmData);
522 
523 
524  // run the current ignore algorithm
525  {
526  uint16_t cmp1 = HAL_readPwmCmpA(halHandle,PWM_Number_1);
527  uint16_t cmp2 = HAL_readPwmCmpA(halHandle,PWM_Number_2);
528  uint16_t cmp3 = HAL_readPwmCmpA(halHandle,PWM_Number_3);
529  uint16_t cmpM1 = HAL_readPwmCmpAM(halHandle,PWM_Number_1);
530  uint16_t cmpM2 = HAL_readPwmCmpAM(halHandle,PWM_Number_2);
531  uint16_t cmpM3 = HAL_readPwmCmpAM(halHandle,PWM_Number_3);
532 
533  // run the current ignore algorithm
534  SVGENCURRENT_RunIgnoreShunt(svgencurrentHandle,cmp1,cmp2,cmp3,cmpM1,cmpM2,cmpM3);
535  }
536 
537  {
538  int16_t minwidth = SVGENCURRENT_getMinWidth(svgencurrentHandle);
539  SVGENCURRENT_IgnoreShunt_e ignoreShuntNextCycle = SVGENCURRENT_getIgnoreShunt(svgencurrentHandle);
540 
541  // Set trigger point in the middle of the low side pulse
542  HAL_setTrigger(halHandle,ignoreShuntNextCycle,minwidth,gCmpOffset);
543  }
544 
545  // setup the controller
546  CTRL_setup(ctrlHandle);
547 
548 
549  return;
550 } // end of mainISR() function
551 
552 
554 {
555  CTRL_Obj *obj = (CTRL_Obj *)handle;
556  int32_t tmp;
557 
558  // get the speed estimate
559  gMotorVars.Speed_krpm = EST_getSpeed_krpm(obj->estHandle);
560 
561  // get the real time speed reference coming out of the speed trajectory generator
563 
564  // get the torque estimate
565  gMotorVars.Torque_Nm = USER_computeTorque_Nm(handle, gTorque_Flux_Iq_pu_to_Nm_sf, gTorque_Ls_Id_Iq_pu_to_Nm_sf);
566 
567  // when calling EST_ functions that return a float, and fpu32 is enabled, an integer is needed as a return
568  // so that the compiler reads the returned value from the accumulator instead of fpu32 registers
569  // get the magnetizing current
570  tmp = EST_getIdRated(obj->estHandle);
571  gMotorVars.MagnCurr_A = *((float_t *)&tmp);
572 
573  // get the rotor resistance
574  tmp = EST_getRr_Ohm(obj->estHandle);
575  gMotorVars.Rr_Ohm = *((float_t *)&tmp);
576 
577  // get the stator resistance
578  tmp = EST_getRs_Ohm(obj->estHandle);
579  gMotorVars.Rs_Ohm = *((float_t *)&tmp);
580 
581  // get the stator inductance in the direct coordinate direction
582  tmp = EST_getLs_d_H(obj->estHandle);
583  gMotorVars.Lsd_H = *((float_t *)&tmp);
584 
585  // get the stator inductance in the quadrature coordinate direction
586  tmp = EST_getLs_q_H(obj->estHandle);
587  gMotorVars.Lsq_H = *((float_t *)&tmp);
588 
589  // get the flux in V/Hz in floating point
590  tmp = EST_getFlux_VpHz(obj->estHandle);
591  gMotorVars.Flux_VpHz = *((float_t *)&tmp);
592 
593  // get the flux in Wb in fixed point
594  gMotorVars.Flux_Wb = USER_computeFlux(handle, gFlux_pu_to_Wb_sf);
595 
596  // get the controller state
597  gMotorVars.CtrlState = CTRL_getState(handle);
598 
599  // get the estimator state
600  gMotorVars.EstState = EST_getState(obj->estHandle);
601 
602  // read Vd and Vq vectors per units
603  gMotorVars.Vd = CTRL_getVd_out_pu(ctrlHandle);
604  gMotorVars.Vq = CTRL_getVq_out_pu(ctrlHandle);
605 
606  // calculate vector Vs in per units
607  gMotorVars.Vs = _IQsqrt(_IQmpy(gMotorVars.Vd, gMotorVars.Vd) + _IQmpy(gMotorVars.Vq, gMotorVars.Vq));
608 
609  // read Id and Iq vectors in amps
610  gMotorVars.Id_A = _IQmpy(CTRL_getId_in_pu(ctrlHandle), _IQ(USER_IQ_FULL_SCALE_CURRENT_A));
611  gMotorVars.Iq_A = _IQmpy(CTRL_getIq_in_pu(ctrlHandle), _IQ(USER_IQ_FULL_SCALE_CURRENT_A));
612 
613  // calculate vector Is in amps
614  gMotorVars.Is_A = _IQsqrt(_IQmpy(gMotorVars.Id_A, gMotorVars.Id_A) + _IQmpy(gMotorVars.Iq_A, gMotorVars.Iq_A));
615 
616  // Get the DC buss voltage
617  gMotorVars.VdcBus_kV = _IQmpy(gAdcData.dcBus,_IQ(USER_IQ_FULL_SCALE_VOLTAGE_V/1000.0));
618 
619  return;
620 } // end of updateGlobalVariables_motor() function
621 
622 
624 {
625  if((gMotorVars.CtrlState == CTRL_State_OnLine) && (gMotorVars.Flag_MotorIdentified == true) && (Flag_Latch_softwareUpdate == false))
626  {
627  // set the kp and ki speed values from the watch window
628  CTRL_setKp(handle,CTRL_Type_PID_spd,gMotorVars.Kp_spd);
629  CTRL_setKi(handle,CTRL_Type_PID_spd,gMotorVars.Ki_spd);
630 
631  // set the kp and ki current values for Id and Iq from the watch window
632  CTRL_setKp(handle,CTRL_Type_PID_Id,gMotorVars.Kp_Idq);
633  CTRL_setKi(handle,CTRL_Type_PID_Id,gMotorVars.Ki_Idq);
634  CTRL_setKp(handle,CTRL_Type_PID_Iq,gMotorVars.Kp_Idq);
635  CTRL_setKi(handle,CTRL_Type_PID_Iq,gMotorVars.Ki_Idq);
636  }
637 
638  return;
639 } // end of updateKpKiGains() function
640 
641 
643 // end of file
644 
645 
646 
float_t EST_getFlux_VpHz(EST_Handle handle)
#define USER_SYSTEM_FREQ_MHz
CLOCKS & TIMERS.
Definition: user.h:140
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
_iq gTorque_Flux_Iq_pu_to_Nm_sf
Definition: proj_lab10c.c:127
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 gFlux_pu_to_Wb_sf
Definition: proj_lab10c.c:121
SVGENCURRENT_Obj svgencurrent
Definition: proj_lab10c.c:101
_iq USER_computeFlux_pu_to_VpHz_sf(void)
Computes the scale factor needed to convert from per unit to V/Hz.
#define _IQ(A)
_iq Iq_A
Definition: main.h:195
bool Flag_Run_Identify
Definition: main.h:137
_iq EST_getSpeed_krpm(EST_Handle handle)
static uint16_t HAL_readPwmCmpAM(HAL_Handle handle, const PWM_Number_e pwmNumber)
USER_Params gUserParams
The user parameters.
Definition: proj_lab10c.c:76
#define MATH_TWO_OVER_THREE
void USER_calcPIgains(CTRL_Handle handle)
Updates Id and Iq PI gains.
CTRL_State_e CtrlState
Definition: main.h:147
void updateGlobalVariables_motor(CTRL_Handle handle)
Updates the global motor variables.
Definition: proj_lab10c.c:553
bool Flag_enablePowerWarp
Definition: main.h:144
static void HAL_writePwmData(HAL_Handle handle, HAL_PwmData_t *pPwmData)
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)
void main(void)
Definition: proj_lab10c.c:132
bool CTRL_isError(CTRL_Handle handle)
void USER_softwareUpdate1p6(CTRL_Handle handle)
Recalculates Inductances with the correct Q Format.
CTRL_Obj ctrl
Defines the CTRL object.
Definition: proj_lab10c.c:87
static void HAL_acqAdcInt(HAL_Handle handle, const ADC_IntNumber_e intNumber)
_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
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)
bool Flag_enableForceAngle
Definition: main.h:139
void CTRL_setFlag_enableCtrl(CTRL_Handle handle, const bool state)
void CTRL_setFlag_enableSpeedCtrl(CTRL_Handle handle, const bool state)
#define V_B_offset
Definition: user.h:133
long _iq
_iq OverModulation
Definition: main.h:161
void USER_setParams(USER_Params *pUserParams)
Sets the user parameter values.
_iq gFlux_pu_to_VpHz_sf
Definition: proj_lab10c.c:123
EST_State_e EstState
Definition: main.h:148
SVGENCURRENT_Handle svgencurrentHandle
Definition: proj_lab10c.c:102
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
_iq gMaxCurrentSlope
Definition: proj_lab10c.c:82
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.
HAL_PwmData_t gPwmData
Defines the PWM data.
Definition: proj_lab10c.c:78
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)
uint_least16_t gCounter_updateGlobals
A counter that is denotes when to update the global variables.
Definition: proj_lab10c.c:68
#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)
_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 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)
CTRL_State_e CTRL_getState(CTRL_Handle handle)
uint16_t gIavg_shift
Definition: proj_lab10c.c:108
#define I_C_offset
Definition: user.h:127
SVGENCURRENT_IgnoreShunt_e
float_t Flux_VpHz
Definition: main.h:173
bool Flag_enableUserParams
Definition: main.h:142
CTRL_Handle ctrlHandle
The controller handle.
Definition: proj_lab10c.c:72
EST_State_e EST_getState(EST_Handle handle)
bool Flag_enableOffsetcalc
Definition: main.h:143
void updateKpKiGains(CTRL_Handle handle)
Updates Kp and Ki gains in the controller object.
Definition: proj_lab10c.c:623
#define I_B_offset
Definition: user.h:126
#define LED_BLINK_FREQ_Hz
Definition: proj_lab10c.c:62
_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
uint16_t gLEDcnt
Definition: proj_lab10c.c:90
_iq CTRL_getVd_out_pu(CTRL_Handle handle)
CTRL_State_e
#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
HAL_Handle halHandle
The hal handle.
Definition: proj_lab10c.c:74
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)
interrupt void mainISR(void)
The main interrupt service (ISR) routine.
Definition: proj_lab10c.c:472
void CTRL_setMaxVsMag_pu(CTRL_Handle handle, const _iq maxVsMag)
float_t Lsd_H
Definition: main.h:171
_iq CTRL_getId_ref_pu(CTRL_Handle handle)
void CTRL_setFlag_enablePowerWarp(CTRL_Handle handle, const bool state)
#define USER_ISR_FREQ_Hz
Defines the Interrupt Service Routine (ISR) frequency, Hz.
Definition: user.h:173
int16_t gCmpOffset
Definition: proj_lab10c.c:105
bool CTRL_updateState(CTRL_Handle handle)
_iq CTRL_getKi(CTRL_Handle handle, const CTRL_Type_e ctrlType)
static void HAL_disablePwm(HAL_Handle handle)
bool EST_isMotorIdentified(EST_Handle handle)
MATH_vec3 gIavg
Definition: proj_lab10c.c:107
_iq USER_computeTorque_Nm(CTRL_Handle handle, const _iq torque_Flux_sf, const _iq torque_Ls_sf)
Computes Torque in Nm.
void CTRL_setFlag_enableOffset(CTRL_Handle handle, const bool state)
HAL_Handle HAL_init(void *pMemory, const size_t numBytes)
void CTRL_setFlag_enableDcBusComp(CTRL_Handle handle, const bool state)
#define _IQsqrt(A)
static uint16_t HAL_readPwmCmpA(HAL_Handle handle, const PWM_Number_e pwmNumber)
_iq EST_getMaxCurrentSlope_pu(EST_Handle handle)
void CTRL_setFlag_enableUserMotorParams(CTRL_Handle handle, const bool state)
_iq SpeedTraj_krpm
Definition: main.h:158
volatile MOTOR_Vars_t gMotorVars
Definition: proj_lab10c.c:92
#define USER_IQ_FULL_SCALE_CURRENT_A
Defines the full scale current for the IQ variables, A.
Definition: user.h:102
float_t MagnCurr_A
Definition: main.h:167
static void HAL_readAdcData(HAL_Handle handle, HAL_AdcData_t *pAdcData)
HAL_Obj hal
static void HAL_setTrigger(HAL_Handle handle, const SVGENCURRENT_IgnoreShunt_e ignoreShunt, const int16_t minwidth, const int16_t cmpOffset)
static _iq HAL_getBias(HAL_Handle handle, const HAL_SensorType_e sensorType, uint_least8_t sensorNumber)
bool Flag_enableSys
Definition: main.h:136
HAL_AdcData_t gAdcData
Defines the ADC data.
Definition: proj_lab10c.c:80
_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)
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)
SVGENCURRENT_Handle SVGENCURRENT_init(void *pMemory, const size_t numBytes)
static void HAL_updateAdcBias(HAL_Handle handle)
void CTRL_getVersion(CTRL_Handle handle, CTRL_Version *pVersion)
uint16_t minor
_iq gTorque_Ls_Id_Iq_pu_to_Nm_sf
Definition: proj_lab10c.c:125
CTRL_Version CtrlVersion
Definition: main.h:152
float_t EST_getRr_Ohm(EST_Handle handle)
void HAL_setParams(HAL_Handle handle, const USER_Params *pUserParams)
void HAL_readDrvData(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars)
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
bool Flag_Latch_softwareUpdate
Definition: proj_lab10c.c:70
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)
float float_t