l6208_class.cpp

00001 /**
00002   ******************************************************************************
00003   * @file    l6208_class.cpp
00004   * @author  IPC Rennes
00005   * @version V1.1.0
00006   * @date    February 11th, 2016
00007   * @brief   L6208 product related routines
00008   * @note    (C) COPYRIGHT 2016 STMicroelectronics
00009   ******************************************************************************
00010   * @attention
00011   *
00012   * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
00013   *
00014   * Redistribution and use in source and binary forms, with or without modification,
00015   * are permitted provided that the following conditions are met:
00016   *   1. Redistributions of source code must retain the above copyright notice,
00017   *      this list of conditions and the following disclaimer.
00018   *   2. Redistributions in binary form must reproduce the above copyright notice,
00019   *      this list of conditions and the following disclaimer in the documentation
00020   *      and/or other materials provided with the distribution.
00021   *   3. Neither the name of STMicroelectronics nor the names of its contributors
00022   *      may be used to endorse or promote products derived from this software
00023   *      without specific prior written permission.
00024   *
00025   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00026   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00027   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00028   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
00029   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00030   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00031   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00032   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00033   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00034   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00035   *
00036   ******************************************************************************
00037   */
00038 
00039 /* Includes ------------------------------------------------------------------*/
00040 #include "l6208_class.h"
00041 
00042 /* Definitions ---------------------------------------------------------------*/
00043 /// Bridge A
00044 #define BRIDGE_A                     (0)
00045 /// Bridge B
00046 #define BRIDGE_B                     (1)
00047 
00048 /// Bitmaps for system flags
00049 #define EN_A_set              0x00000001    ///< EN_A pin status
00050 #define HiZstop               0x00000002    ///< motor has to be left in HiZ after stopping
00051 #define busy                  0x00000004    ///< stepper position command executing flag
00052 #define running               0x00000008    ///< running motor flag
00053 #define velocitymode          0x00000010    ///< velocity controlled stepper motor
00054 #define positionmode          0x00000020    ///< position controlled stepper motor
00055 #define fullstep              0x00000040    ///< full step mode controlled    
00056 #define halfstep              0x00000080    ///< half step mode controlled    
00057 #define microstep             0x00000100    ///< micro step mode controlled
00058 #define forward               0x00000200    ///< forward running motor
00059 #define dir2change            0x00000400    ///< direction has to be changed while the motor is running
00060 #define fastdecaymode         0x00000800    ///< decay mode is fast
00061 #define wavestep              0x00001000    ///< wave step mode controlled
00062 
00063 /* Variables  ----------------------------------------------------------------*/
00064 /* Number of devices. */
00065 uint8_t L6208::numberOfDevices = 0;
00066 
00067 /// RefMicroTable values are 2^L6208_SINE_WAVEFORM_POWER_OF_TWO_MAX_VALUE*|sin(n/16*PI/2)|
00068 /// where n is the index in the table
00069 const uint16_t L6208::RefMicroTable[L6208_USTEPS_PER_QUARTER_PERIOD*3] =
00070 {
00071   0,3212,6393,9512,12540,15447,18205,20788,23170,25330,27246,28899,30274,31357,32138,32610,
00072   32768,32610,32138,31357,30274,28899,27246,25330,23170,20788,18205,15447,12540,9512,6393,3212,
00073   0,3212,6393,9512,12540,15447,18205,20788,23170,25330,27246,28899,30274,31357,32138,32610
00074 };
00075 
00076 /* Methods -------------------------------------------------------------------*/
00077 /******************************************************//**
00078  * @brief Start the L6208 library
00079  * @param[in] pInit pointer to the initialization data
00080  * @retval COMPONENT_OK in case of success.
00081  **********************************************************/
00082 Status_t L6208::L6208_Init(void* pInit)
00083 { 
00084   if (pInit == NULL)
00085   {
00086     /* Set context variables to the predefined values from l6208_target_config.h */
00087     /* Set GPIO according to these values */
00088     L6208_SetDeviceParamsToPredefinedValues();
00089   }
00090   else
00091   {
00092     L6208_SetDeviceParamsToGivenValues((l6208_Init_t*) pInit);
00093   }
00094   
00095   /* Initialise the PWMs */
00096   L6208_Board_VrefPwmInit(BRIDGE_A, devicePrm.vrefPwmPeriod);
00097   L6208_Board_VrefPwmInit(BRIDGE_B, devicePrm.vrefPwmPeriod);
00098 
00099   /* Initialise the tick */
00100   L6208_Board_TickInit();
00101   
00102   /* Reset L6208 */
00103   L6208_ResetDevice();
00104   
00105   /* Align motor mechanical position to driver position */
00106   L6208_Board_VrefPwmStart(BRIDGE_A, devicePrm.vrefPwmPeriod);
00107   L6208_Board_VrefPwmStart(BRIDGE_B, devicePrm.vrefPwmPeriod);
00108   //L6208_Enable();
00109   
00110   return COMPONENT_OK;
00111 }
00112 
00113 /**********************************************************
00114  * @brief Read id
00115  * @param id pointer to the identifier to be read.
00116  * @retval COMPONENT_OK in case of success.
00117  **********************************************************/
00118 Status_t L6208::L6208_ReadID(uint8_t *id)
00119 {
00120   *id = deviceInstance;
00121 
00122   return COMPONENT_OK;
00123 }
00124 
00125 /**********************************************************
00126  * @brief  Attaches a user callback to the error Handler.
00127  * The call back will be then called each time the library 
00128  * detects an error
00129  * @param[in] callback Name of the callback to attach 
00130  * to the error Hanlder
00131  * @retval None
00132  **********************************************************/
00133 void L6208::L6208_AttachErrorHandler(void (*callback)(uint16_t error))
00134 {
00135   errorHandlerCallback = (void (*)(uint16_t error)) callback;
00136 }
00137 
00138 /******************************************************//**
00139  * @brief Disable the power bridges (leave the output bridges HiZ)
00140  * @retval None
00141  **********************************************************/
00142 void L6208::L6208_Disable(void)
00143 {
00144   L6208_Board_Disable();
00145   L6208_ClearSysFlag(EN_A_set);
00146 }
00147 
00148 /******************************************************//**
00149  * @brief Error handler which calls the user callback (if defined)
00150  * @param[in] error Number of the error
00151  * @retval None
00152  **********************************************************/
00153 void L6208::L6208_ErrorHandler(uint16_t error)
00154 {
00155   if (errorHandlerCallback != 0)
00156   {
00157     errorHandlerCallback(error);
00158   }
00159   else   
00160   {
00161     while(1)
00162     {
00163       /* Infinite loop */
00164     }
00165   }
00166 }
00167 
00168 /******************************************************//**
00169  * @brief Enable the power bridges
00170  * @retval None
00171  **********************************************************/
00172 void L6208::L6208_Enable(void)
00173 {
00174   L6208_Board_Enable();
00175   L6208_SetSysFlag(EN_A_set);
00176 }
00177 
00178 /******************************************************//**
00179  * @brief Get the stepper acceleration rate
00180  * in step/s^2 for full, half and wave modes
00181  * in microsteps/s^2 for microstep modes
00182  * @retval the stepper acceleration rate in step/s^2 or microstep/s^2
00183  * @note
00184  **********************************************************/
00185 uint16_t L6208::L6208_GetAcceleration(void)
00186 {
00187     return devicePrm.accelerationSps2;
00188 }
00189 
00190 /******************************************************//**
00191  * @brief Get the current speed
00192  * in step/s for full, half and wave modes
00193  * in microsteps/s for microstep modes
00194  * @retval return the current speed in step/s or microstep/s
00195  * @note
00196  **********************************************************/
00197 uint16_t L6208::L6208_GetCurrentSpeed(void)
00198 {
00199   uint64_t tmp64 = (uint64_t) devicePrm.speedSpt * L6208_Board_TickGetFreq();
00200   
00201   devicePrm.speedSps = (uint16_t)(tmp64 >> 23);
00202   if (devicePrm.speedSps & 0x1)
00203   {
00204     devicePrm.speedSps = (devicePrm.speedSps >> 1) + 1;
00205   }
00206   else
00207   {
00208     devicePrm.speedSps = devicePrm.speedSps >> 1;
00209   }
00210   return devicePrm.speedSps;
00211 }
00212 
00213 /******************************************************//**
00214  * @brief Get the motor decay mode
00215  * @retval decay mode
00216  **********************************************************/
00217 motorDecayMode_t L6208::L6208_GetDecayMode(void)
00218 {
00219   if (L6208_IsSysFlag(fastdecaymode)) return (FAST_DECAY);
00220   else return (SLOW_DECAY);
00221 }
00222 
00223 /******************************************************//**
00224  * @brief Get the stepper deceleration rate
00225  * in step/s^2 for full, half and wave modes
00226  * in microsteps/s^2 for microstep modes
00227  * @retval the stepper deceleration rate in step/s^2 or microstep/s^2
00228  * @note
00229  **********************************************************/
00230 uint16_t L6208::L6208_GetDeceleration(void)
00231 {
00232     return devicePrm.decelerationSps2;
00233 }
00234 
00235 /******************************************************//**
00236  * @brief Get the motor current direction
00237  * @retval direction
00238  **********************************************************/
00239 motorDir_t L6208::L6208_GetDirection(void)
00240 {
00241   if (L6208_IsSysFlag(forward))
00242   {
00243     return FORWARD;
00244   }
00245   else
00246   {
00247     return BACKWARD;
00248   }
00249 }
00250 
00251 /******************************************************//**
00252  * @brief Return the FW version.
00253  * @retval FW version
00254  **********************************************************/
00255 uint32_t L6208::L6208_GetFwVersion(void)
00256 {
00257   return L6208_FW_VERSION;
00258 }
00259 
00260 /******************************************************//**
00261  * @brief Get the mark position (32b signed) 
00262  * @retval mark position
00263  **********************************************************/
00264 int32_t L6208::L6208_GetMark(void)
00265 {
00266   return devicePrm.markPos;
00267 }
00268 
00269 /******************************************************//**
00270  * @brief Get the max speed
00271  * in step/s for full, half and wave modes
00272  * in microsteps/s for microstep modes
00273  * @retval return the max speed in step/s or microstep/s
00274  * @note
00275  **********************************************************/
00276 uint16_t L6208::L6208_GetMaxSpeed(void)
00277 {
00278   return devicePrm.maxSpeedSps;
00279 }
00280 
00281 /******************************************************//**
00282  * @brief Get the min speed
00283  * in step/s for full, half and wave modes
00284  * in microsteps/s for microstep modes
00285  * @retval return the min speed in step/s or microstep/s
00286  * @note
00287  **********************************************************/
00288 uint16_t L6208::L6208_GetMinSpeed(void)
00289 {
00290   return devicePrm.minSpeedSps;
00291 }
00292 
00293 /******************************************************//**
00294  * @brief Get the stepper state machine index
00295  * @retval one of the stepper state machine index in the motorState_t enum
00296  **********************************************************/
00297 motorState_t L6208::L6208_GetMotionState(void)
00298 {
00299   // gets the new stepper state machine index
00300   return devicePrm.motionState;    
00301 }
00302 
00303 /******************************************************//**
00304  * @brief Get the current position (32b signed) 
00305  * @retval current absoulte position
00306  **********************************************************/
00307 int32_t L6208::L6208_GetPosition(void)
00308 {
00309   return devicePrm.absolutePos;
00310 }
00311 
00312 /******************************************************//**
00313  * @brief Get the motor step mode
00314  * @retval step mode
00315  **********************************************************/
00316 motorStepMode_t L6208::L6208_GetStepMode(void)
00317 {
00318   return devicePrm.stepMode;
00319 }
00320 
00321 /******************************************************//**
00322  * @brief Get the selected stop mode
00323  * @retval the selected stop mode
00324  **********************************************************/
00325 motorStopMode_t L6208::L6208_GetStopMode(void)
00326 {
00327   if (L6208_IsSysFlag(HiZstop) == FALSE)
00328   {
00329       return (HOLD_MODE);
00330   }
00331   else
00332   {
00333       return (HIZ_MODE);
00334   }
00335 }
00336 
00337 /******************************************************//**
00338  * @brief Go to the home position
00339  * @retval None
00340  **********************************************************/
00341 void L6208::L6208_GoHome(void)
00342 {
00343   L6208_GoTo(0);
00344 }
00345 
00346 /******************************************************//**
00347  * @brief Go to the Mark position
00348  * @retval None
00349  **********************************************************/
00350 void L6208::L6208_GoMark(void)
00351 {
00352   L6208_GoTo(devicePrm.markPos);
00353 }
00354 
00355 /******************************************************//**
00356  * @brief Move the motor to the absolute position using the shortest path
00357  * @param[in] abs_pos 32 bit signed value position
00358  * @retval None
00359  * @note The position is at the resolution corresponding to the
00360  * selected step mode.
00361  * STEP_MODE_FULL or STEP_MODE_WAVE : step
00362  * STEP_MODE_HALF                     : 1/2 step
00363  * STEP_MODE_1_4              : 1/4 step
00364  * STEP_MODE_1_8              : 1/8 step
00365  * STEP_MODE_1_16             : 1/16 step 
00366  **********************************************************/
00367 void L6208::L6208_GoTo(int32_t abs_pos)
00368 {
00369   uint32_t steps = 0;
00370   
00371   if(L6208_IsSysFlag(running))
00372   {
00373     L6208_HardStop();
00374   }
00375   
00376   if (abs_pos > devicePrm.absolutePos)
00377   {
00378     steps = abs_pos - devicePrm.absolutePos;
00379     if (steps < (L6208_POSITION_RANGE>>1))
00380     {
00381       L6208_Move(FORWARD, steps);
00382     }
00383     else
00384     {
00385       L6208_Move(BACKWARD, (L6208_POSITION_RANGE - steps));
00386     }
00387   }
00388   else
00389   {
00390     steps = devicePrm.absolutePos - abs_pos;
00391     if (steps < (L6208_POSITION_RANGE>>1))
00392     {
00393       L6208_Move(BACKWARD, steps);
00394     }
00395     else
00396     {
00397       L6208_Move(FORWARD, (L6208_POSITION_RANGE - steps));
00398     }
00399   }
00400 }
00401 
00402 /******************************************************//**
00403  * @brief Move the motor to the absolute position
00404  * @param[in] direction FORWARD or BACKWARD
00405  * @param[in] abs_pos 32 bit signed value position
00406  * @retval None
00407  * @note The position is at the resolution corresponding to the
00408  * selected step mode.
00409  * STEP_MODE_FULL or STEP_MODE_WAVE : step
00410  * STEP_MODE_HALF                     : 1/2 step
00411  * STEP_MODE_1_4              : 1/4 step
00412  * STEP_MODE_1_8              : 1/8 step
00413  * STEP_MODE_1_16             : 1/16 step 
00414  **********************************************************/
00415 void L6208::L6208_GoToDir(motorDir_t direction, int32_t abs_pos)
00416 {
00417   uint32_t steps = 0;
00418   
00419   if(L6208_IsSysFlag(running))
00420   {
00421     L6208_HardStop();
00422   }
00423   
00424   if (direction != BACKWARD)
00425   {
00426     if (abs_pos > devicePrm.absolutePos)
00427     {
00428       steps = abs_pos - devicePrm.absolutePos;
00429     }
00430     else
00431     {
00432       steps = L6208_POSITION_RANGE + (abs_pos - devicePrm.absolutePos);
00433     }
00434   }
00435   else
00436   {
00437     if (abs_pos > devicePrm.absolutePos)
00438     {
00439       steps = L6208_POSITION_RANGE + (devicePrm.absolutePos - abs_pos);
00440     }
00441     else
00442     {
00443       steps = devicePrm.absolutePos - abs_pos;
00444     }
00445   }
00446   L6208_Move(direction, steps);
00447 }
00448 
00449 /******************************************************//**
00450  * @brief Immediately stop the motor and disables the power bridges
00451  * @retval None
00452  **********************************************************/
00453 void L6208::L6208_HardHiZ(void)
00454 {
00455   /* Disables power stage */
00456   L6208_Disable();
00457   
00458   /* Sets inactive state */
00459   L6208_SetMotionState(INACTIVE);
00460   
00461   /* Clears the running motor and the position */
00462   L6208_ClearSysFlag(running);
00463  
00464   /* Disables PWMs */
00465   L6208_Board_VrefPwmStop(BRIDGE_A);
00466   L6208_Board_VrefPwmStop(BRIDGE_B);
00467   
00468   /* Disables tick timer */
00469   L6208_Board_TickStop();
00470 }
00471 
00472 /******************************************************//**
00473  * @brief Immediately stop the motor and keeps holding torque
00474  * @retval None
00475  **********************************************************/
00476 void L6208::L6208_HardStop(void) 
00477 {
00478   /* Sets inactive state */
00479   L6208_SetMotionState(INACTIVE);
00480   
00481   /* Clears the running motor and the position */
00482   L6208_ClearSysFlag(running);
00483   L6208_VectorCalc(devicePrm.holdTorque);
00484     
00485   /* Disables tick timer */
00486   L6208_Board_TickStop();
00487 }
00488 
00489 /******************************************************//**
00490  * @brief Move the motor by the specified number of steps
00491  * in the specified direction
00492  * @param[in] direction FORWARD or BACKWARD
00493  * @param[in] stepCount 32 bit unsigned step count
00494  * @retval None
00495  * @note The step count resolution is corresponding to the
00496  * selected step mode.
00497  * STEP_MODE_FULL or STEP_MODE_WAVE : step
00498  * STEP_MODE_HALF                   : 1/2 step
00499  * STEP_MODE_1_4                    : 1/4 step
00500  * STEP_MODE_1_8                    : 1/8 step
00501  * STEP_MODE_1_16                   : 1/16 step 
00502  **********************************************************/
00503 void L6208::L6208_Move(motorDir_t direction, uint32_t stepCount)
00504 {
00505   if(L6208_IsSysFlag(running))
00506   {
00507     L6208_HardStop();
00508   }
00509 
00510   /* clear the velocity driving mode flag */
00511   L6208_ClearSysFlag(velocitymode);
00512   
00513   /* Set the indexing driving mode flag */
00514   /* and the user command executing flag */
00515   L6208_SetSysFlag(positionmode);
00516   
00517   /* store relative number of steps to move */
00518   devicePrm.positionTarget = stepCount;
00519 
00520   L6208_SetDirection(direction); 
00521   
00522   /* Motor activation */
00523   L6208_StartMovement(); 
00524 }
00525 
00526 /******************************************************//**
00527  * @brief  Release the L6208 reset (Reset pin set to high level)
00528  * @retval None
00529  **********************************************************/
00530 void L6208::L6208_ReleaseReset(void)
00531 { 
00532   L6208_Board_ReleaseReset(); 
00533 }
00534 
00535 /******************************************************//**
00536  * @brief Reset the L6208 (Reset pin set to low level)
00537  * @retval None
00538  **********************************************************/
00539 void L6208::L6208_Reset(void)
00540 {
00541   L6208_Board_Reset();
00542 }
00543 
00544 
00545 /******************************************************//**
00546  * @brief Call L6208_SetStepMode with current step mode, 
00547  * the L6208_SetStepMode function along with setting the step mode resets
00548  * the L6208 device
00549  * @retval None
00550  **********************************************************/
00551 void L6208::L6208_ResetDevice(void)
00552 {
00553   L6208_SetStepMode(L6208_GetStepMode());
00554 }
00555 
00556 /******************************************************//**
00557  * @brief Run the motor in the specified direction
00558  * according to the speed profile defined by the minimum speed,
00559  * maximum speed, and acceleration parameters. 
00560  * The device accelerates from the minimum speed up to the maximum
00561  * speed by using the device acceleration.
00562  * @param[in] direction FORWARD or BACKWARD
00563  * @retval None
00564  **********************************************************/
00565 void L6208::L6208_Run(motorDir_t direction)
00566 {
00567   if(L6208_IsSysFlag(running))
00568   {
00569     L6208_HardStop();
00570   }
00571   L6208_SetDirection(direction);
00572   /* Clear the indexing driving mode flag */
00573   L6208_ClearSysFlag(positionmode);
00574   /* Set the velocity driving mode flag */
00575   L6208_SetSysFlag(velocitymode);
00576   /* Motor activation */
00577   L6208_StartMovement(); 
00578 }
00579 
00580 /******************************************************//**
00581  * @brief Set the stepper acceleration rate
00582  * in step/s^2 and step/tick^2 for full, half and wave modes
00583  * in microsteps/s^2 and microsteps/tick^2 for microstep modes
00584  * @param[in] newAcc new acceleration rate in step/s^2 or microstep/s^2
00585  * @retval TRUE
00586  * @note
00587  **********************************************************/
00588 bool L6208::L6208_SetAcceleration(uint16_t newAcc)
00589 {
00590   uint16_t newAccSpt2 = L6208_ConvertAcceDecelRateValue(newAcc);
00591   if (newAccSpt2)
00592   {
00593     devicePrm.accelerationSps2 = newAcc;
00594     devicePrm.accelerationSpt2 = newAccSpt2; 
00595   }
00596   else
00597   {
00598     L6208_ErrorHandler(L6208_ERROR_SET_ACCELERATION);
00599   }
00600   return TRUE;
00601 }
00602 
00603 /******************************************************//**
00604  * @brief Select the motor decay mode
00605  * @param[in] decayMode (SLOW_DECAY or FAST_DECAY)
00606  * @retval None
00607  **********************************************************/
00608 void L6208::L6208_SetDecayMode(motorDecayMode_t decayMode)
00609 {
00610   if ((decayMode & L6208_FAST_DECAY_MODE_MASK) == L6208_FAST_DECAY_MODE_MASK)
00611   {
00612     L6208_Board_CONTROL_PIN_Set();
00613     L6208_SetSysFlag(fastdecaymode);
00614   }
00615   else 
00616   {
00617     L6208_Board_CONTROL_PIN_Reset();
00618     L6208_ClearSysFlag(fastdecaymode);
00619   }
00620 }
00621 
00622 /******************************************************//**
00623  * @brief Set the stepper deceleration rate
00624  * in step/s^2 and step/tick^2 for full, half and wave modes
00625  * in microsteps/s^2 and microsteps/tick^2 for microstep modes
00626  * @param[in] newDec new deceleration rate in step/s^2 or microstep/s^2
00627  * @retval TRUE
00628  * @note
00629  **********************************************************/
00630 bool L6208::L6208_SetDeceleration(uint16_t newDec)
00631 {
00632   uint16_t newDecSpt2 = L6208_ConvertAcceDecelRateValue(newDec);
00633   if (newDecSpt2)
00634   {
00635     devicePrm.decelerationSps2 = newDec;
00636     devicePrm.decelerationSpt2 = newDecSpt2;
00637   }
00638   else
00639   {
00640     L6208_ErrorHandler(L6208_ERROR_SET_DECELERATION);
00641   }
00642   return TRUE;
00643 }
00644 
00645 /******************************************************//**
00646  * @brief Specify the direction
00647  * @param[in] dir FORWARD or BACKWARD
00648  * @note In velocity mode a direction change forces the device to stop and 
00649  * then run in the new direction. In position mode, if the device is 
00650  * running, a direction change will generate an error.
00651  * @retval None
00652  **********************************************************/
00653 void L6208::L6208_SetDirection(motorDir_t dir)
00654 {
00655   L6208_ClearSysFlag(dir2change);
00656   if (dir == FORWARD)
00657   {
00658     if (!L6208_IsSysFlag(forward))
00659     {
00660       if (L6208_IsSysFlag(running))
00661       {
00662         /* motor is running */
00663         if (L6208_IsSysFlag(positionmode))
00664         {
00665           L6208_ErrorHandler(L6208_ERROR_SET_DIRECTION);
00666         }
00667         else
00668         {
00669           /* set the rotation direction to change flag */
00670           L6208_SetSysFlag(dir2change);
00671         }
00672       }
00673       else /* the motor is stopped, cw direction selected */
00674       {
00675         L6208_SetSysFlag(forward);
00676         L6208_Board_DIR_PIN_Set();
00677       }
00678     }
00679   }
00680   else
00681   {
00682     if (L6208_IsSysFlag(forward))
00683    {
00684       if (L6208_IsSysFlag(running))
00685       {
00686         /* motor is running */
00687         if (L6208_IsSysFlag(positionmode))
00688         {
00689           L6208_ErrorHandler(L6208_ERROR_SET_DIRECTION);
00690         }
00691         else
00692         {
00693           /* set the rotation direction to change flag */
00694           L6208_SetSysFlag(dir2change);
00695         }
00696       }
00697       else /* the motor is stopped, ccw direction selected */
00698       {
00699         L6208_ClearSysFlag(forward);
00700         L6208_Board_DIR_PIN_Reset();
00701       }
00702     }
00703   }
00704   if(L6208_IsSysFlag(dir2change))
00705   {
00706     L6208_VectorCalc(devicePrm.decelTorque);     
00707     L6208_SetMotionState(DECELERATINGTOSTOP);  
00708   }
00709 }
00710 
00711 /******************************************************//**
00712  * @brief Set current position to be the home position
00713  * @retval None
00714  **********************************************************/
00715 void L6208::L6208_SetHome(void)
00716 {
00717   if (!L6208_IsSysFlag(running))
00718   {
00719       devicePrm.absolutePos = 0;
00720   }
00721   else
00722   {
00723       L6208_ErrorHandler(L6208_ERROR_SET_HOME);
00724   }
00725 }
00726 
00727 /******************************************************//**
00728  * @brief Set current position to be the mark position 
00729  * @retval None
00730  **********************************************************/
00731 void L6208::L6208_SetMark(void)
00732 {
00733   devicePrm.markPos = devicePrm.absolutePos;
00734 }
00735 
00736 /******************************************************//**
00737  * @brief Set the user selected maximum speed 
00738  * in step/s and step/tick for full, half and wave modes
00739  * in microsteps/s and microsteps/tick for microstep modes
00740  * @param[in] newSpeed speed value (step/s or microstep/s)
00741  * @retval TRUE
00742  * @note One microstep is 1/16 step
00743  **********************************************************/
00744 bool L6208::L6208_SetMaxSpeed(uint16_t newSpeed)
00745 {
00746   if (L6208_SetSpeed(newSpeed, &devicePrm.maxSpeedSpt))
00747   {
00748     devicePrm.maxSpeedSps = newSpeed;
00749   }
00750   else
00751   {
00752     L6208_ErrorHandler(L6208_ERROR_SET_MAX_SPEED);
00753   }
00754   return TRUE;
00755 }
00756 
00757 /******************************************************//**
00758  * @brief Set the user selected minimum speed 
00759  * in step/s and step/tick for full, half and wave modes
00760  * in microsteps/s and microsteps/tick for microstep modes
00761  * @param[in] newSpeed speed value (step/s or microstep/s)
00762  * @retval TRUE
00763  * @note One microstep is 1/16 step
00764  **********************************************************/
00765 bool L6208::L6208_SetMinSpeed(uint16_t newSpeed)
00766 {
00767   if (L6208_SetSpeed(newSpeed, &devicePrm.minSpeedSpt))
00768   {
00769     devicePrm.minSpeedSps = newSpeed;
00770   }
00771   else
00772   {
00773     L6208_ErrorHandler(L6208_ERROR_SET_MIN_SPEED);
00774   }
00775   return TRUE;
00776 }
00777 
00778 /******************************************************//**
00779  * @brief Set the step mode
00780  * @param[in] stepMode
00781  * @retval true if the command is successfully executed, else false
00782  * @note Every time the step mode is changed, the step state machine is reset
00783  **********************************************************/
00784 bool L6208::L6208_SetStepMode(motorStepMode_t stepMode)
00785 {
00786   devicePrm.stepMode = stepMode;
00787   L6208_ClearSysFlag(fullstep | halfstep | microstep | wavestep);
00788   switch (stepMode)
00789   {
00790     case STEP_MODE_HALF:
00791       /* Set the Half/Full pin low and Reset and the set the Half/Full pin high*/
00792       L6208_Board_HALF_FULL_PIN_Reset(); 
00793       L6208_Board_Reset();
00794       L6208_Board_HALF_FULL_PIN_Set();
00795       /* Set system flag */
00796       L6208_SetSysFlag(halfstep);
00797       break;
00798     case STEP_MODE_FULL:
00799        /* Set the Half/Full pin low and Reset */
00800       L6208_Board_HALF_FULL_PIN_Reset(); 
00801       L6208_Board_Reset();
00802       /* Set system flag */
00803       L6208_SetSysFlag(fullstep);
00804       break;
00805     case STEP_MODE_WAVE:
00806       /* Set the Half/Full pin low and Reset and the set the Half/Full pin high*/
00807       L6208_Board_CLOCK_PIN_Reset();
00808       L6208_Board_HALF_FULL_PIN_Reset();
00809       L6208_Board_Reset();
00810       L6208_Board_CLOCK_PIN_Set();
00811       L6208_Board_HALF_FULL_PIN_Set();
00812       L6208_Board_Delay(2);
00813       L6208_Board_CLOCK_PIN_Reset();
00814       L6208_Board_Delay(2);
00815       L6208_Board_HALF_FULL_PIN_Reset();
00816       /* Set system flag */
00817       L6208_SetSysFlag(wavestep);
00818       break;
00819       case STEP_MODE_1_4:
00820       /* Set the Half/Full pin low and Reset */
00821       L6208_Board_HALF_FULL_PIN_Reset();
00822       L6208_Board_Reset();
00823       /* Set system flag */
00824       L6208_SetSysFlag(microstep);
00825       devicePrm.uStepInc = 4;
00826       break;
00827     case STEP_MODE_1_8:
00828       /* Set the Half/Full pin low and Reset */
00829       L6208_Board_HALF_FULL_PIN_Reset();
00830       L6208_Board_Reset();
00831       /* Set system flag */
00832       L6208_SetSysFlag(microstep);
00833       devicePrm.uStepInc = 2;
00834       break;
00835       case STEP_MODE_1_16:
00836       /* Set the Half/Full pin low and Reset */
00837       L6208_Board_HALF_FULL_PIN_Reset();
00838       L6208_Board_Reset();
00839       /* Set system flag */
00840       L6208_SetSysFlag(microstep);
00841       devicePrm.uStepInc = 1;
00842       break;
00843     default:
00844       return FALSE;
00845     }
00846   L6208_Board_Delay(2);
00847   L6208_Board_ReleaseReset();
00848   L6208_ResetSteps();
00849   return TRUE;
00850 }
00851 
00852 /******************************************************//**
00853  * @brief Select the mode to stop the motor. When the motor
00854  * is stopped, if autoHiZ is TRUE, the power bridges are disabled
00855  * if autoHiZ is FALSE, the power bridges are kept enabled.
00856  * @param[in] stopMode HOLD_MODE to let power bridge enabled
00857  * @retval None
00858  **********************************************************/
00859 void L6208::L6208_SetStopMode(motorStopMode_t stopMode)
00860 {
00861   if (stopMode == HOLD_MODE)
00862   {
00863     L6208_ClearSysFlag(HiZstop);
00864   }
00865   else
00866   {
00867     L6208_SetSysFlag(HiZstop);
00868   }
00869 }
00870 
00871 /******************************************************//**
00872  * @brief  Stop the motor by using the device deceleration and set deceleration torque
00873  * @retval true if the command is successfully executed, else false
00874  * @note .
00875  **********************************************************/
00876 bool L6208::L6208_SoftStop(void)
00877 {   
00878   L6208_VectorCalc(devicePrm.decelTorque);
00879   L6208_SetMotionState(DECELERATINGTOSTOP);
00880   return TRUE;
00881 }
00882 
00883 /******************************************************//**
00884  * @brief  Handle the device state machine at each tick timer pulse end.
00885  * @retval None
00886  **********************************************************/
00887 void L6208::L6208_TickHandler(void)
00888 {
00889   uint32_t locMaxSpeedSpt = devicePrm.maxSpeedSpt;
00890   uint32_t locMinSpeedSpt = devicePrm.minSpeedSpt;
00891   
00892   /* Update state, target speed, acceleration and deceleration rates */
00893   L6208_Board_CLOCK_PIN_Reset();
00894     
00895   switch(L6208_GetMotionState())
00896   {
00897     /* ============ Velocity control mode states ======================== */
00898     case ACCELERATING:
00899       /* velocity mode: acceleration phase */
00900       /* Increase Speed and update position */
00901       L6208_DoAccel();
00902       if(locMaxSpeedSpt < devicePrm.speedSpt)
00903       {  
00904         /*Target speed reached */
00905         devicePrm.speedSpt = locMaxSpeedSpt;
00906         L6208_VectorCalc(devicePrm.runTorque); 
00907         L6208_SetMotionState(STEADY);
00908       }
00909       break;
00910     case STEADY:  
00911       /* velocity mode: constant speed phase */
00912       /* Update position */
00913       L6208_DoRun();  
00914       if(locMaxSpeedSpt != devicePrm.speedSpt)
00915       { 
00916         /* targeted speed  has changed */
00917         if(locMaxSpeedSpt< devicePrm.speedSpt)
00918         { 
00919           /* Slow down the motor */
00920           L6208_VectorCalc(devicePrm.decelTorque);     
00921           L6208_SetMotionState(DECELERATING); 
00922         }
00923         else
00924         { 
00925           /* speed up the motor */
00926           L6208_VectorCalc(devicePrm.accelTorque);     
00927           L6208_SetMotionState(ACCELERATING);
00928         }
00929       }
00930       break;
00931     case DECELERATING:  
00932       /* velocity mode: running motor deceleration phase */
00933       /* Decrease Speed and update position */
00934       L6208_DoDecel();  
00935       if(locMaxSpeedSpt > devicePrm.speedSpt)
00936       { 
00937         /*Target speed reached but motor has still to be run*/
00938         devicePrm.speedSpt = locMaxSpeedSpt;
00939         L6208_VectorCalc(devicePrm.runTorque);   
00940         L6208_SetMotionState(STEADY);  
00941       }
00942       break;
00943     case DECELERATINGTOSTOP: 
00944       /* velocity mode: decelerate to stopped phase */
00945       /* Decrease current speed */
00946       L6208_DoDecel();
00947       if(devicePrm.speedSpt == locMinSpeedSpt)
00948       { 
00949         if (L6208_IsSysFlag(dir2change))
00950         { 
00951           L6208_ClearSysFlag(running);
00952           /* Change direction */
00953           if (L6208_IsSysFlag(forward))
00954           {
00955             /* switch to reverse rotation */
00956             L6208_SetDirection(BACKWARD);
00957           }
00958           else
00959           {
00960             /* switch to forward rotation */
00961             L6208_SetDirection(FORWARD);
00962           }
00963           L6208_SetSysFlag(running);
00964           L6208_SetMotionState(ACCELERATING);
00965           /* Set VRefA and VRefB to the selected acceleration torque */
00966           L6208_VectorCalc(devicePrm.accelTorque);
00967         }
00968         else
00969         {
00970           if (L6208_IsSysFlag(HiZstop))
00971           { 
00972             L6208_HardHiZ();
00973           }
00974           else
00975           {
00976             L6208_HardStop();
00977           }
00978         }
00979       }
00980       break;
00981     
00982     /* ============ Position (indexed) control mode states ======================== */
00983 
00984     case INDEX_ACCEL:
00985       /*  position mode: acceleration state*/
00986       
00987       /* Increase Speed and update position */
00988       L6208_DoAccel();  
00989 
00990       if(devicePrm.positionTarget1 <= devicePrm.step)
00991       { 
00992         /* End of acceleration phase */
00993         L6208_VectorCalc(devicePrm.runTorque); 
00994         L6208_SetMotionState(INDEX_RUN);    
00995       }
00996       break;
00997 
00998       case INDEX_RUN:   
00999         /* position mode: constant speed phase */
01000         
01001         /* Update position */
01002         L6208_DoRun();  
01003 
01004         if(devicePrm.positionTarget2 <= devicePrm.step)
01005         {  
01006           /* reach position targeted for constant speed */
01007           L6208_VectorCalc(devicePrm.decelTorque);   
01008           L6208_SetMotionState(INDEX_DECEL); 
01009         }
01010         break;
01011 
01012       case INDEX_DECEL: 
01013         /* position mode: deceleration phase */
01014         
01015         /* Decrease Speed and update position */
01016         L6208_DoDecel();  
01017 
01018         if(devicePrm.positionTarget3 <= devicePrm.step)
01019         {  
01020           /* reach position targeted for deceleration phase */
01021           /* the motor terminated its run */
01022           /* the torque will be the deceleration one */
01023           devicePrm.step = devicePrm.positionTarget3;
01024           L6208_SetMotionState(INDEX_DWELL);   
01025         }
01026         break;
01027 
01028       case INDEX_DWELL: 
01029         /* position mode: dwelling state */
01030         if(devicePrm.dwellCounter > 0)
01031         {
01032           /* decrease the dwelling wait tick counter */
01033           devicePrm.dwellCounter--;
01034         }
01035         if(devicePrm.dwellCounter == 0)
01036         { 
01037           /* dwelling wait time is elapsed */
01038           /* so stop the motor */
01039           if (L6208_IsSysFlag(HiZstop))
01040           { 
01041             L6208_HardHiZ();
01042           }
01043           else
01044           {
01045             L6208_HardStop();
01046           }
01047         }
01048         break;
01049         
01050     /* ============ stopped state ======================== */
01051     case INACTIVE:
01052     {
01053       if(L6208_IsSysFlag(running))
01054       {
01055         /* clear the user move command executing  */
01056         /* and the motor running flags */
01057         L6208_ClearSysFlag(running);
01058       }
01059       break;
01060     }
01061     default:
01062       break;
01063   } /* switch(L6208_GetMotionState()) */
01064   if(L6208_GetMotionState() != INACTIVE)
01065   {
01066     if (L6208_IsSysFlag(microstep))
01067     { 
01068       /* Microstep handling */     
01069       switch(devicePrm.uStepInc)
01070       {
01071         default:
01072         case 1:  
01073           /* 1 microstep increment */
01074           devicePrm.lsbTicks = (uint8_t)(devicePrm.ticks>>16);
01075           break;
01076 
01077         case 2:  
01078           /* 2 microsteps increment */           
01079           devicePrm.lsbTicks = (uint8_t)(devicePrm.ticks>>17);
01080           break;
01081 
01082         case 4:  
01083           /* 4 microsteps increment */
01084           devicePrm.lsbTicks = (uint8_t)(devicePrm.ticks>>18);
01085           break;
01086       }
01087       devicePrm.lsbTicks &= 0x01;
01088       if(devicePrm.lsbOldUSteppingTicks != devicePrm.lsbTicks)
01089       { 
01090         /*  waveform sample to update */
01091         devicePrm.lsbOldUSteppingTicks = devicePrm.lsbTicks;
01092         devicePrm.step++;
01093         if(L6208_IsSysFlag(forward))
01094         { 
01095           /* the motor is going forward */
01096           devicePrm.absolutePos++;
01097           /* Reset the absolute motor position in step/microsteps */
01098           /* Get next microstep sample */
01099           devicePrm.uStepSample += devicePrm.uStepInc;  
01100           if(devicePrm.uStepSample > 31)
01101           {
01102             devicePrm.uStepSample = 0;
01103           }
01104         }
01105         else
01106         { 
01107          /* the motor is going backward */
01108           devicePrm.absolutePos--;
01109           if(devicePrm.uStepSample >= devicePrm.uStepInc)
01110           {
01111             /* Get previous microstep sample */
01112             devicePrm.uStepSample -= devicePrm.uStepInc; 
01113           }
01114           else
01115           {
01116             devicePrm.uStepSample = 32 - devicePrm.uStepInc;
01117           }
01118         }
01119         /* set the PWM to update VRefs */
01120         L6208_VrefPwmComputePulseWidth(BRIDGE_A, pMicroTable2[devicePrm.uStepSample], FALSE);
01121         L6208_VrefPwmComputePulseWidth(BRIDGE_B, microTable1[devicePrm.uStepSample], FALSE);
01122         if(devicePrm.uStepsample2update > 0)
01123         { 
01124           /*  the waveform samples table has been recalculated 
01125           so update the waveform scanning table */
01126           L6208_UpdateScanWaveformTable();
01127           devicePrm.uStepsample2update = 0;
01128         }
01129       }
01130       /* Microstep: use the bit4 toggling as step clock */
01131       /* this bit is used because there are 16 microstep samples per quarter period */
01132       devicePrm.lsbTicks = (uint8_t)((devicePrm.uStepSample>>4) & 0x01);
01133       if(devicePrm.lsbOldTicks != devicePrm.lsbTicks)
01134       { 
01135         /* the selected bit status changed ==> get the next motor step
01136         save the current masked motor tick position for step setting scope ... */
01137         devicePrm.lsbOldTicks = devicePrm.lsbTicks;
01138         L6208_Board_CLOCK_PIN_Set();
01139       }
01140     }
01141     else
01142     {
01143       /* Full and half step handling code */ 
01144       if(!L6208_IsSysFlag(halfstep))
01145       { 
01146         /* Full step: use the bit 16 toggling as step clock */
01147         devicePrm.lsbTicks = (uint8_t)((devicePrm.ticks>>16) & 0x00000001);
01148       }
01149       else
01150       { 
01151         /* half step: use the bit 15 toggling as step clock */
01152         devicePrm.lsbTicks = (uint8_t)((devicePrm.ticks>>15) & 0x00000001);
01153       }
01154       if(devicePrm.lsbOldTicks != devicePrm.lsbTicks)
01155       { 
01156         /* the selected bit status changed ==> get the next motor step */
01157         devicePrm.step++;
01158         if(L6208_IsSysFlag(forward))
01159         { 
01160           /* the motor is going forward */
01161           devicePrm.absolutePos++;
01162         }
01163         else
01164         {
01165           /* the motor is going backward */
01166           devicePrm.absolutePos--;          
01167         }
01168         /* save the current masked motor tick position for step setting scope ... */
01169         devicePrm.lsbOldTicks = devicePrm.lsbTicks;
01170         L6208_Board_CLOCK_PIN_Set();
01171       }
01172     }
01173   }
01174   L6208_UstepWaveformHandling();
01175   L6208_VrefPwmUpdatePulseWidth();
01176 }
01177 
01178 /******************************************************//**
01179  * @brief Get the frequency of VREFA and VREFB PWM
01180  * @retval the frequency of VREFA and VREFB PWM in Hz
01181  * @note
01182  **********************************************************/
01183 uint32_t L6208::L6208_VrefPwmGetFreq(void)
01184 {
01185   return devicePrm.vrefPwmFreq;
01186 }
01187 
01188 /******************************************************//**
01189  * @brief Set the frequency of the VREFA and VREFB PWM
01190  * @param[in] newFreq in Hz
01191  * @retval None
01192  * @note
01193  **********************************************************/
01194 void L6208::L6208_VrefPwmSetFreq(uint32_t newFreq)
01195 {
01196   devicePrm.vrefPwmFreq = newFreq;
01197   /* Compute the pwm period in 1/256th of a microsecond */
01198   devicePrm.vrefPwmPeriod = (uint16_t)((1000000<<8)/newFreq);
01199   /* Re-Initialise the PWMs -----------------------------------------------------*/
01200   L6208_Board_VrefPwmInit(BRIDGE_A, devicePrm.vrefPwmPeriod);
01201   L6208_Board_VrefPwmInit(BRIDGE_B, devicePrm.vrefPwmPeriod);
01202   /* Recompute the waveform samples according to the new PWM frequency */
01203   L6208_ScaleWaveformTable();
01204   /* Update the waveform scanning table */
01205   L6208_UpdateScanWaveformTable();
01206   if (L6208_IsSysFlag(running))
01207   {
01208     L6208_Board_VrefPwmStart(BRIDGE_A, devicePrm.vrefPwmPeriod);
01209     L6208_Board_VrefPwmStart(BRIDGE_B, devicePrm.vrefPwmPeriod);
01210   }
01211 }
01212 
01213 /******************************************************//**
01214  * @brief Lock while motor is running
01215  * @retval None
01216  **********************************************************/
01217 void L6208::L6208_WaitWhileActive(void)
01218 {
01219   /* Wait while motor is running */
01220   while (L6208_IsSysFlag(running));
01221 }
01222 
01223 /* ------------------------------------------------------------------------- */
01224 /* Private functions ------------------------------------------------------- */
01225 /* ------------------------------------------------------------------------- */
01226 /******************************************************//**
01227  * @brief Clear the bit/s of flags according to the specified mask
01228  * @param[in] mask flag bit mask
01229  * @retval None
01230  **********************************************************/
01231 inline void L6208::L6208_ClearSysFlag(uint32_t mask)
01232 {
01233   devicePrm.flags &= ~mask;    
01234 }
01235 
01236 /******************************************************//**
01237  * @brief Compute the number of steps at the end of the accereration/deceleration phase
01238  * P = position in steps at the end of the acceleration/deceleration phase
01239  * T = acceleration/deceleration time in seconds
01240  * A =  acceleration/deceleration rate in steps per second per second (steps/sec^2)
01241  * V = peak velocity during acceleration/deceleration phase
01242  * V1 = average velocity during acceleration/deceleration phase
01243  * T = V/A
01244  * V1 = V/2
01245  * P = V1*T
01246  * P = V^2/2A
01247  * @param  accOrDecRate acceleration/deceleration rate in steps per second per second (steps/sec^2)
01248  * @retval end position or 0xFFFFFFFF on error 
01249  **********************************************************/
01250 uint32_t L6208::L6208_ComputeNbAccOrDecSteps(uint16_t accOrDecRate)
01251 {
01252   uint32_t nbAccOrDecSteps;
01253   uint32_t locMaxSpeedSps = (uint32_t)devicePrm.maxSpeedSps;
01254   
01255   if (L6208_IsSysFlag(microstep))
01256   {
01257     switch(devicePrm.uStepInc)
01258     {
01259       case 1:  
01260         locMaxSpeedSps = (uint32_t)devicePrm.maxSpeedSps;
01261         break;
01262       case 2:            
01263         locMaxSpeedSps = ((uint32_t)devicePrm.maxSpeedSps)>>1;
01264         accOrDecRate >>= 1;
01265         break;
01266       case 4:  
01267         locMaxSpeedSps = ((uint32_t)devicePrm.maxSpeedSps)>>2;
01268         accOrDecRate >>= 2;
01269         break;
01270       default:
01271         break;
01272     }
01273   }
01274   else if (L6208_IsSysFlag(halfstep))
01275   {
01276     locMaxSpeedSps = ((uint32_t)devicePrm.maxSpeedSps)<<1;
01277     accOrDecRate <<= 1;
01278   }
01279   
01280   if(accOrDecRate == 0)
01281   {
01282     /* division by 0 error */
01283     return 0xFFFFFFFF;
01284   }
01285   nbAccOrDecSteps = locMaxSpeedSps * locMaxSpeedSps;
01286   nbAccOrDecSteps /= (uint32_t)accOrDecRate;
01287   nbAccOrDecSteps /= 2;
01288 
01289   return nbAccOrDecSteps;
01290 }
01291 
01292 /******************************************************//**
01293  * @brief Compute the acceleration/deceleration speed increment value
01294  * @param[in] newAccOrDecRate acceleration or deceleration value (steps/s^2) greater or equal than 24
01295  * @retval the speed (step/tick) increment value
01296  * LSB = 2^-24 step/tick^2 or 2^-20 microstep/tick^2
01297  * @note return 0 if the rate is too low or if the tick frequency is too small
01298  * or if the device is running in position mode
01299  **********************************************************/
01300 uint16_t L6208::L6208_ConvertAcceDecelRateValue(uint16_t newAccOrDecRate)
01301 {
01302   uint64_t tmp64;
01303   uint32_t tmp32;
01304 
01305   if (((L6208_IsSysFlag(running))&&(L6208_IsSysFlag(positionmode)))||\
01306       (newAccOrDecRate < L6208_MIN_ACC_DEC_RATE))
01307   {
01308     return 0;
01309   } 
01310   /* Compute (tick frequency)^2 */
01311   tmp32 = (uint32_t)L6208_Board_TickGetFreq();
01312   tmp32 *= tmp32;
01313   /* Return 0 if the (tick frequency)^2 is too small */
01314   if ( tmp32 < (uint32_t)newAccOrDecRate )
01315   {
01316     return 0;
01317   } 
01318   /* Compute the decimal number of microstep or step per tick^2 */
01319   /* Decimal part is on 32 bits */
01320   tmp64 = (uint64_t)newAccOrDecRate << 32;
01321   tmp64 /= ((uint64_t)tmp32);
01322 
01323   return (uint16_t)((tmp64 & 0x00000000FFFFFFFF)>>8);
01324 }
01325 
01326 /******************************************************//**
01327  * @brief Compute next position and speed according to the acceleration rate
01328  * @retval None
01329  **********************************************************/
01330 void L6208::L6208_DoAccel(void)
01331 {
01332   /* Increase speed by acceleration rate */
01333   uint32_t locAccelerationSpt2 = (uint32_t)devicePrm.accelerationSpt2;
01334   uint32_t locMinSpeedSpt = devicePrm.minSpeedSpt;
01335   if ((devicePrm.speedSpt + locAccelerationSpt2) < locMinSpeedSpt)
01336   {
01337     devicePrm.speedSpt = locMinSpeedSpt;
01338   }
01339   else
01340   {
01341     devicePrm.speedSpt += locAccelerationSpt2;
01342   }
01343   /* Compute next position */
01344   L6208_DoRun();
01345 }
01346 
01347 /******************************************************//**
01348  * @brief Compute next position and speed according to the deceleration rate
01349  * @retval None
01350  **********************************************************/
01351 void L6208::L6208_DoDecel(void)
01352 {
01353   /* Decrease current speed by deceleration rate */
01354   uint32_t locDecelerationSpt2 = (uint32_t)devicePrm.decelerationSpt2;
01355   uint32_t locMinSpeedSpt = devicePrm.minSpeedSpt;
01356   if((devicePrm.speedSpt - locMinSpeedSpt) > (uint32_t)locDecelerationSpt2)  
01357   {
01358     devicePrm.speedSpt -= (uint32_t)locDecelerationSpt2;
01359   }
01360   else
01361   {
01362     /* Set minimum speed */
01363     devicePrm.speedSpt = locMinSpeedSpt;
01364   }
01365   /* Compute next position */
01366   L6208_DoRun(); 
01367 }
01368 
01369 /******************************************************//**
01370  * @brief Compute next position by adding current speed
01371  * @retval None
01372  **********************************************************/
01373 void L6208::L6208_DoRun(void)
01374 {
01375   devicePrm.ticks += (devicePrm.speedSpt >> 8) & 0x0000FFFF;
01376 }
01377 
01378 /******************************************************//**
01379  * @brief Get number of samples to rescale
01380  * @retval uStepsample2scale the number of micro stepping waveform samples to rescale
01381  **********************************************************/
01382 uint8_t L6208::L6208_GetMicrostepSample2Scale(void)
01383 {
01384   return devicePrm.uStepsample2scale;
01385 }
01386 
01387 /******************************************************//**
01388  * @brief  Initialize the system for position mode motor moving command
01389  *  P = total move distance in steps
01390  *  P1 = steps required to accel from 0 to V
01391  *  P2 = steps required to decel from V to 0
01392  *  V = peak velocity in steps per second (steps/sec)
01393  *  V1 = average velocity during accel or decel*
01394  *  A = required accel rate in steps per second per second (steps/sec2)
01395  *  D = required decel rate in steps per second per second (steps/sec2)
01396  *  T1 = acceleration time in seconds
01397  *  T2 = deceleration time in seconds*
01398  *
01399  *  1) T1 = V / A
01400  *  2) V1 = V / 2
01401  *  3) P1 = V1 T1
01402  *  Substituting 1 and 2 into 3 yields:
01403  *  4) P1 = V2 / 2A
01404  *  In the same manner we have:
01405  *  5) P2 = V2 / 2D
01406  *
01407  *  P1 = PD/(D+A)
01408  *
01409  *  \sa Application Note: AN2044  
01410  * @retval None
01411  **********************************************************/
01412 void L6208::L6208_Indexmodeinit(void)
01413 {
01414   uint32_t tmpVal0;
01415   uint32_t tmpVal1;
01416   uint32_t locAccelSteps;
01417   uint32_t locDecSteps;
01418 
01419   /* calculate the number of steps to get the running speed */
01420   locAccelSteps = L6208_ComputeNbAccOrDecSteps(devicePrm.accelerationSps2);
01421   /* calculate the number of steps to get the motor stopped */
01422   locDecSteps = L6208_ComputeNbAccOrDecSteps(devicePrm.decelerationSps2);
01423   if(( locAccelSteps + locDecSteps ) > devicePrm.positionTarget)
01424   { 
01425     /* Triangular move needed */
01426     /* accelsteps = P1 = PD/(D+A) */
01427     tmpVal0 = devicePrm.positionTarget * devicePrm.decelerationSps2;
01428     tmpVal1 = (uint32_t)devicePrm.decelerationSps2;
01429     tmpVal1 += (uint32_t)devicePrm.accelerationSps2;
01430     locAccelSteps = tmpVal0 / tmpVal1;
01431     devicePrm.positionTarget1 = locAccelSteps;
01432     devicePrm.positionTarget2 = devicePrm.positionTarget1 + 1;
01433     devicePrm.positionTarget3 = devicePrm.positionTarget;
01434     if(devicePrm.positionTarget1 == 0)
01435     {
01436       devicePrm.positionTarget1 = 1;
01437     }
01438   }
01439   else
01440   {  
01441     /* trapezoidal move needed */
01442     /* P1 = V^2/2A */
01443     /* P2 = P - V^2/2D */
01444     devicePrm.positionTarget1 = locAccelSteps;
01445     devicePrm.positionTarget2 = devicePrm.positionTarget - locDecSteps;
01446     devicePrm.positionTarget3 = devicePrm.positionTarget;
01447   }
01448   L6208_SetMotionState(INDEX_ACCEL);  
01449 }
01450 
01451 /******************************************************//**
01452  * @brief Check the bit/s of flags according to the specified mask
01453  * @param[in] mask flag bit mask
01454  * @retval TRUE if the bit of the mask are set
01455  **********************************************************/
01456 inline bool L6208::L6208_IsSysFlag(uint32_t mask)
01457 {
01458   return (bool)((devicePrm.flags & mask) == mask);    
01459 }
01460 
01461 /******************************************************//**
01462  * @brief Stepper driver device step state reset subroutine
01463  * @retval None
01464  **********************************************************/
01465 void L6208::L6208_ResetSteps(void)
01466 {
01467   devicePrm.speedSpt = 0;             // reset the current speed value
01468   devicePrm.ticks = 0;                // reset the current ticks counter value
01469   devicePrm.step = 0;                 // reset the current step counter value
01470   devicePrm.lsbOldTicks = 0;          // reset copy of the previous position (tick)
01471   devicePrm.lsbOldUSteppingTicks = 0; // reset copy of the previous position (tick) ( micro stepping )
01472   devicePrm.lsbTicks = 0;             // reset copy of the current position (tick)
01473   devicePrm.absolutePos = 0;          // reset the absolute motor position in step/microsteps
01474   devicePrm.uStepSample = 0;          // reset the microstepping waveform sample index
01475 }
01476 
01477 /******************************************************//**
01478  * @brief Compute the specified micro stepping waveform sample with the
01479  * current selected torque and pwm period
01480  * @param[in] sampleIndex sample Index
01481  * @retval scaled sample value
01482  **********************************************************/
01483 uint32_t L6208::L6208_ScaleWaveformSample(uint8_t sampleIndex)
01484 {
01485   uint32_t sample;
01486 
01487   sample = (uint32_t)RefMicroTable[sampleIndex];
01488   sample *= devicePrm.vrefPwmPeriod;
01489   sample >>= (uint32_t)L6208_SINE_WAVEFORM_POWER_OF_TWO_MAX_VALUE;
01490   
01491   sample *= (uint32_t)devicePrm.curTorqueScaler; // torque val (%)
01492   sample /= (uint32_t)100;
01493   
01494   return sample;
01495 }
01496 
01497 /******************************************************//**
01498  * @brief Compute the micro stepping waveform sample table samples with the
01499  * current selected torque and pwm period
01500  * @retval None
01501  **********************************************************/
01502 void L6208::L6208_ScaleWaveformTable(void)
01503 {
01504   uint8_t index;
01505   for(index=0; index<=L6208_USTEPS_PER_QUARTER_PERIOD; index++)
01506   { 
01507     /* Calculate the scaled sample and save its value into the waveform to update table */
01508     updatedMicroTable[index] = (uint16_t)L6208_ScaleWaveformSample(index);
01509   }
01510 }
01511 
01512 /******************************************************//**
01513  * @brief  Set the parameters of the device to values of the structure pointed
01514  * by pInitDevicePrm. Set GPIO according to these values.
01515  * @param pInitDevicePrm pointer onto the structure containing values to
01516  * initialize the device parameters.
01517  * @retval None
01518  **********************************************************/
01519 void L6208::L6208_SetDeviceParamsToGivenValues(l6208_Init_t* pInitDevicePrm)
01520 {
01521   memset(&devicePrm, 0, sizeof(devicePrm));
01522   L6208_SetAcceleration(pInitDevicePrm->accelerationSps2);
01523   L6208_SetDeceleration(pInitDevicePrm->decelerationSps2);
01524   L6208_SetMaxSpeed(pInitDevicePrm->maxSpeedSps);
01525   L6208_SetMinSpeed(L6208_MIN_SPEED);
01526   devicePrm.accelTorque = pInitDevicePrm->accelTorque;
01527   devicePrm.decelTorque = pInitDevicePrm->decelTorque;
01528   devicePrm.runTorque = pInitDevicePrm->runTorque;
01529   devicePrm.holdTorque = pInitDevicePrm->holdTorque;
01530   /* Only once acceleration, deceleration, min speed and max speed have been */
01531   /* initialized, set the step mode */
01532   devicePrm.stepMode = pInitDevicePrm->stepMode;
01533   L6208_SetDecayMode(pInitDevicePrm->decayMode);
01534   devicePrm.moveDwellTime = pInitDevicePrm->moveDwellTime;
01535   if (L6208_CONF_PARAM_AUTO_HIZ_STOP) L6208_SetSysFlag(pInitDevicePrm->autoHiZstop);
01536   devicePrm.vrefPwmFreq = pInitDevicePrm->vrefPwmFreq;
01537   devicePrm.vrefPwmPeriod = (uint16_t)((1000000<<8)/pInitDevicePrm->vrefPwmFreq);
01538   /* Initialize current stepper state machine index  */
01539   L6208_SetMotionState(INACTIVE);
01540 }
01541 
01542 /******************************************************//**
01543  * @brief  Set the parameters of the device to predefined values
01544  * Set GPIO according to these values
01545  * from l6208_target_config.h
01546  * @retval None
01547  **********************************************************/
01548 void L6208::L6208_SetDeviceParamsToPredefinedValues(void)
01549 {
01550   memset(&devicePrm, 0, sizeof(devicePrm));
01551   L6208_SetAcceleration(L6208_CONF_PARAM_ACC_RATE);
01552   L6208_SetDeceleration(L6208_CONF_PARAM_DEC_RATE);
01553   L6208_SetMaxSpeed(L6208_CONF_PARAM_RUNNING_SPEED);
01554   L6208_SetMinSpeed(L6208_MIN_SPEED);
01555   devicePrm.accelTorque = L6208_CONF_PARAM_ACC_CURRENT;
01556   devicePrm.decelTorque = L6208_CONF_PARAM_DEC_CURRENT;
01557   devicePrm.runTorque = L6208_CONF_PARAM_RUNNING_CURRENT;
01558   devicePrm.holdTorque = L6208_CONF_PARAM_HOLDING_CURRENT;
01559   /* Only once acceleration, deceleration, min speed and max speed have been */
01560   /* initialized, set the step mode */
01561   devicePrm.stepMode = (motorStepMode_t) L6208_CONF_PARAM_STEP_MODE;
01562   L6208_SetDecayMode(L6208_CONF_PARAM_DECAY_MODE);
01563   devicePrm.moveDwellTime = L6208_CONF_PARAM_DWELL_TIME;
01564   if (L6208_CONF_PARAM_AUTO_HIZ_STOP) L6208_SetSysFlag(HiZstop);
01565   devicePrm.vrefPwmFreq = L6208_CONF_VREF_PWM_FREQUENCY;
01566   devicePrm.vrefPwmPeriod = (uint16_t)((1000000<<8)/L6208_CONF_VREF_PWM_FREQUENCY);
01567   /* Initialize current stepper state machine index  */
01568   L6208_SetMotionState(INACTIVE);
01569 }
01570 
01571 /******************************************************//**
01572  * @brief Set the number of micro stepping waveform samples to rescale
01573  * @param[in] value number of micro stepping waveform samples 
01574  * @retval None
01575  **********************************************************/
01576 void L6208::L6208_SetMicrostepSample2Scale(uint8_t value)
01577 {
01578   if(value > L6208_USTEPS_PER_QUARTER_PERIOD)
01579   {
01580     value = L6208_USTEPS_PER_QUARTER_PERIOD;  // clamp to maximum number of samples per period/4
01581   }
01582   devicePrm.uStepsample2scale = value;    
01583 }
01584 
01585 /******************************************************//**
01586  * @brief Set the number of micro stepping waveform samples to update into scanning
01587  * @param[in] value number of micro stepping waveform samples 
01588  * @retval None
01589  **********************************************************/
01590 void L6208::L6208_SetMicrostepSample2Update(uint8_t value)
01591 {
01592   // clamp to maximum number of samples per period/4
01593   if(value > L6208_USTEPS_PER_QUARTER_PERIOD)
01594   {
01595     value = L6208_USTEPS_PER_QUARTER_PERIOD;  
01596   }
01597   // copy the stepper acceleration rate
01598   devicePrm.uStepsample2update = value;    
01599 }
01600 
01601 /******************************************************//**
01602  * @brief Set the stepper state machine index
01603  * @param[in] newMotionState
01604  * @retval None
01605  **********************************************************/
01606 void L6208::L6208_SetMotionState(motorState_t newMotionState)
01607 {
01608   // sets the new stepper state machine index
01609   devicePrm.motionState = newMotionState;    
01610 }
01611 
01612 /******************************************************//**
01613  * @brief Set the user selected speed in step/tick
01614  * @param[in] newSpeed speed value (step/s)
01615  * @param[in] pSpeed pointer to the selected speed field
01616  * @retval return FALSE if the speed is too low or too high
01617  * or if the device is running in position mode, else TRUE
01618  **********************************************************/
01619 bool L6208::L6208_SetSpeed(uint16_t newSpeed, uint32_t volatile *pSpeed)
01620 {
01621   uint64_t tmp64;
01622   uint32_t tmp32;
01623 
01624   if (((L6208_IsSysFlag(running))&&(L6208_IsSysFlag(positionmode)))||\
01625       (newSpeed < L6208_MIN_SPEED))
01626   {
01627     return FALSE;
01628   }
01629   tmp32 = (uint32_t)L6208_Board_TickGetFreq();
01630   if (tmp32 < newSpeed)
01631   {
01632     return FALSE;
01633   }
01634   /* Compute the decimal number of microstep or step per tick */
01635   /* Decimal part is on 32 bits */
01636   tmp64 = (uint64_t)newSpeed << 32;
01637   tmp64 /= ((uint64_t)tmp32);
01638   /* set the running constant speed value (step/tick) */
01639   *pSpeed = (uint32_t)((tmp64 & 0x00000000FFFFFFFF)>>8);
01640   
01641   return TRUE;
01642 }
01643 
01644 /******************************************************//**
01645  * @brief Set the bit/s of flags according to the specified mask
01646  * @param[in] mask flag bit mask
01647  * @retval None
01648  **********************************************************/
01649 inline void L6208::L6208_SetSysFlag(uint32_t mask)
01650 {
01651   devicePrm.flags |= mask;    
01652 }
01653 
01654 /******************************************************//**
01655  * @brief Stepper motor start command
01656  * @retval true on correct command execution
01657  **********************************************************/
01658 bool L6208::L6208_StartMovement(void)
01659 {
01660   uint32_t tmp;
01661   if (L6208_IsSysFlag(running))
01662   {
01663     /* Motor is already running ==> quit */
01664     return FALSE;    
01665   }
01666   if (!L6208_IsSysFlag(positionmode))
01667   {
01668     /* Set the VREFA and VREFB to the selected acc. torque */
01669     L6208_VectorCalc(devicePrm.accelTorque);
01670     
01671     /* If the speed control mode is selected */
01672     /* setup the motor acceleration for velocity mode driving */
01673     L6208_SetMotionState(ACCELERATING);  
01674   }
01675   else
01676   {  
01677     /* if position control mode is selected, reset the current step counter  */
01678     devicePrm.step = 0;    
01679     if(devicePrm.uStepSample > 31)
01680     {
01681       /* check the micro stepping waveform sample index */
01682       devicePrm.uStepSample = 0;
01683     }
01684     /* Set the position dwelling wait time */
01685     /* compute number of ticks per millisecond */
01686     tmp = (uint32_t)L6208_Board_TickGetFreq() / 1000;
01687     /* Compute the dwelling time in ticks => dwellCounter (ticks) */
01688     devicePrm.dwellCounter = tmp * (uint32_t)devicePrm.moveDwellTime;
01689     if (devicePrm.positionTarget == 0)
01690     {
01691       /* if the position to go is 0 (no move) */
01692       /* Set the deceleration torque */
01693       L6208_VectorCalc(devicePrm.decelTorque); 
01694       /* Set the dwelling delay state index */
01695       L6208_SetMotionState(INDEX_DWELL);       
01696     }
01697     else
01698     {
01699       /* Set the VREFA and VREFB to the selected acc. torque */
01700       L6208_VectorCalc(devicePrm.accelTorque);
01701       /* go to the selected position */
01702       L6208_Indexmodeinit();
01703       L6208_SetMotionState(INDEX_ACCEL);
01704     }
01705   }
01706   /* Sets the motor running flag */
01707   L6208_SetSysFlag(running);
01708   /* Start the VREFA and VREFB PWMs */
01709   L6208_Board_VrefPwmStart(BRIDGE_A, devicePrm.vrefPwmPeriod);
01710   L6208_Board_VrefPwmStart(BRIDGE_B, devicePrm.vrefPwmPeriod);
01711   if (!(L6208_IsSysFlag(EN_A_set)))
01712   {
01713     /* Enable power bridges */
01714     L6208_Enable();
01715   }
01716   /* Start the tick */
01717   L6208_Board_TickStart(L6208::tickFreq);
01718   
01719   return TRUE;
01720 }
01721 
01722 /******************************************************//**
01723  * @brief Update the micro stepping waveform samples table with the
01724  * values previously scaled with current selected torque and tick period
01725  * @retval None
01726  **********************************************************/
01727 void L6208::L6208_UpdateScanWaveformTable(void)
01728 {
01729   uint8_t index;
01730 
01731   for(index=0; index<=L6208_USTEPS_PER_QUARTER_PERIOD; index++)
01732   {
01733     microTable1[index] = updatedMicroTable[index];
01734     microTable1[L6208_USTEPS_PER_QUARTER_PERIOD*2 - index] = microTable1[index];
01735     microTable1[index + L6208_USTEPS_PER_QUARTER_PERIOD*2] = updatedMicroTable[index];
01736   }
01737   /* clear the number of samples to update */
01738   L6208_SetMicrostepSample2Update(0); 
01739 }
01740 
01741 /******************************************************//**
01742  * @brief Check if there are waveform samples to rescale and if so, perform the rescaling
01743  * @retval None
01744  **********************************************************/
01745 void L6208::L6208_UstepWaveformHandling(void)
01746 {
01747   /* micro stepper waveform samples rescaling ... and updating */
01748   uint8_t nbSamplesToRescale = L6208_GetMicrostepSample2Scale();
01749   if(nbSamplesToRescale > 0)
01750   { 
01751     /* Current torque value has been changed, so recalculate the waveform table */
01752     L6208_ScaleWaveformTable();
01753     
01754     /* Set the number of samples to update */
01755     L6208_SetMicrostepSample2Update(L6208_USTEPS_PER_QUARTER_PERIOD);
01756 
01757     /* Reset the number of samples to rescaled afer rescaling */
01758     L6208_SetMicrostepSample2Scale(0);
01759   }
01760 }
01761 
01762 /******************************************************//**
01763  * @brief Set the current torque value (Vref)
01764  * @param[in] newTorque Selected torque value
01765  * @retval always TRUE
01766  **********************************************************/
01767 bool L6208::L6208_VectorCalc(uint8_t newTorque)
01768 {
01769   /* save current selected torque value */
01770   devicePrm.curTorqueScaler = (uint16_t)newTorque;
01771 
01772   if(!L6208_IsSysFlag(microstep))
01773   {
01774     /* full/half step mode or the motor is not running */
01775     /* set the PWM duty cycle according to the current torque value (%). */
01776     /* The TON value will be calculated inside the TIMx_PWM_duty_setup f(). */
01777     L6208_VrefPwmComputePulseWidth(BRIDGE_A, devicePrm.curTorqueScaler, TRUE);
01778     L6208_VrefPwmComputePulseWidth(BRIDGE_B, devicePrm.curTorqueScaler, TRUE);
01779     devicePrm.vRefAVal = devicePrm.curTorqueScaler; // save current VREFA value
01780     devicePrm.vRefBVal = devicePrm.curTorqueScaler; // save current VREFB value
01781   }
01782   else
01783   { 
01784     /* microstep mode */
01785     if(L6208_IsSysFlag(running))
01786     {
01787       /* set the number of waveform sample to rescale according current selected */
01788       /* torque value */
01789       L6208_SetMicrostepSample2Scale(L6208_USTEPS_PER_QUARTER_PERIOD);
01790     }
01791     else
01792     { 
01793       /* micro stepping mode motor stopped */
01794       L6208_ScaleWaveformTable();
01795       L6208_UpdateScanWaveformTable();
01796       /* Set the VREF timer PWM TON to update VREFA and VREFB */
01797       L6208_VrefPwmComputePulseWidth(BRIDGE_A, pMicroTable2[devicePrm.uStepSample], FALSE);      
01798       L6208_VrefPwmComputePulseWidth(BRIDGE_B, microTable1[devicePrm.uStepSample], FALSE);
01799     }
01800   }
01801   return TRUE;
01802 }
01803 
01804 /******************************************************//**
01805  * @brief Compute the pulse width of VREFA or VREFB PWM
01806  * @param[in] bridgeId
01807  *            0 for BRIDGE_A
01808  *            1 for BRIDGE_B
01809  * @param[in] value pulse length in 1/256th of microsecond
01810  * or PWM duty cycle: 0 - 100 %
01811  * @param[in] valueIsPwmDutyCycle must be TRUE if value is a PWM duty cycle
01812  * @retval FALSE if wrong timer handle is used, else TRUE
01813  **********************************************************/
01814 bool L6208::L6208_VrefPwmComputePulseWidth(uint8_t bridgeId, uint16_t value, bool valueIsPwmDutyCycle)
01815 {
01816   if(valueIsPwmDutyCycle)
01817   {
01818     if (value > 100) value = 100;
01819     value = (uint16_t)(((uint32_t)devicePrm.vrefPwmPeriod * (uint32_t)value) / 100); 
01820   }
01821   if (bridgeId == 0)
01822   {
01823     devicePrm.vrefPwmPulseWidthTargetA = value;
01824     devicePrm.vrefPwmPulseWidthToBeGeneratedA = 0;
01825   } 
01826   else if (bridgeId == 1)
01827   {
01828     devicePrm.vrefPwmPulseWidthTargetB = value;
01829     devicePrm.vrefPwmPulseWidthToBeGeneratedB = 0;
01830   }
01831   else
01832   {
01833     return FALSE;
01834   }
01835   return TRUE;
01836 }
01837 
01838 /******************************************************//**
01839  * @brief Update the pulse width of VREFA or VREFB PWM
01840  * @param None
01841  * @retval None
01842  **********************************************************/
01843 void L6208::L6208_VrefPwmUpdatePulseWidth(void)
01844 {
01845   uint16_t pulseWidthUs;
01846   
01847   devicePrm.vrefPwmPulseWidthToBeGeneratedA += devicePrm.vrefPwmPulseWidthTargetA;
01848   pulseWidthUs = devicePrm.vrefPwmPulseWidthToBeGeneratedA>>8;
01849   if (pulseWidthUs!=0)
01850   {
01851     L6208_Board_VrefPwmSetPulseWidthA(pulseWidthUs);
01852     devicePrm.vrefPwmPulseWidthToBeGeneratedA -= (pulseWidthUs<<8);
01853   }
01854   else
01855   {
01856     L6208_Board_VrefPwmSetPulseWidthA(0);
01857   }
01858   
01859   devicePrm.vrefPwmPulseWidthToBeGeneratedB += devicePrm.vrefPwmPulseWidthTargetB;
01860   pulseWidthUs = devicePrm.vrefPwmPulseWidthToBeGeneratedB>>8;
01861   if (pulseWidthUs!=0)
01862   {
01863     L6208_Board_VrefPwmSetPulseWidthB(pulseWidthUs);
01864     devicePrm.vrefPwmPulseWidthToBeGeneratedB -= (pulseWidthUs<<8);
01865   }
01866   else
01867   {
01868     L6208_Board_VrefPwmSetPulseWidthB(0);
01869   }
01870 }
01871 
01872 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/