instaspin_foc
fast_obs_pm.c
Go to the documentation of this file.
1 
7 
8 // **************************************************************************
9 
10 // solutions
11 #include "fast_obs.h"
12 
13 
14 // **************************************************************************
15 // the defines
16 
17 
18 // **************************************************************************
19 // the globals
20 
21 EST_State_e gEstState = EST_State_Idle;
22 
23 volatile bool gFlag_enableSys = true;
24 
25 volatile bool gFlag_runOnLine = false;
26 
27 volatile bool gFlag_enableForceAngle = true;
28 
30 
32 
34 
36 
38 
40 
41 volatile float_t gSpeed_Kp = 0.01;
42 
43 volatile float_t gSpeed_Ki = 0.001;
44 
45 volatile float_t gId_ref_A = 0.0;
46 
48 
49 uint16_t gCounter_speed = 0;
50 
52 
54 
56 
58 
60 
62 
64 
65 MATH_vec3 gOffsets_I_A = {0.0, 0.0, 0.0};
66 
67 MATH_vec3 gOffsets_V_V = {0.0, 0.0, 0.0};
68 
71 
74 
77 
79 
82 
85 
88 
91 
94 
97 
98 #ifdef DRV8301_SPI
99 // Watch window interface to the 8301 SPI
100 DRV_SPI_8301_Vars_t gDrvSpi8301Vars;
101 #endif
102 
108 
109 // **************************************************************************
110 // the functions
111 
112 void main(void)
113 {
114  uint_least8_t estNumber = 0;
115 
116  // initialize the user parameters
117  USER_setParams(&gUserParams);
118 
119  // initialize the user parameters
120  USER_setParams_priv(&gUserParams);
121 
122  // initialize the driver
123  halHandle = HAL_init(&hal,sizeof(hal));
124 
125  // set the driver parameters
126  HAL_setParams(halHandle,&gUserParams);
127 
128  // initialize the Clarke modules
129  clarkeHandle_I = CLARKE_init(&clarke_I,sizeof(clarke_I));
130  clarkeHandle_V = CLARKE_init(&clarke_V,sizeof(clarke_V));
131 
132  // set the Clarke parameters
133  setupClarke_I(clarkeHandle_I,gUserParams.numCurrentSensors);
134  setupClarke_V(clarkeHandle_V,gUserParams.numVoltageSensors);
135 
136  // initialize the estimator
137  estHandle = EST_initEst(estNumber);
138 
139  // set the default estimator parameters
140  EST_setParams(estHandle,&gUserParams);
143 
144  // initialize the inverse Park module
145  iparkHandle = IPARK_init(&ipark,sizeof(ipark));
146 
147  // initialize the Park module
148  parkHandle = PARK_init(&park,sizeof(park));
149 
150  // initialize the PI controllers
151  piHandle_Id = PI_init(&pi_Id, sizeof(pi_Id));
152  piHandle_Iq = PI_init(&pi_Iq, sizeof(pi_Iq));
153  piHandle_spd = PI_init(&pi_spd,sizeof(pi_spd));
154 
155  // setup the controllers
157 
158  // initialize the space vector generator module
159  svgenHandle = SVGEN_init(&svgen,sizeof(svgen));
160 
161  // initialize the CPU usage module
162  cpu_usageHandle = CPU_USAGE_init(&cpu_usage,sizeof(cpu_usage));
163  CPU_USAGE_setParams(cpu_usageHandle,
164  (uint32_t)USER_SYSTEM_FREQ_MHz * 1000000, // timer period, cnts
165  (uint32_t)USER_ISR_FREQ_Hz); // average over 1 second of ISRs
166 
167  // setup faults
168  HAL_setupFaults(halHandle);
169 
170  // initialize the interrupt vector table
171  HAL_initIntVectorTable(halHandle);
172 
173  // enable the ADC interrupts
174  HAL_enableAdcInts(halHandle);
175 
176  // disable global interrupts
177  HAL_disableGlobalInts(halHandle);
178 
179  // enable debug interrupts
180  HAL_enableDebugInt(halHandle);
181 
182  // disable the PWM
183  HAL_disablePwm(halHandle);
184 
185  // set adcBias values
186  gOffsets_I_A.value[0] = IA_OFFSET_A;
187  gOffsets_I_A.value[1] = IB_OFFSET_A;
188  gOffsets_I_A.value[2] = IC_OFFSET_A;
189  gOffsets_V_V.value[0] = VA_OFFSET_V;
190  gOffsets_V_V.value[1] = VB_OFFSET_V;
191  gOffsets_V_V.value[2] = VC_OFFSET_V;
192 
193 #ifdef DRV8301_SPI
194  // turn on the DRV8301 if present
195  HAL_enableDrv(halHandle);
196  // initialize the DRV8301 interface
197  HAL_setupDrvSpi(halHandle,&gDrvSpi8301Vars);
198 #endif
199 
200  // Waiting for enable system flag to be set
201  while(!gFlag_enableSys);
202 
203  // loop while the enable system flag is true
204  while(gFlag_enableSys)
205  {
206  // set custom speed controller gains
207  PI_setGains(piHandle_spd,gSpeed_Kp,gSpeed_Ki);
208 
209  // enable or disable force angle
211 
212  if(gFlag_runOnLine)
213  {
214  // enable the estimator
216 
217  // enable the PWM
218  HAL_enablePwm(halHandle);
219 
220  // enable global interrupts
221  HAL_enableGlobalInts(halHandle);
222  }
223  else
224  {
225  // disable the estimator
227 
228  // disable the PWM
229  HAL_disablePwm(halHandle);
230 
231  // disable global interrupts
232  HAL_disableGlobalInts(halHandle);
233 
234  // clear integral outputs of the controllers
235  PI_setUi(piHandle_Id,0.0);
236  PI_setUi(piHandle_Iq,0.0);
237  PI_setUi(piHandle_spd,0.0);
238 
239  // clear current references
240  gId_ref_A = 0.0;
241  gIq_ref_A = 0.0;
242 
243  // clear PWM data
244  gPwmData.Vabc_pu.value[0] = 0.0;
245  gPwmData.Vabc_pu.value[1] = 0.0;
246  gPwmData.Vabc_pu.value[2] = 0.0;
247  }
248 
249  // update the estimator state
251 
252  // update the global variables
254 
255  // update CPU usage
256  updateCPUusage();
257 
258 #ifdef DRV8301_SPI
259  HAL_writeDrvData(halHandle,&gDrvSpi8301Vars);
260 
261  HAL_readDrvData(halHandle,&gDrvSpi8301Vars);
262 #endif
263 
264  } // end of while() loop
265 
266  // disable the PWM
267  HAL_disablePwm(halHandle);
268 
269 } // end of main() function
270 
271 
272 interrupt void mainISR(void)
273 {
274  uint32_t timer1Cnt;
275  float_t angleDelta_rad;
276  float_t angleWithDelay_rad;
277  MATH_vec2 Idq_A;
278  float_t outMax_V;
279  MATH_vec2 phasor;
280  MATH_vec2 Vab_out_V;
281  MATH_vec2 Vdq_out_V;
282  HAL_AdcData_t AdcDataWithOffset;
283 
284  // read the timer 1 value and update the CPU usage module
285  timer1Cnt = HAL_readTimerCnt(halHandle,1);
286  CPU_USAGE_updateCnts(cpu_usageHandle,timer1Cnt);
287 
288  // acknowledge the ADC interrupt
289  HAL_acqAdcInt(halHandle,ADC_IntNumber_6);
290 
291  // read the ADC data with offsets
292  HAL_readAdcDataWithOffsets(halHandle,&AdcDataWithOffset);
293 
294  // remove offsets
295  gAdcData.I_A.value[0] = AdcDataWithOffset.I_A.value[0] - gOffsets_I_A.value[0];
296  gAdcData.I_A.value[1] = AdcDataWithOffset.I_A.value[1] - gOffsets_I_A.value[1];
297  gAdcData.I_A.value[2] = AdcDataWithOffset.I_A.value[2] - gOffsets_I_A.value[2];
298  gAdcData.V_V.value[0] = AdcDataWithOffset.V_V.value[0] - gOffsets_V_V.value[0];
299  gAdcData.V_V.value[1] = AdcDataWithOffset.V_V.value[1] - gOffsets_V_V.value[1];
300  gAdcData.V_V.value[2] = AdcDataWithOffset.V_V.value[2] - gOffsets_V_V.value[2];
301  gAdcData.dcBus_V = AdcDataWithOffset.dcBus_V;
302 
303  // run Clarke transform on current
304  CLARKE_run(clarkeHandle_I,&(gAdcData.I_A),&(gEstInputData.Iab_A));
305 
306  // run Clarke transform on voltage
307  CLARKE_run(clarkeHandle_V,&(gAdcData.V_V),&(gEstInputData.Vab_V));
308 
309  // store the input data into a buffer
310  gEstInputData.dcBus_V = gAdcData.dcBus_V;
311  gEstInputData.speed_ref_Hz = gSpeed_ref_Hz;
312 
313  // run the estimator
314  EST_run(estHandle,&gEstInputData,&gEstOutputData);
315 
316  // run the speed controller
317  if(++gCounter_speed >= gUserParams.numCtrlTicksPerSpeedTick)
318  {
319  gCounter_speed = 0;
320 
321  PI_run_series(piHandle_spd,gEstInputData.speed_ref_Hz,gEstOutputData.fm_lp_rps * MATH_ONE_OVER_TWO_PI,0.0,&gIq_ref_A);
322  }
323 
324  // get Idq, reutilizing a Park transform used inside the estimator. This is optional, user's Park works as well
325  EST_getIdq_A(estHandle,&Idq_A);
326 
327  // run the Id controller
328  PI_run_series(piHandle_Id,gId_ref_A,Idq_A.value[0],0.0,&(Vdq_out_V.value[0]));
329 
330  // calculate Iq controller limits, and run Iq controller using fast RTS function, callable assembly
331  outMax_V = sqrt_fastRTS((gUserParams.maxVsMag_V * gUserParams.maxVsMag_V) - (Vdq_out_V.value[0] * Vdq_out_V.value[0]));
332  PI_setMinMax(piHandle_Iq,-outMax_V,outMax_V);
333  PI_run_series(piHandle_Iq,gIq_ref_A,Idq_A.value[1],0.0,&(Vdq_out_V.value[1]));
334 
335  // compute angle with delay compensation
336  angleDelta_rad = gUserParams.angleDelayed_sf_sec * gEstOutputData.fm_lp_rps;
337  angleWithDelay_rad = MATH_incrAngle(gEstOutputData.angle_rad, angleDelta_rad);
338 
339  // compute the sin/cos phasor using fast RTS function, callable assembly
340  sincos_fastRTS(angleWithDelay_rad, &(phasor.value[1]), &(phasor.value[0]));
341 
342  // set the phasor in the inverse Park transform
343  IPARK_setPhasor(iparkHandle,&phasor);
344 
345  // run the inverse Park module
346  IPARK_run(iparkHandle,&Vdq_out_V,&Vab_out_V);
347 
348  // setup the space vector generator (SVGEN) module
349  SVGEN_setup(svgenHandle,gEstOutputData.oneOverDcBus_invV);
350 
351  // run the space vector generator (SVGEN) module
352  SVGEN_run(svgenHandle,&Vab_out_V,&(gPwmData.Vabc_pu));
353 
354  // write the PWM compare values
355  HAL_writePwmData(halHandle,&gPwmData);
356 
357  // read the timer 1 value and update the CPU usage module
358  timer1Cnt = HAL_readTimerCnt(halHandle,1);
359  CPU_USAGE_updateCnts(cpu_usageHandle,timer1Cnt);
360 
361  // run the CPU usage module
362  CPU_USAGE_run(cpu_usageHandle);
363 
364  return;
365 } // end of mainISR() function
366 
367 
368 void setupClarke_I(CLARKE_Handle handle,const uint_least8_t numCurrentSensors)
369 {
370  float_t alpha_sf,beta_sf;
371 
372  // initialize the Clarke transform module for current
373  if(numCurrentSensors == 3)
374  {
375  alpha_sf = MATH_ONE_OVER_THREE;
376  beta_sf = MATH_ONE_OVER_SQRT_THREE;
377  }
378  else if(numCurrentSensors == 2)
379  {
380  alpha_sf = 1.0;
381  beta_sf = MATH_ONE_OVER_SQRT_THREE;
382  }
383  else
384  {
385  alpha_sf = 0.0;
386  beta_sf = 0.0;
387  }
388 
389  // set the parameters
390  CLARKE_setScaleFactors(handle,alpha_sf,beta_sf);
391  CLARKE_setNumSensors(handle,numCurrentSensors);
392 
393  return;
394 } // end of setupClarke_I() function
395 
396 
397 void setupClarke_V(CLARKE_Handle handle,const uint_least8_t numVoltageSensors)
398 {
399  float_t alpha_sf,beta_sf;
400 
401  // initialize the Clarke transform module for voltage
402  if(numVoltageSensors == 3)
403  {
404  alpha_sf = MATH_ONE_OVER_THREE;
405  beta_sf = MATH_ONE_OVER_SQRT_THREE;
406  }
407  else
408  {
409  alpha_sf = 0.0;
410  beta_sf = 0.0;
411  }
412 
413  // set the parameters
414  CLARKE_setScaleFactors(handle,alpha_sf,beta_sf);
415  CLARKE_setNumSensors(handle,numVoltageSensors);
416 
417  return;
418 } // end of setupClarke_V() function
419 
420 
422 {
423  float_t Ls_d_H = gUserParams.motor_Ls_d_H;
424  float_t Ls_q_H = gUserParams.motor_Ls_q_H;
425  float_t Rs_d_Ohm = gUserParams.motor_Rs_d_Ohm;
426  float_t Rs_q_Ohm = gUserParams.motor_Rs_q_Ohm;
427  float_t RdoverLd_rps = Rs_d_Ohm / Ls_d_H;
428  float_t RqoverLq_rps = Rs_q_Ohm / Ls_q_H;
429  float_t BWc_rps = gUserParams.BWc_rps;
430  float_t currentCtrlPeriod_sec = (float_t)gUserParams.numCtrlTicksPerCurrentTick / gUserParams.ctrlFreq_Hz;
431  float_t outMax_V = gUserParams.Vd_sf * gUserParams.maxVsMag_V;
432 
433  float_t Kp_Id = Ls_d_H * BWc_rps;
434  float_t Ki_Id = RdoverLd_rps * currentCtrlPeriod_sec;
435 
436  float_t Kp_Iq = Ls_q_H * BWc_rps;
437  float_t Ki_Iq = RqoverLq_rps * currentCtrlPeriod_sec;
438 
439  // set the Id controller
440  PI_setGains(piHandle_Id,Kp_Id,Ki_Id);
441  PI_setUi(piHandle_Id,0.0);
442  PI_setRefValue(piHandle_Id,0.0);
443  PI_setFbackValue(piHandle_Id,0.0);
444  PI_setFfwdValue(piHandle_Id,0.0);
445  PI_setMinMax(piHandle_Id,-outMax_V,outMax_V);
446 
447  // set the Iq controller
448  PI_setGains(piHandle_Iq,Kp_Iq,Ki_Iq);
449  PI_setUi(piHandle_Iq,0.0);
450  PI_setRefValue(piHandle_Iq,0.0);
451  PI_setFbackValue(piHandle_Iq,0.0);
452  PI_setFfwdValue(piHandle_Iq,0.0);
453  PI_setMinMax(piHandle_Iq,0.0,0.0);
454 
455  // set the speed controller
456  PI_setGains(piHandle_spd,gSpeed_Kp,gSpeed_Ki);
457  PI_setUi(piHandle_spd,0.0);
458  PI_setRefValue(piHandle_spd,0.0);
459  PI_setFbackValue(piHandle_spd,0.0);
460  PI_setFfwdValue(piHandle_spd,0.0);
461  PI_setMinMax(piHandle_spd,-gUserParams.maxCurrent_A,gUserParams.maxCurrent_A);
462 
463  return;
464 } // end of setupCurrentControllers() function
465 
466 
468 {
469  // get the states
470  gEstState = EST_getState(estHandle);
471 
472  // get the speed estimate
473  gSpeed_Hz = EST_getFe_Hz(estHandle);
474 
475  // get the torque estimate
476  gTorque_Nm = EST_computeTorque_Nm(estHandle);
477 
478  // get the stator resistance
479  gRs_Ohm = EST_getRs_Ohm(estHandle);
480 
481  // get the stator inductance in the direct coordinate direction
482  gLs_d_H = EST_getLs_d_H(estHandle);
483 
484  // get the stator inductance in the quadrature coordinate direction
485  gLs_q_H = EST_getLs_q_H(estHandle);
486 
487  // get the flux, Wb
488  gFlux_Wb = EST_getFlux_Wb(estHandle);
489 
490  return;
491 } // end of updateGlobalVariables_motor() function
492 
493 
494 void updateCPUusage(void)
495 {
496  uint32_t minDeltaCntObserved = CPU_USAGE_getMinDeltaCntObserved(cpu_usageHandle);
497  uint32_t avgDeltaCntObserved = CPU_USAGE_getAvgDeltaCntObserved(cpu_usageHandle);
498  uint32_t maxDeltaCntObserved = CPU_USAGE_getMaxDeltaCntObserved(cpu_usageHandle);
499  uint16_t pwmPeriod = HAL_readPwmPeriod(halHandle,PWM_Number_1);
500  float_t cpu_usage_den = (float_t)pwmPeriod * (float_t)USER_NUM_PWM_TICKS_PER_ISR_TICK * 2.0;
501 
502  // calculate the minimum cpu usage percentage
503  gCpuUsagePercentageMin = (float_t)minDeltaCntObserved / cpu_usage_den * 100.0;
504 
505  // calculate the average cpu usage percentage
506  gCpuUsagePercentageAvg = (float_t)avgDeltaCntObserved / cpu_usage_den * 100.0;
507 
508  // calculate the maximum cpu usage percentage
509  gCpuUsagePercentageMax = (float_t)maxDeltaCntObserved / cpu_usage_den * 100.0;
510 
511  return;
512 } // end of updateCPUusage() function
513 
514 
515 // end of file
516 
CPU_USAGE_Handle cpu_usageHandle
Definition: fast_obs_pm.c:103
#define USER_SYSTEM_FREQ_MHz
CLOCKS & TIMERS.
Definition: user.h:140
volatile float_t gSpeed_Kp
Definition: fast_obs_pm.c:41
EST_State_e gEstState
Global variable for the estimator state.
Definition: fast_obs_pm.c:21
float_t angleDelayed_sf_sec
void EST_setFlag_enableForceAngle(EST_Handle handle, const bool state)
IPARK_Handle IPARK_init(void *pMemory, const size_t numBytes)
#define MATH_ONE_OVER_TWO_PI
EST_InputData_t gEstInputData
Definition: fast_obs_pm.c:57
IPARK_Handle iparkHandle
the handle for the inverse Park transform
Definition: fast_obs_pm.c:80
void HAL_enableGlobalInts(HAL_Handle handle)
void HAL_enableAdcInts(HAL_Handle handle)
float_t EST_getFlux_Wb(EST_Handle handle)
void updateGlobalVariables_motor(EST_Handle estHandle)
Updates the global motor variables.
Definition: fast_obs_pm.c:467
static void PI_setFfwdValue(PI_Handle handle, const _iq ffwdValue)
SVGEN_Obj svgen
the space vector generator object
Definition: fast_obs_pm.c:96
void HAL_disableGlobalInts(HAL_Handle handle)
MATH_vec3 Vabc_pu
static void HAL_readAdcDataWithOffsets(HAL_Handle handle, HAL_AdcData_t *pAdcData)
float_t gIq_ref_A
Definition: fast_obs_pm.c:47
float_t gCpuUsagePercentageAvg
Definition: fast_obs_pm.c:106
float_t gLs_d_H
Global variable for the stator inductance in the direct coordinate direction, Henry.
Definition: fast_obs_pm.c:31
CLARKE_Obj clarke_V
the voltage Clarke transform object
Definition: fast_obs_pm.c:73
float_t motor_Rs_d_Ohm
PI_Obj pi_Iq
the Iq PI controller object
Definition: fast_obs_pm.c:90
PI_Handle piHandle_Iq
the handle for the Iq PI controller
Definition: fast_obs_pm.c:89
static void HAL_writePwmData(HAL_Handle handle, HAL_PwmData_t *pPwmData)
float_t BWc_rps
_iq value[3]
struct _EST_Obj_ * EST_Handle
float_t maxCurrent_A
void HAL_writeDrvData(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars)
void main(void)
Definition: fast_obs_pm.c:112
static void PI_setUi(PI_Handle handle, const _iq Ui)
PARK_Handle parkHandle
the handle for the Park object
Definition: fast_obs_pm.c:83
static void HAL_acqAdcInt(HAL_Handle handle, const ADC_IntNumber_e intNumber)
float_t motor_Rs_q_Ohm
uint_least8_t numCurrentSensors
volatile bool gFlag_runOnLine
Definition: fast_obs_pm.c:25
float_t gCpuUsagePercentageMin
Definition: fast_obs_pm.c:105
CPU_USAGE_Obj cpu_usage
Definition: fast_obs_pm.c:104
void EST_setParams(EST_Handle handle, USER_Params *pUserParams)
static void SVGEN_run(SVGEN_Handle handle, const MATH_vec2 *pVab, MATH_vec3 *pT)
static uint32_t CPU_USAGE_getAvgDeltaCntObserved(CPU_USAGE_Handle handle)
MATH_vec3 gOffsets_V_V
Definition: fast_obs_pm.c:67
PI_Obj pi_spd
the speed PI controller object
Definition: fast_obs_pm.c:93
uint_least16_t numCtrlTicksPerCurrentTick
#define MATH_ONE_OVER_THREE
void USER_setParams(USER_Params *pUserParams)
Sets the user parameter values.
void setupClarke_V(CLARKE_Handle handle, const uint_least8_t numVoltageSensors)
Sets the number of voltage sensors.
Definition: fast_obs_pm.c:397
float_t EST_computeTorque_Nm(EST_Handle handle)
float_t speed_ref_Hz
static void CLARKE_setScaleFactors(CLARKE_Handle handle, const _iq alpha_sf, const _iq beta_sf)
void EST_enable(EST_Handle handle)
float_t maxVsMag_V
void HAL_setupFaults(HAL_Handle handle)
float_t EST_getLs_d_H(EST_Handle handle)
void EST_setFlag_enableRsRecalc(EST_Handle handle, const bool state)
USER_Params gUserParams
The user parameters.
Definition: fast_obs_pm.c:63
PI_Handle piHandle_Id
the handle for the Id PI controller
Definition: fast_obs_pm.c:86
void EST_getIdq_A(EST_Handle handle, MATH_vec2 *pIdq_A)
static void HAL_enablePwm(HAL_Handle handle)
PI_Handle piHandle_spd
the handle for the speed PI controller
Definition: fast_obs_pm.c:92
EST_State_e
void HAL_enableDrv(HAL_Handle handle)
_iq value[2]
EST_Handle EST_initEst(const uint_least8_t estNumber)
PI_Handle PI_init(void *pMemory, const size_t numBytes)
void HAL_setupDrvSpi(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars)
uint_least8_t numVoltageSensors
float_t EST_getLs_q_H(EST_Handle handle)
void HAL_enableDebugInt(HAL_Handle handle)
CLARKE_Handle CLARKE_init(void *pMemory, const size_t numBytes)
float_t oneOverDcBus_invV
void sincos_fastRTS(float_t angle_rad, float_t *pSin, float_t *pCos)
Calculates sine and cosine in a single function call, using callable assembly, fast RTS...
static void IPARK_run(IPARK_Handle handle, const MATH_vec2 *pInVec, MATH_vec2 *pOutVec)
EST_State_e EST_getState(EST_Handle handle)
void setupClarke_I(CLARKE_Handle handle, const uint_least8_t numCurrentSensors)
Sets the number of current sensors.
Definition: fast_obs_pm.c:368
volatile bool gFlag_enableForceAngle
Definition: fast_obs_pm.c:27
PI_Obj pi_Id
the Id PI controller object
Definition: fast_obs_pm.c:87
HAL_DacData_t gDacData
Defines the DAC data.
Definition: fast_obs_pm.c:53
MATH_vec3 gOffsets_I_A
Definition: fast_obs_pm.c:65
float_t gLs_q_H
Global variable for the stator inductance in the quadrature coordinate direction, Henry...
Definition: fast_obs_pm.c:33
volatile float_t gId_ref_A
Definition: fast_obs_pm.c:45
EST_OutputData_t gEstOutputData
Definition: fast_obs_pm.c:59
interrupt void mainISR(void)
The main interrupt service (ISR) routine.
Definition: fast_obs_pm.c:272
float_t gSpeed_ref_Hz
Definition: fast_obs_pm.c:39
static uint32_t HAL_readTimerCnt(HAL_Handle handle, const uint_least8_t timerNumber)
static void CLARKE_setNumSensors(CLARKE_Handle handle, const uint_least8_t numSensors)
float_t EST_getRs_Ohm(EST_Handle handle)
uint_least16_t numCtrlTicksPerSpeedTick
CLARKE_Handle clarkeHandle_V
the handle for the voltage Clarke transform
Definition: fast_obs_pm.c:72
void CPU_USAGE_setParams(CPU_USAGE_Handle handle, const uint32_t timerPeriod_cnts, const uint32_t numDeltaCntsAvg)
IPARK_Obj ipark
the inverse Park transform object
Definition: fast_obs_pm.c:81
#define USER_ISR_FREQ_Hz
Defines the Interrupt Service Routine (ISR) frequency, Hz.
Definition: user.h:173
static void IPARK_setPhasor(IPARK_Handle handle, const MATH_vec2 *pPhasor)
CPU_USAGE_Handle CPU_USAGE_init(void *pMemory, const size_t numBytes)
static void HAL_disablePwm(HAL_Handle handle)
HAL_Handle HAL_init(void *pMemory, const size_t numBytes)
HAL_Obj hal
the hardware abstraction layer object
Definition: fast_obs_pm.c:76
float_t gCpuUsagePercentageMax
Definition: fast_obs_pm.c:107
static void CLARKE_run(CLARKE_Handle handle, const MATH_vec3 *pInVec, MATH_vec2 *pOutVec)
static uint32_t CPU_USAGE_getMaxDeltaCntObserved(CPU_USAGE_Handle handle)
HAL_Handle halHandle
the handle for the hardware abstraction layer
Definition: fast_obs_pm.c:75
volatile float_t gSpeed_Ki
Definition: fast_obs_pm.c:43
float_t gSpeed_Hz
Definition: fast_obs_pm.c:37
void updateCPUusage(void)
Updates CPU usage.
Definition: fast_obs_pm.c:494
float_t gFlux_Wb
Global variable for the rotor flux estimate, Wb.
Definition: fast_obs_pm.c:29
MATH_vec2 Iab_A
uint_least32_t ctrlFreq_Hz
CLARKE_Handle clarkeHandle_I
the handle for the current Clarke transform
Definition: fast_obs_pm.c:69
void SVGEN_setup(SVGEN_Handle svgenHandle)
static void PI_setMinMax(PI_Handle handle, const _iq outMin, const _iq outMax)
static void PI_setRefValue(PI_Handle handle, const _iq refValue)
static void CPU_USAGE_updateCnts(CPU_USAGE_Handle handle, const uint32_t cnt)
void setupControllers(void)
Setups the controllers.
Definition: fast_obs_pm.c:421
float_t sqrt_fastRTS(float_t x)
Calculates square root using callable assembly, fast RTS.
volatile bool gFlag_enableSys
Global flag to enable/disable the system.
Definition: fast_obs_pm.c:23
MATH_vec2 Vab_V
static uint32_t CPU_USAGE_getMinDeltaCntObserved(CPU_USAGE_Handle handle)
#define MATH_ONE_OVER_SQRT_THREE
EST_Handle estHandle
the handle for the estimator
Definition: fast_obs_pm.c:78
PARK_Obj park
the Park transform object
Definition: fast_obs_pm.c:84
static void HAL_initIntVectorTable(HAL_Handle handle)
static float_t MATH_incrAngle(const float_t angle_rad, const float_t angleDelta_rad)
float_t gRs_Ohm
Definition: fast_obs_pm.c:35
PARK_Handle PARK_init(void *pMemory, const size_t numBytes)
static void PI_setFbackValue(PI_Handle handle, const _iq fbackValue)
static uint16_t HAL_readPwmPeriod(HAL_Handle handle, const PWM_Number_e pwmNumber)
HAL_PwmData_t gPwmData
Defines the PWM data.
Definition: fast_obs_pm.c:55
bool EST_updateState(EST_Handle handle, const _iq Id_target_pu)
void EST_disable(EST_Handle handle)
void HAL_setParams(HAL_Handle handle, const USER_Params *pUserParams)
static void CPU_USAGE_run(CPU_USAGE_Handle handle)
CLARKE_Obj clarke_I
the current Clarke transform object
Definition: fast_obs_pm.c:70
HAL_AdcData_t gAdcData
Defines the ADC data.
Definition: fast_obs_pm.c:51
float_t EST_getFe_Hz(EST_Handle handle)
void HAL_readDrvData(HAL_Handle handle, DRV_SPI_8301_Vars_t *Spi_8301_Vars)
float_t gTorque_Nm
Global variable for the estimated torque, N*m.
Definition: fast_obs_pm.c:61
float_t motor_Ls_d_H
float_t motor_Ls_q_H
SVGEN_Handle svgenHandle
the handle for the space vector generator
Definition: fast_obs_pm.c:95
SVGEN_Handle SVGEN_init(void *pMemory, const size_t numBytes)
static void PI_setGains(PI_Handle handle, const _iq Kp, const _iq Ki)
static void PI_run_series(PI_Handle handle, const _iq refValue, const _iq fbackValue, const _iq ffwdValue, _iq *pOutValue)
float float_t
uint16_t gCounter_speed
Definition: fast_obs_pm.c:49
void EST_run(EST_Handle handle, const MATH_vec2 *pIab_pu, const MATH_vec2 *pVab_pu, const _iq dcBus_pu, const _iq speed_ref_pu)
#define USER_NUM_PWM_TICKS_PER_ISR_TICK
DECIMATION.
Definition: user.h:184