Davide Aliprandi
/
X-NUCLEO-IHM05A1
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
X-NUCLEO-IHM05A1
by 
ST
Embed:
(wiki syntax)
Show/hide line numbers
l6208_class.h
Go to the documentation of this file.
00001 /** 00002 ****************************************************************************** 00003 * @file l6208_class.h 00004 * @author IPC Rennes 00005 * @version V1.0.0 00006 * @date March 18th, 2016 00007 * @brief This file contains the class of a L6208 Motor Control component. 00008 * @note (C) COPYRIGHT 2016 STMicroelectronics 00009 ****************************************************************************** 00010 * @attention 00011 * 00012 * <h2><center>© 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 00040 /* Define to prevent recursive inclusion -------------------------------------*/ 00041 00042 #ifndef __L6208_CLASS_H 00043 #define __L6208_CLASS_H 00044 00045 00046 /* Includes ------------------------------------------------------------------*/ 00047 00048 /* ACTION 1 ------------------------------------------------------------------* 00049 * Include here platform specific header files. * 00050 *----------------------------------------------------------------------------*/ 00051 #include "mbed.h" 00052 00053 /* ACTION 2 ------------------------------------------------------------------* 00054 * Include here component specific header files. * 00055 *----------------------------------------------------------------------------*/ 00056 #include "l6208.h" 00057 /* ACTION 3 ------------------------------------------------------------------* 00058 * Include here interface specific header files. * 00059 * * 00060 * Example: * 00061 * #include "Humidity_class.h" * 00062 * #include "Temperature_class.h" * 00063 *----------------------------------------------------------------------------*/ 00064 #include "StepperMotor.h" 00065 00066 00067 /* Classes -------------------------------------------------------------------*/ 00068 00069 /** 00070 * @brief Class representing a L6208 component. 00071 */ 00072 class L6208 : public StepperMotor 00073 { 00074 public: 00075 /*** Constructor and Destructor Methods ***/ 00076 00077 /** 00078 * @brief Constructor. 00079 * @param flag_and_enable_pin pin name of the EN pin of the component. 00080 * @param reset_pin pin name of the RESET pin of the component. 00081 * @param direction_pin pin name of the CW_CCW pin of the component. 00082 * @param half_full_pin pin name of the HALF_FULL pin of the component. 00083 * @param control_pin pin name of the CONTROL pin of the component. 00084 * @param clock_pin pin name of the CLOCK pin of the component. 00085 * @param vrefA_pwm_pin pin name of the PWM connected to the VREFA pin of the component. 00086 * @param vrefB_pwm_pin pin name of the PWM connected to the VREFB pin of the component. 00087 */ 00088 L6208(PinName flag_and_enable_pin, PinName reset_pin, PinName direction_pin, PinName half_full_pin, PinName control_pin, PinName clock_pin, PinName vrefA_pwm_pin, PinName vrefB_pwm_pin) : StepperMotor(), 00089 flag_and_enable(flag_and_enable_pin), 00090 reset(reset_pin), 00091 direction(direction_pin), 00092 half_full(half_full_pin), 00093 control(control_pin), 00094 clock(clock_pin), 00095 vrefA_pwm(vrefA_pwm_pin), 00096 vrefB_pwm(vrefB_pwm_pin) 00097 { 00098 /* Checking stackability. */ 00099 if (numberOfDevices!=0) 00100 error("Instantiation of the L6208 component failed: it can't be stacked on itself.\r\n"); 00101 00102 /* ACTION 4 ----------------------------------------------------------* 00103 * Initialize here the component's member variables, one variable per * 00104 * line. * 00105 * * 00106 * Example: * 00107 * measure = 0; * 00108 * instance_id = number_of_instances++; * 00109 *--------------------------------------------------------------------*/ 00110 errorHandlerCallback = 0; 00111 deviceInstance = numberOfDevices++; 00112 /* default tick frequency */ 00113 tickFreq = TIMER_TICK_FREQUENCY; 00114 /* waveform microstepping PWM period sample array, 90 deg shifted */ 00115 pMicroTable2 = &(microTable1[16]); 00116 } 00117 00118 /** 00119 * @brief Destructor. 00120 */ 00121 virtual ~L6208(void) {} 00122 00123 00124 /*** Public Component Related Methods ***/ 00125 00126 /* ACTION 5 --------------------------------------------------------------* 00127 * Implement here the component's public methods, as wrappers of the C * 00128 * component's functions. * 00129 * They should be: * 00130 * + Methods with the same name of the C component's virtual table's * 00131 * functions (1); * 00132 * + Methods with the same name of the C component's extended virtual * 00133 * table's functions, if any (2). * 00134 * * 00135 * Example: * 00136 * virtual int GetValue(float *pData) //(1) * 00137 * { * 00138 * return COMPONENT_GetValue(float *pfData); * 00139 * } * 00140 * * 00141 * virtual int EnableFeature(void) //(2) * 00142 * { * 00143 * return COMPONENT_EnableFeature(); * 00144 * } * 00145 *------------------------------------------------------------------------*/ 00146 00147 /** 00148 * @brief Public functions inherited from the Component Class 00149 */ 00150 00151 /** 00152 * @brief Initialize the component. 00153 * @param init Pointer to device specific initalization structure. 00154 * @retval "0" in case of success, an error code otherwise. 00155 */ 00156 virtual int Init(void *init = NULL) 00157 { 00158 return (int) L6208_Init((void *) init); 00159 } 00160 00161 /** 00162 * @brief Getting the ID of the component. 00163 * @param id Pointer to an allocated variable to store the ID into. 00164 * @retval "0" in case of success, an error code otherwise. 00165 */ 00166 virtual int ReadID(uint8_t *id = NULL) 00167 { 00168 return (int) L6208_ReadID((uint8_t *) id); 00169 } 00170 00171 /** 00172 * @brief Public functions inherited from the StepperMotor Class 00173 */ 00174 00175 /** 00176 * @brief Getting the value of the motor state . 00177 * @param None. 00178 * @retval The motor state accoring to motorState_t in motor.h 00179 */ 00180 virtual unsigned int GetStatus(void) 00181 { 00182 return (unsigned int) L6208_GetMotionState(); 00183 } 00184 00185 /** 00186 * @brief Getting the position. 00187 * @param None. 00188 * @retval The position. 00189 */ 00190 virtual signed int GetPosition(void) 00191 { 00192 return (signed int)L6208_GetPosition(); 00193 } 00194 00195 /** 00196 * @brief Getting the marked position. 00197 * @param None. 00198 * @retval The marked position. 00199 */ 00200 virtual signed int GetMark(void) 00201 { 00202 return (signed int)L6208_GetMark(); 00203 } 00204 00205 /** 00206 * @brief Getting the current speed in pps. 00207 * @param None. 00208 * @retval The current speed in pps. 00209 */ 00210 virtual unsigned int GetSpeed(void) 00211 { 00212 return (unsigned int)L6208_GetCurrentSpeed(); 00213 } 00214 00215 /** 00216 * @brief Getting the maximum speed in pps. 00217 * @param None. 00218 * @retval The maximum speed in pps. 00219 */ 00220 virtual unsigned int GetMaxSpeed(void) 00221 { 00222 return (unsigned int)L6208_GetMaxSpeed(); 00223 } 00224 00225 /** 00226 * @brief Getting the minimum speed in pps. 00227 * @param None. 00228 * @retval The minimum speed in pps. 00229 */ 00230 virtual unsigned int GetMinSpeed(void) 00231 { 00232 return (unsigned int)L6208_GetMinSpeed(); 00233 } 00234 00235 /** 00236 * @brief Getting the acceleration in pps^2. 00237 * @param None. 00238 * @retval The acceleration in pps^2. 00239 */ 00240 virtual unsigned int GetAcceleration(void) 00241 { 00242 return (unsigned int)L6208_GetAcceleration(); 00243 } 00244 00245 /** 00246 * @brief Getting the deceleration in pps^2. 00247 * @param None. 00248 * @retval The deceleration in pps^2. 00249 */ 00250 virtual unsigned int GetDeceleration(void) 00251 { 00252 return (unsigned int)L6208_GetDeceleration(); 00253 } 00254 00255 /** 00256 * @brief Getting the direction of rotation. 00257 * @param None. 00258 * @retval The direction of rotation. 00259 */ 00260 virtual direction_t GetDirection(void) 00261 { 00262 if (L6208_GetDirection()!=BACKWARD) 00263 { 00264 return FWD; 00265 } 00266 else 00267 { 00268 return BWD; 00269 } 00270 } 00271 00272 /** 00273 * @brief Setting the current position to be the home position. 00274 * @param None. 00275 * @retval None. 00276 */ 00277 virtual void SetHome(void) 00278 { 00279 L6208_SetHome(); 00280 } 00281 00282 /** 00283 * @brief Setting the current position to be the marked position. 00284 * @param None. 00285 * @retval None. 00286 */ 00287 virtual void SetMark(void) 00288 { 00289 L6208_SetMark(); 00290 } 00291 00292 /** 00293 * @brief Setting the maximum speed in pps. 00294 * @param speed The maximum speed in pps. 00295 * @retval "true" in case of success, "false" otherwise. 00296 */ 00297 virtual bool SetMaxSpeed(unsigned int speed) 00298 { 00299 if (speed <= 0xFFFF) 00300 { 00301 return L6208_SetMaxSpeed((uint16_t) speed); 00302 } 00303 else 00304 { 00305 return false; 00306 } 00307 } 00308 00309 /** 00310 * @brief Setting the minimum speed in pps. 00311 * @param speed The minimum speed in pps. 00312 * @retval "true" in case of success, "false" otherwise. 00313 */ 00314 virtual bool SetMinSpeed(unsigned int speed) 00315 { 00316 if (speed <= 0xFFFF) 00317 { 00318 return L6208_SetMinSpeed((uint16_t) speed); 00319 } 00320 else 00321 { 00322 return false; 00323 } 00324 } 00325 00326 /** 00327 * @brief Setting the acceleration in pps^2. 00328 * @param acceleration The acceleration in pps/s^2. 00329 * @retval "true" in case of success, "false" otherwise. 00330 */ 00331 virtual bool SetAcceleration(unsigned int acceleration) 00332 { 00333 if (acceleration <= 0xFFFF) 00334 { 00335 return L6208_SetAcceleration((uint16_t) acceleration); 00336 } 00337 else 00338 { 00339 return false; 00340 } 00341 } 00342 00343 /** 00344 * @brief Setting the deceleration in pps^2. 00345 * @param deceleration The deceleration in pps^2. 00346 * @retval "true" in case of success, "false" otherwise. 00347 */ 00348 virtual bool SetDeceleration(unsigned int deceleration) 00349 { 00350 if (deceleration <= 0xFFFF) 00351 { 00352 return L6208_SetDeceleration((uint16_t) deceleration); 00353 } 00354 else 00355 { 00356 return false; 00357 } 00358 } 00359 00360 /** 00361 * @brief Setting the Step Mode. 00362 * @param step_mode The Step Mode. 00363 * @retval "true" in case of success, "false" otherwise. 00364 * @note step_mode can be one of the following: 00365 * + STEP_MODE_FULL 00366 * + STEP_MODE_WAVE 00367 * + STEP_MODE_HALF 00368 * + STEP_MODE_1_4 00369 * + STEP_MODE_1_8 00370 * + STEP_MODE_1_16 00371 */ 00372 virtual bool SetStepMode(step_mode_t step_mode) 00373 { 00374 return L6208_SetStepMode((motorStepMode_t) step_mode); 00375 } 00376 00377 /** 00378 * @brief Going to a specified position. 00379 * @param position The desired position. 00380 * @retval None. 00381 */ 00382 virtual void GoTo(signed int position) 00383 { 00384 L6208_GoTo((int32_t)position); 00385 } 00386 00387 /** 00388 * @brief Going to the home position. 00389 * @param None. 00390 * @retval None. 00391 */ 00392 virtual void GoHome(void) 00393 { 00394 L6208_GoHome(); 00395 } 00396 00397 /** 00398 * @brief Going to the marked position. 00399 * @param None. 00400 * @retval None. 00401 */ 00402 virtual void GoMark(void) 00403 { 00404 L6208_GoMark(); 00405 } 00406 00407 /** 00408 * @brief Running the motor towards a specified direction. 00409 * @param direction The direction of rotation. 00410 * @retval None. 00411 */ 00412 virtual void Run(direction_t direction) 00413 { 00414 L6208_Run((motorDir_t) (direction == StepperMotor::FWD ? FORWARD : BACKWARD)); 00415 } 00416 00417 /** 00418 * @brief Moving the motor towards a specified direction for a certain number of steps. 00419 * @param direction The direction of rotation. 00420 * @param steps The desired number of steps. 00421 * @retval None. 00422 */ 00423 virtual void Move(direction_t direction, unsigned int steps) 00424 { 00425 L6208_Move((motorDir_t) (direction == StepperMotor::FWD ? FORWARD : BACKWARD), (uint32_t)steps); 00426 } 00427 00428 /** 00429 * @brief Stopping the motor through an immediate deceleration up to zero speed. 00430 * @param None. 00431 * @retval None. 00432 */ 00433 virtual void SoftStop(void) 00434 { 00435 L6208_SoftStop(); 00436 } 00437 00438 /** 00439 * @brief Stopping the motor through an immediate infinite deceleration. 00440 * @param None. 00441 * @retval None. 00442 */ 00443 virtual void HardStop(void) 00444 { 00445 L6208_HardStop(); 00446 } 00447 00448 /** 00449 * @brief Disabling the power bridge after performing a deceleration to zero. 00450 * @param None. 00451 * @retval None. 00452 */ 00453 virtual void SoftHiZ(void) 00454 { 00455 motorStopMode_t stopMode = L6208_GetStopMode(); 00456 if (stopMode==HIZ_MODE) 00457 { 00458 L6208_SoftStop(); 00459 } 00460 else 00461 { 00462 L6208_SetStopMode(HIZ_MODE); 00463 L6208_SoftStop(); 00464 L6208_SetStopMode(stopMode); 00465 } 00466 } 00467 00468 /** 00469 * @brief Disabling the power bridge immediately. 00470 * @param None. 00471 * @retval None. 00472 */ 00473 virtual void HardHiZ(void) 00474 { 00475 L6208_HardHiZ(); 00476 } 00477 00478 /** 00479 * @brief Waiting while the motor is active. 00480 * @param None. 00481 * @retval None. 00482 */ 00483 virtual void WaitWhileActive(void) 00484 { 00485 L6208_WaitWhileActive(); 00486 } 00487 00488 /** 00489 * @brief Public functions NOT inherited 00490 */ 00491 00492 /** 00493 * @brief Attaching an error handler. 00494 * @param fptr An error handler. 00495 * @retval None. 00496 */ 00497 virtual void AttachErrorHandler(void (*fptr)(uint16_t error)) 00498 { 00499 L6208_AttachErrorHandler((void (*)(uint16_t error)) fptr); 00500 } 00501 00502 /** 00503 * @brief Checks if the device is disabled or/and has an alarm flag set 00504 * by reading the EN pin position. 00505 * @param None. 00506 * @retval One if the EN pin is low (the device is disabled or/and 00507 * has an alarm flag set), otherwise zero. 00508 */ 00509 virtual unsigned int CheckStatusHw(void) 00510 { 00511 if (!flag_and_enable.read()) return 0x01; 00512 else return 0x00; 00513 } 00514 00515 /** 00516 * @brief Disabling the device. 00517 * @param None. 00518 * @retval None. 00519 */ 00520 virtual void Disable(void) 00521 { 00522 L6208_Disable(); 00523 } 00524 00525 /** 00526 * @brief Enabling the device. 00527 * @param None. 00528 * @retval None. 00529 */ 00530 virtual void Enable(void) 00531 { 00532 L6208_Enable(); 00533 } 00534 00535 /** 00536 * @brief Getting the motor decay mode. 00537 * @param None. 00538 * @retval The motor decay mode. 00539 */ 00540 virtual motorDecayMode_t GetDecayMode() 00541 { 00542 return L6208_GetDecayMode(); 00543 } 00544 00545 /** 00546 * @brief Set the frequency of the VREFA and VREFB PWM 00547 * @param frequency in Hz 00548 * @retval None. 00549 */ 00550 virtual uint32_t GetFreqVrefPwm(void) 00551 { 00552 return L6208_VrefPwmGetFreq(); 00553 } 00554 00555 /** 00556 * @brief Getting the version of the firmware. 00557 * @param None. 00558 * @retval The version of the firmware. 00559 */ 00560 virtual unsigned int GetFwVersion(void) 00561 { 00562 return (unsigned int) L6208_GetFwVersion(); 00563 } 00564 00565 /** 00566 * @brief Getting the motor step mode. 00567 * @param None. 00568 * @retval The motor step mode. 00569 */ 00570 virtual step_mode_t GetStepMode(void) 00571 { 00572 return (step_mode_t) L6208_GetStepMode(); 00573 } 00574 00575 /** 00576 * @brief Getting the motor stop mode. 00577 * @param None. 00578 * @retval The motor stop mode. 00579 */ 00580 virtual motorStopMode_t GetStopMode(void) 00581 { 00582 return L6208_GetStopMode(); 00583 } 00584 00585 /** 00586 * @brief Going to a specified position with a specificied direction. 00587 * @param direction The desired direction. 00588 * @param position The desired position. 00589 * @retval None. 00590 */ 00591 virtual void GoTo(direction_t direction, signed int position) 00592 { 00593 L6208_GoToDir((motorDir_t) (direction == StepperMotor::FWD ? FORWARD : BACKWARD),(int32_t)position); 00594 } 00595 00596 /** 00597 * @brief Release the L6208 reset (Reset pin set to high level). 00598 * @param None. 00599 * @retval None. 00600 */ 00601 virtual void ReleaseReset(void) 00602 { 00603 L6208_ReleaseReset(); 00604 } 00605 00606 /** 00607 * @brief Reset the device with current step mode, resets current speed, 00608 * positions and microstep variables. 00609 * @param None. 00610 * @retval None. 00611 */ 00612 virtual void Reset(void) 00613 { 00614 L6208_Reset(); 00615 } 00616 00617 /** 00618 * @brief Reset the L6208 (Reset pin set to low level). 00619 * @param None. 00620 * @retval None. 00621 */ 00622 virtual void ResetDevice(void) 00623 { 00624 L6208_ResetDevice(); 00625 } 00626 00627 /** 00628 * @brief Set the motor decay mode. 00629 * @param decayMode The desired decay mode (SLOW_DECAY or FAST_DECAY). 00630 * @retval None. 00631 */ 00632 virtual void SetDecayMode(motorDecayMode_t decayMode) 00633 { 00634 L6208_SetDecayMode(decayMode); 00635 } 00636 00637 /** 00638 * @brief Set the motor direction. 00639 * @param direction The desired direction. 00640 * @retval None. 00641 */ 00642 virtual void SetDirection(direction_t direction) 00643 { 00644 L6208_SetDirection((motorDir_t) (direction == StepperMotor::FWD ? FORWARD : BACKWARD)); 00645 } 00646 00647 /** 00648 * @brief Set the frequency of the VREFA and VREFB PWM 00649 * @param frequency in Hz 00650 * @retval None. 00651 */ 00652 virtual void SetFreqVrefPwm(uint32_t frequency) 00653 { 00654 L6208_VrefPwmSetFreq(frequency); 00655 } 00656 00657 /** 00658 * @brief Set the motor stop mode. 00659 * @param stopMode The desired stop mode (HOLD_MODE or HIZ_MODE). 00660 * @retval None. 00661 */ 00662 virtual void SetStopMode(motorStopMode_t stopMode) 00663 { 00664 L6208_SetStopMode(stopMode); 00665 } 00666 00667 /*** Public Interrupt Related Methods ***/ 00668 00669 /* ACTION 6 --------------------------------------------------------------* 00670 * Implement here interrupt related methods, if any. * 00671 * Note that interrupt handling is platform dependent, e.g.: * 00672 * + mbed: * 00673 * InterruptIn feature_irq(pin); //Interrupt object. * 00674 * feature_irq.rise(callback); //Attach a callback. * 00675 * feature_irq.mode(PullNone); //Set interrupt mode. * 00676 * feature_irq.enable_irq(); //Enable interrupt. * 00677 * feature_irq.disable_irq(); //Disable interrupt. * 00678 * + Arduino: * 00679 * attachInterrupt(pin, callback, RISING); //Attach a callback. * 00680 * detachInterrupt(pin); //Detach a callback. * 00681 * * 00682 * Example (mbed): * 00683 * void AttachFeatureIRQ(void (*fptr) (void)) * 00684 * { * 00685 * feature_irq.rise(fptr); * 00686 * } * 00687 * * 00688 * void EnableFeatureIRQ(void) * 00689 * { * 00690 * feature_irq.enable_irq(); * 00691 * } * 00692 * * 00693 * void DisableFeatureIRQ(void) * 00694 * { * 00695 * feature_irq.disable_irq(); * 00696 * } * 00697 *------------------------------------------------------------------------*/ 00698 /** 00699 * @brief Attaching an interrupt handler to the FLAG interrupt. 00700 * @param fptr An interrupt handler. 00701 * @retval None. 00702 */ 00703 00704 void AttachFlagIRQ(void (*fptr)(void)) 00705 { 00706 flag_and_enable.mode(PullDown); 00707 flag_and_enable.fall(fptr); 00708 } 00709 00710 /** 00711 * @brief Enabling the FLAG interrupt handling. 00712 * @param None. 00713 * @retval None. 00714 */ 00715 void EnableFlagIRQ(void) 00716 { 00717 flag_and_enable.enable_irq(); 00718 } 00719 00720 protected: 00721 00722 /*** Protected Component Related Methods ***/ 00723 00724 /* ACTION 7 --------------------------------------------------------------* 00725 * Declare here the component's specific methods. * 00726 * They should be: * 00727 * + Methods with the same name of the C component's virtual table's * 00728 * functions (1); * 00729 * + Methods with the same name of the C component's extended virtual * 00730 * table's functions, if any (2); * 00731 * + Helper methods, if any, like functions declared in the component's * 00732 * source files but not pointed by the component's virtual table (3). * 00733 * * 00734 * Example: * 00735 * Status_t COMPONENT_GetValue(float *f); //(1) * 00736 * Status_t COMPONENT_EnableFeature(void); //(2) * 00737 * Status_t COMPONENT_ComputeAverage(void); //(3) * 00738 *------------------------------------------------------------------------*/ 00739 Status_t L6208_Init(void *init); 00740 Status_t L6208_ReadID(uint8_t *id); 00741 void L6208_AttachErrorHandler(void (*callback)(uint16_t error)); 00742 void L6208_Disable(void); 00743 void L6208_ErrorHandler(uint16_t error); 00744 void L6208_Enable(void); 00745 uint16_t L6208_GetAcceleration(void); 00746 uint16_t L6208_GetCurrentSpeed(void); 00747 uint16_t L6208_GetDeceleration(void); 00748 motorDecayMode_t L6208_GetDecayMode(void); 00749 motorDir_t L6208_GetDirection(void); 00750 uint32_t L6208_GetFwVersion(void); 00751 int32_t L6208_GetMark(void); 00752 uint16_t L6208_GetMaxSpeed(void); 00753 uint16_t L6208_GetMinSpeed(void); 00754 motorState_t L6208_GetMotionState(void); 00755 int32_t L6208_GetPosition(void); 00756 motorStepMode_t L6208_GetStepMode(void); 00757 motorStopMode_t L6208_GetStopMode(void); 00758 void L6208_GoHome(void); 00759 void L6208_GoMark(void); 00760 void L6208_GoTo(int32_t targetPosition); 00761 void L6208_GoToDir(motorDir_t direction, int32_t targetPosition); 00762 void L6208_HardHiZ(void); 00763 void L6208_HardStop(void); 00764 void L6208_Move(motorDir_t direction, uint32_t stepCount); 00765 void L6208_ReleaseReset(void); 00766 void L6208_Reset(void); 00767 void L6208_ResetDevice(void); 00768 void L6208_Run(motorDir_t direction); 00769 bool L6208_SetAcceleration(uint16_t newAcc); 00770 void L6208_SetDecayMode(motorDecayMode_t decayMode); 00771 bool L6208_SetDeceleration(uint16_t newDec); 00772 void L6208_SetDirection(motorDir_t direction); 00773 void L6208_SetHome(void); 00774 void L6208_SetMark(void); 00775 bool L6208_SetMaxSpeed(uint16_t volatile newSpeed); 00776 bool L6208_SetMinSpeed(uint16_t volatile newSpeed); 00777 bool L6208_SetStepMode(motorStepMode_t stepMode); 00778 void L6208_SetStopMode(motorStopMode_t stopMode); 00779 bool L6208_SoftStop(void); 00780 void L6208_TickHandler(void); 00781 uint32_t L6208_VrefPwmGetFreq(void); 00782 void L6208_VrefPwmSetFreq(uint32_t newFreq); 00783 void L6208_WaitWhileActive(void); 00784 00785 /*** Functions intended to be used only internally ***/ 00786 00787 void L6208_ClearSysFlag(uint32_t mask); 00788 uint32_t L6208_ComputeNbAccOrDecSteps(uint16_t accOrDecRate); 00789 uint16_t L6208_ConvertAcceDecelRateValue(uint16_t newAccOrDecRate); 00790 void L6208_DoAccel(void); 00791 void L6208_DoDecel(void); 00792 void L6208_DoRun(void); 00793 uint8_t L6208_GetMicrostepSample2Scale(void); 00794 void L6208_Indexmodeinit(void); 00795 bool L6208_IsSysFlag(uint32_t mask); 00796 void L6208_ResetSteps(void); 00797 uint32_t L6208_ScaleWaveformSample(uint8_t sampleIndex); 00798 void L6208_ScaleWaveformTable(void); 00799 void L6208_SetDeviceParamsToGivenValues(l6208_Init_t* pInitDevicePrm); 00800 void L6208_SetDeviceParamsToPredefinedValues(void); 00801 void L6208_SetMicrostepSample2Scale(uint8_t value); 00802 void L6208_SetMicrostepSample2Update(uint8_t value); 00803 void L6208_SetMotionState(motorState_t newMotionState); 00804 bool L6208_SetSpeed(uint16_t newSpeed, uint32_t volatile *pSpeed); 00805 void L6208_SetSysFlag(uint32_t mask); 00806 bool L6208_StartMovement(void); 00807 void L6208_UpdateScanWaveformTable(void); 00808 void L6208_UstepWaveformHandling(void); 00809 bool L6208_VectorCalc(uint8_t newTorque); 00810 bool L6208_VrefPwmComputePulseWidth(uint8_t bridgeId, uint16_t value, bool valueIsPwmDutyCycle); 00811 void L6208_VrefPwmUpdatePulseWidth(void); 00812 00813 /*** Component's I/O Methods ***/ 00814 00815 /* ACTION 8 --------------------------------------------------------------* 00816 * Implement here other I/O methods beyond those already implemented * 00817 * above, which are declared extern within the component's header file. * 00818 *------------------------------------------------------------------------*/ 00819 /** 00820 * @brief Reset the clock pin. 00821 * @param None. 00822 * @retval None. 00823 */ 00824 void L6208_Board_CLOCK_PIN_Reset(void) 00825 { 00826 clock = 0; 00827 } 00828 /** 00829 * @brief Set the clock pin. 00830 * @param None. 00831 * @retval None. 00832 */ 00833 void L6208_Board_CLOCK_PIN_Set(void) 00834 { 00835 clock = 1; 00836 } 00837 00838 /** 00839 * @brief Set the control pin. 00840 * @param None. 00841 * @retval None. 00842 */ 00843 void L6208_Board_CONTROL_PIN_Set(void) 00844 { 00845 control = 1; 00846 } 00847 00848 /** 00849 * @brief Reset the control pin. 00850 * @param None. 00851 * @retval None. 00852 */ 00853 void L6208_Board_CONTROL_PIN_Reset(void) 00854 { 00855 control = 0; 00856 } 00857 00858 /** 00859 * @brief Making the CPU wait. 00860 * @param None. 00861 * @retval None. 00862 */ 00863 void L6208_Board_Delay(uint32_t delay) 00864 { 00865 wait_ms(delay); 00866 } 00867 00868 /** 00869 * @brief Reset the dir pin. 00870 * @param None. 00871 * @retval None. 00872 */ 00873 void L6208_Board_DIR_PIN_Reset(void) 00874 { 00875 direction = 0; 00876 } 00877 00878 /** 00879 * @brief Set the dir pin. 00880 * @param None. 00881 * @retval None. 00882 */ 00883 void L6208_Board_DIR_PIN_Set(void) 00884 { 00885 direction = 1; 00886 } 00887 00888 /** 00889 * @brief Disable the power bridges (leave the output bridges HiZ). 00890 * @param None. 00891 * @retval None. 00892 */ 00893 void L6208_Board_Disable(void) 00894 { 00895 flag_and_enable.disable_irq(); 00896 flag_and_enable.mode(PullDown); 00897 } 00898 00899 /** 00900 * @brief Disabling interrupts. 00901 * @param None. 00902 * @retval None. 00903 */ 00904 void L6208_Board_DisableIrq(void) 00905 { 00906 __disable_irq(); 00907 } 00908 00909 /** 00910 * @brief Enable the power bridges (leave the output bridges HiZ). 00911 * @param None. 00912 * @retval None. 00913 */ 00914 void L6208_Board_Enable(void) 00915 { 00916 flag_and_enable.mode(PullUp); 00917 flag_and_enable.enable_irq(); 00918 } 00919 00920 /** 00921 * @brief Enabling interrupts. 00922 * @param None. 00923 * @retval None. 00924 */ 00925 void L6208_Board_EnableIrq(void) 00926 { 00927 __enable_irq(); 00928 } 00929 00930 /** 00931 * @brief Reset the half full pin. 00932 * @param None. 00933 * @retval None. 00934 */ 00935 void L6208_Board_HALF_FULL_PIN_Reset(void) 00936 { 00937 half_full = 0; 00938 } 00939 00940 /** 00941 * @brief Set the half full pin. 00942 * @param None. 00943 * @retval None. 00944 */ 00945 void L6208_Board_HALF_FULL_PIN_Set(void) 00946 { 00947 half_full = 1; 00948 } 00949 00950 /** 00951 * @brief Initialising the the VREFA or VREFB PWM. 00952 * @param None. 00953 * @retval None. 00954 */ 00955 void L6208_Board_VrefPwmInit(uint8_t bridgeId, uint32_t pwmFreq) {} 00956 00957 /** 00958 * @brief Exit the device from reset mode. 00959 * @param None. 00960 * @retval None. 00961 */ 00962 void L6208_Board_ReleaseReset(void) 00963 { 00964 reset = 1; 00965 } 00966 00967 /** 00968 * @brief Put the device in reset mode. 00969 * @param None. 00970 * @retval None. 00971 */ 00972 void L6208_Board_Reset(void) 00973 { 00974 reset = 0; 00975 } 00976 00977 /** 00978 * @brief Get the tick timer frequency in Hz. 00979 * @param None. 00980 * @retval The tick timer frequency in Hz. 00981 */ 00982 uint32_t L6208_Board_TickGetFreq(void) 00983 { 00984 return TIMER_TICK_FREQUENCY; 00985 } 00986 00987 /** 00988 * @brief Initialising the tick. 00989 * @param None. 00990 * @retval None. 00991 */ 00992 void L6208_Board_TickInit(void) {} 00993 00994 /** 00995 * @brief Starting the tick timer, setting its frequency 00996 * and attaching a tick handler function to it. 00997 * @param frequency the frequency of the tick. 00998 * @retval None. 00999 */ 01000 void L6208_Board_TickStart(uint16_t frequency) 01001 { 01002 /* Computing the period of the tick. */ 01003 double period = 1.0f / frequency; 01004 01005 /* Attaching a tick handler function which updates */ 01006 /* the state machine every elapsed period time. */ 01007 ticker.attach(this, &L6208::L6208_TickHandler, period); 01008 } 01009 01010 /** 01011 * @brief Stopping the tick. 01012 * @param None. 01013 * @retval None. 01014 */ 01015 void L6208_Board_TickStop(void) 01016 { 01017 ticker.detach(); 01018 } 01019 01020 /** 01021 * @brief Set the pulse width of the VREFA PWM. 01022 * @param[in] pulseWidthInUs pulse width of the PWM in microsecond. 01023 * @retval None. 01024 */ 01025 void L6208_Board_VrefPwmSetPulseWidthA(uint8_t pulseWidthInUs) 01026 { 01027 vrefA_pwm.pulsewidth_us(pulseWidthInUs); 01028 } 01029 01030 /** 01031 * @brief Set the pulse width of the VREFB PWM. 01032 * @param[in] pulseWidthInUs pulse width of the PWM in microsecond. 01033 * @retval None. 01034 */ 01035 void L6208_Board_VrefPwmSetPulseWidthB(uint8_t pulseWidthInUs) 01036 { 01037 vrefB_pwm.pulsewidth_us(pulseWidthInUs); 01038 } 01039 01040 /** 01041 * @brief Start the timer for the VREFA or VREFB PWM. 01042 * @param[in] bridgeId 01043 * 0 for BRIDGE_A 01044 * 1 for BRIDGE_B 01045 * @param[in] pwmPeriod period of the PWM used to generate the reference 01046 * voltage for the bridge. 01047 * @retval "true" in case of success, "false" otherwise. 01048 * @note the unit is 1/256th of a microsecond. The VREFA PWM must be started 01049 * before the VREFB PWM. 01050 */ 01051 bool L6208_Board_VrefPwmStart(uint8_t bridgeId, uint16_t pwmPeriod) 01052 { 01053 pwmPeriod>>=8; 01054 /* Setting the period and the duty-cycle of PWM. */ 01055 if (bridgeId == 0) 01056 { 01057 vrefA_pwm.period_us(pwmPeriod); 01058 } 01059 else if (bridgeId == 1) 01060 { 01061 vrefB_pwm.period_us(pwmPeriod); 01062 } 01063 else return false; 01064 return true; 01065 } 01066 01067 /** 01068 * @brief Stop the timer for the VREFA or VREFB PWM. 01069 * @param[in] bridgeId 01070 * 0 for BRIDGE_A 01071 * 1 for BRIDGE_B 01072 * @retval "true" in case of success, "false" otherwise. 01073 */ 01074 bool L6208_Board_VrefPwmStop(uint8_t bridgeId) 01075 { 01076 if (bridgeId == 0) 01077 { 01078 vrefA_pwm.period_us(0); 01079 } 01080 else if (bridgeId == 1) 01081 { 01082 vrefB_pwm.period_us(0); 01083 } 01084 else return false; 01085 return true; 01086 } 01087 01088 protected: 01089 01090 /*** Component's Instance Variables ***/ 01091 01092 /* ACTION 9 --------------------------------------------------------------* 01093 * Declare here interrupt related variables, if needed. * 01094 * Note that interrupt handling is platform dependent, see * 01095 * "Interrupt Related Methods" above. * 01096 * * 01097 * Example: * 01098 * + mbed: * 01099 * InterruptIn feature_irq; * 01100 *------------------------------------------------------------------------*/ 01101 /* Flag Interrupt and chip enable. */ 01102 InterruptIn flag_and_enable; 01103 01104 /* ACTION 10 -------------------------------------------------------------* 01105 * Declare here other pin related variables, if needed. * 01106 * * 01107 * Example: * 01108 * + mbed: * 01109 * DigitalOut standby_reset; * 01110 *------------------------------------------------------------------------*/ 01111 /* RESET pin. */ 01112 DigitalOut reset; 01113 /* CW_CCW pin. */ 01114 DigitalOut direction; 01115 /* HALF_FULL pin */ 01116 DigitalOut half_full; 01117 /* CONTROL pin */ 01118 DigitalOut control; 01119 /* CLOCK pin */ 01120 DigitalOut clock; 01121 01122 /* Pulse Width Modulation pin for VREFA pin */ 01123 PwmOut vrefA_pwm; 01124 /* Pulse Width Modulation pin for VREFA pin */ 01125 PwmOut vrefB_pwm; 01126 01127 /* Timer for the tick */ 01128 Ticker ticker; 01129 01130 /* ACTION 11 -------------------------------------------------------------* 01131 * Declare here communication related variables, if needed. * 01132 * * 01133 * Example: * 01134 * + mbed: * 01135 * DigitalOut ssel; * 01136 * DevSPI &dev_spi; * 01137 *------------------------------------------------------------------------*/ 01138 /* Configuration. */ 01139 01140 /* IO Device. */ 01141 01142 /* ACTION 12 -------------------------------------------------------------* 01143 * Declare here identity related variables, if needed. * 01144 * Note that there should be only a unique identifier for each component, * 01145 * which should be the "who_am_i" parameter. * 01146 *------------------------------------------------------------------------*/ 01147 /* Identity */ 01148 uint8_t who_am_i; 01149 01150 /* ACTION 13 -------------------------------------------------------------* 01151 * Declare here the component's static and non-static data, one variable * 01152 * per line. * 01153 * * 01154 * Example: * 01155 * float measure; * 01156 * int instance_id; * 01157 * static int number_of_instances; * 01158 *------------------------------------------------------------------------*/ 01159 /* Data. */ 01160 void (*errorHandlerCallback)(uint16_t error); 01161 deviceParams_t devicePrm; 01162 uint8_t deviceInstance; 01163 uint32_t tickFreq; 01164 /// microstepping PWM period and torque scaled waveform samples array 01165 uint16_t updatedMicroTable[L6208_USTEPS_PER_QUARTER_PERIOD+1]; 01166 /// waveform scanning microstepping PWM period sample arrays for VREFA wave 01167 uint16_t microTable1[L6208_USTEPS_PER_QUARTER_PERIOD*3+1]; 01168 /// waveform scanning microstepping PWM period sample array for VREFB wave 01169 uint16_t *pMicroTable2; 01170 01171 /* Static data. */ 01172 static uint8_t numberOfDevices; 01173 static const uint16_t RefMicroTable[L6208_USTEPS_PER_QUARTER_PERIOD*3]; 01174 01175 public: 01176 01177 /* Static data. */ 01178 01179 }; 01180 01181 #endif // __L6208_CLASS_H 01182 01183 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Generated on Thu Jul 21 2022 19:36:08 by
1.7.2