Davide Aliprandi
/
X_NUCLEO_IHM14A1
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.
Components/STSPIN820/STSPIN820.h@1:bc265521eb00, 2018-04-27 (annotated)
- Committer:
- Davidroid
- Date:
- Fri Apr 27 17:02:08 2018 +0000
- Revision:
- 1:bc265521eb00
Populate
Who changed what in which revision?
| User | Revision | Line number | New contents of line |
|---|---|---|---|
| Davidroid | 1:bc265521eb00 | 1 | /** |
| Davidroid | 1:bc265521eb00 | 2 | ****************************************************************************** |
| Davidroid | 1:bc265521eb00 | 3 | * @file STSPIN820.h |
| Davidroid | 1:bc265521eb00 | 4 | * @author STM |
| Davidroid | 1:bc265521eb00 | 5 | * @version V1.0.0 |
| Davidroid | 1:bc265521eb00 | 6 | * @date August 7th, 2017 |
| Davidroid | 1:bc265521eb00 | 7 | * @brief STSPIN820 driver (fully integrated microstepping motor driver) |
| Davidroid | 1:bc265521eb00 | 8 | * @note (C) COPYRIGHT 2017 STMicroelectronics |
| Davidroid | 1:bc265521eb00 | 9 | ****************************************************************************** |
| Davidroid | 1:bc265521eb00 | 10 | * @attention |
| Davidroid | 1:bc265521eb00 | 11 | * |
| Davidroid | 1:bc265521eb00 | 12 | * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2> |
| Davidroid | 1:bc265521eb00 | 13 | * |
| Davidroid | 1:bc265521eb00 | 14 | * Redistribution and use in source and binary forms, with or without modification, |
| Davidroid | 1:bc265521eb00 | 15 | * are permitted provided that the following conditions are met: |
| Davidroid | 1:bc265521eb00 | 16 | * 1. Redistributions of source code must retain the above copyright notice, |
| Davidroid | 1:bc265521eb00 | 17 | * this list of conditions and the following disclaimer. |
| Davidroid | 1:bc265521eb00 | 18 | * 2. Redistributions in binary form must reproduce the above copyright notice, |
| Davidroid | 1:bc265521eb00 | 19 | * this list of conditions and the following disclaimer in the documentation |
| Davidroid | 1:bc265521eb00 | 20 | * and/or other materials provided with the distribution. |
| Davidroid | 1:bc265521eb00 | 21 | * 3. Neither the name of STMicroelectronics nor the names of its contributors |
| Davidroid | 1:bc265521eb00 | 22 | * may be used to endorse or promote products derived from this software |
| Davidroid | 1:bc265521eb00 | 23 | * without specific prior written permission. |
| Davidroid | 1:bc265521eb00 | 24 | * |
| Davidroid | 1:bc265521eb00 | 25 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| Davidroid | 1:bc265521eb00 | 26 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| Davidroid | 1:bc265521eb00 | 27 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| Davidroid | 1:bc265521eb00 | 28 | * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| Davidroid | 1:bc265521eb00 | 29 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| Davidroid | 1:bc265521eb00 | 30 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| Davidroid | 1:bc265521eb00 | 31 | * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| Davidroid | 1:bc265521eb00 | 32 | * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| Davidroid | 1:bc265521eb00 | 33 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| Davidroid | 1:bc265521eb00 | 34 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| Davidroid | 1:bc265521eb00 | 35 | * |
| Davidroid | 1:bc265521eb00 | 36 | ****************************************************************************** |
| Davidroid | 1:bc265521eb00 | 37 | */ |
| Davidroid | 1:bc265521eb00 | 38 | |
| Davidroid | 1:bc265521eb00 | 39 | |
| Davidroid | 1:bc265521eb00 | 40 | /* Generated with STM32CubeTOO -----------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 41 | |
| Davidroid | 1:bc265521eb00 | 42 | |
| Davidroid | 1:bc265521eb00 | 43 | /* Revision ------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 44 | /* |
| Davidroid | 1:bc265521eb00 | 45 | Repository: http://svn.x-nucleodev.codex.cro.st.com/svnroot/X-NucleoDev |
| Davidroid | 1:bc265521eb00 | 46 | Branch/Trunk/Tag: trunk |
| Davidroid | 1:bc265521eb00 | 47 | Based on: X-CUBE-SPN14/trunk/Drivers/BSP/Components/STSPIN820/STSPIN820.h |
| Davidroid | 1:bc265521eb00 | 48 | Revision: 0 |
| Davidroid | 1:bc265521eb00 | 49 | */ |
| Davidroid | 1:bc265521eb00 | 50 | |
| Davidroid | 1:bc265521eb00 | 51 | |
| Davidroid | 1:bc265521eb00 | 52 | /* Define to prevent recursive inclusion -------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 53 | |
| Davidroid | 1:bc265521eb00 | 54 | #ifndef __STSPIN820_CLASS_H |
| Davidroid | 1:bc265521eb00 | 55 | #define __STSPIN820_CLASS_H |
| Davidroid | 1:bc265521eb00 | 56 | |
| Davidroid | 1:bc265521eb00 | 57 | |
| Davidroid | 1:bc265521eb00 | 58 | /* Includes ------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 59 | |
| Davidroid | 1:bc265521eb00 | 60 | /* ACTION 1 ------------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 61 | * Include here platform specific header files. * |
| Davidroid | 1:bc265521eb00 | 62 | *----------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 63 | #include "mbed.h" |
| Davidroid | 1:bc265521eb00 | 64 | #include "DevSPI.h" |
| Davidroid | 1:bc265521eb00 | 65 | /* ACTION 2 ------------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 66 | * Include here component specific header files. * |
| Davidroid | 1:bc265521eb00 | 67 | *----------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 68 | #include "STSPIN820_def.h" |
| Davidroid | 1:bc265521eb00 | 69 | /* ACTION 3 ------------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 70 | * Include here interface specific header files. * |
| Davidroid | 1:bc265521eb00 | 71 | * * |
| Davidroid | 1:bc265521eb00 | 72 | * Example: * |
| Davidroid | 1:bc265521eb00 | 73 | * #include "../Interfaces/Humidity.h" * |
| Davidroid | 1:bc265521eb00 | 74 | * #include "../Interfaces/Temperature.h" * |
| Davidroid | 1:bc265521eb00 | 75 | *----------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 76 | #include "../Interfaces/Motor.h" |
| Davidroid | 1:bc265521eb00 | 77 | |
| Davidroid | 1:bc265521eb00 | 78 | |
| Davidroid | 1:bc265521eb00 | 79 | /* Classes -------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 80 | |
| Davidroid | 1:bc265521eb00 | 81 | /** |
| Davidroid | 1:bc265521eb00 | 82 | * @brief Class representing a STSPIN820 component. |
| Davidroid | 1:bc265521eb00 | 83 | */ |
| Davidroid | 1:bc265521eb00 | 84 | class STSPIN820 : public Motor |
| Davidroid | 1:bc265521eb00 | 85 | { |
| Davidroid | 1:bc265521eb00 | 86 | public: |
| Davidroid | 1:bc265521eb00 | 87 | |
| Davidroid | 1:bc265521eb00 | 88 | /*** Constructor and Destructor Methods ***/ |
| Davidroid | 1:bc265521eb00 | 89 | |
| Davidroid | 1:bc265521eb00 | 90 | /** |
| Davidroid | 1:bc265521eb00 | 91 | * @brief Constructor. |
| Davidroid | 1:bc265521eb00 | 92 | * @param ssel pin name of the SSEL pin of the SPI device to be used for communication. |
| Davidroid | 1:bc265521eb00 | 93 | * @param spi SPI device to be used for communication. |
| Davidroid | 1:bc265521eb00 | 94 | */ |
| Davidroid | 1:bc265521eb00 | 95 | STSPIN820(PinName ssel, DevSPI &spi) : Motor(), ssel(ssel), dev_spi(spi) |
| Davidroid | 1:bc265521eb00 | 96 | { |
| Davidroid | 1:bc265521eb00 | 97 | /* ACTION 4 ----------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 98 | * Initialize here the component's member variables, one variable per * |
| Davidroid | 1:bc265521eb00 | 99 | * line. * |
| Davidroid | 1:bc265521eb00 | 100 | * * |
| Davidroid | 1:bc265521eb00 | 101 | * Example: * |
| Davidroid | 1:bc265521eb00 | 102 | * measure = 0; * |
| Davidroid | 1:bc265521eb00 | 103 | * instance_id = number_of_instances++; * |
| Davidroid | 1:bc265521eb00 | 104 | *--------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 105 | flag_interrupt_callback = 0; |
| Davidroid | 1:bc265521eb00 | 106 | error_handler_callback = 0; |
| Davidroid | 1:bc265521eb00 | 107 | toggle_odd = 0; |
| Davidroid | 1:bc265521eb00 | 108 | device_prm = 0; |
| Davidroid | 1:bc265521eb00 | 109 | number_of_devices = 0; |
| Davidroid | 1:bc265521eb00 | 110 | device_instance = 0; |
| Davidroid | 1:bc265521eb00 | 111 | } |
| Davidroid | 1:bc265521eb00 | 112 | |
| Davidroid | 1:bc265521eb00 | 113 | /** |
| Davidroid | 1:bc265521eb00 | 114 | * @brief Destructor. |
| Davidroid | 1:bc265521eb00 | 115 | */ |
| Davidroid | 1:bc265521eb00 | 116 | virtual ~STSPIN820(void) {} |
| Davidroid | 1:bc265521eb00 | 117 | |
| Davidroid | 1:bc265521eb00 | 118 | |
| Davidroid | 1:bc265521eb00 | 119 | /*** Public Component Related Methods ***/ |
| Davidroid | 1:bc265521eb00 | 120 | |
| Davidroid | 1:bc265521eb00 | 121 | /* ACTION 5 --------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 122 | * Implement here the component's public methods, as wrappers of the C * |
| Davidroid | 1:bc265521eb00 | 123 | * component's functions. * |
| Davidroid | 1:bc265521eb00 | 124 | * They should be: * |
| Davidroid | 1:bc265521eb00 | 125 | * + Methods with the same name of the C component's virtual table's * |
| Davidroid | 1:bc265521eb00 | 126 | * functions (1); * |
| Davidroid | 1:bc265521eb00 | 127 | * + Methods with the same name of the C component's extended virtual * |
| Davidroid | 1:bc265521eb00 | 128 | * table's functions, if any (2). * |
| Davidroid | 1:bc265521eb00 | 129 | * * |
| Davidroid | 1:bc265521eb00 | 130 | * Example: * |
| Davidroid | 1:bc265521eb00 | 131 | * virtual int get_value(float *p_data) //(1) * |
| Davidroid | 1:bc265521eb00 | 132 | * { * |
| Davidroid | 1:bc265521eb00 | 133 | * return COMPONENT_get_value(float *pf_data); * |
| Davidroid | 1:bc265521eb00 | 134 | * } * |
| Davidroid | 1:bc265521eb00 | 135 | * * |
| Davidroid | 1:bc265521eb00 | 136 | * virtual int enable_feature(void) //(2) * |
| Davidroid | 1:bc265521eb00 | 137 | * { * |
| Davidroid | 1:bc265521eb00 | 138 | * return COMPONENT_enable_feature(); * |
| Davidroid | 1:bc265521eb00 | 139 | * } * |
| Davidroid | 1:bc265521eb00 | 140 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 141 | virtual int init(void *init = NULL) |
| Davidroid | 1:bc265521eb00 | 142 | { |
| Davidroid | 1:bc265521eb00 | 143 | return (int) STSPIN820_Init((void *) init); |
| Davidroid | 1:bc265521eb00 | 144 | } |
| Davidroid | 1:bc265521eb00 | 145 | |
| Davidroid | 1:bc265521eb00 | 146 | virtual int read_id(uint8_t *id = NULL) |
| Davidroid | 1:bc265521eb00 | 147 | { |
| Davidroid | 1:bc265521eb00 | 148 | return (int) STSPIN820_ReadId((uint8_t *) id); |
| Davidroid | 1:bc265521eb00 | 149 | } |
| Davidroid | 1:bc265521eb00 | 150 | |
| Davidroid | 1:bc265521eb00 | 151 | virtual void attach_error_handler(void (*callback)(uint16_t error)) |
| Davidroid | 1:bc265521eb00 | 152 | { |
| Davidroid | 1:bc265521eb00 | 153 | STSPIN820_AttachErrorHandler((void (*)(uint16_t error)) callback); |
| Davidroid | 1:bc265521eb00 | 154 | } |
| Davidroid | 1:bc265521eb00 | 155 | |
| Davidroid | 1:bc265521eb00 | 156 | virtual void attach_flag_interrupt(void (*callback)(void)) |
| Davidroid | 1:bc265521eb00 | 157 | { |
| Davidroid | 1:bc265521eb00 | 158 | STSPIN820_AttachFlagInterrupt((void (*)(void)) callback); |
| Davidroid | 1:bc265521eb00 | 159 | } |
| Davidroid | 1:bc265521eb00 | 160 | |
| Davidroid | 1:bc265521eb00 | 161 | virtual void flag_interrupt_handler(void) |
| Davidroid | 1:bc265521eb00 | 162 | { |
| Davidroid | 1:bc265521eb00 | 163 | STSPIN820_FlagInterruptHandler(); |
| Davidroid | 1:bc265521eb00 | 164 | } |
| Davidroid | 1:bc265521eb00 | 165 | |
| Davidroid | 1:bc265521eb00 | 166 | virtual uint16_t get_acceleration(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 167 | { |
| Davidroid | 1:bc265521eb00 | 168 | return (uint16_t) STSPIN820_GetAcceleration((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 169 | } |
| Davidroid | 1:bc265521eb00 | 170 | |
| Davidroid | 1:bc265521eb00 | 171 | virtual uint16_t get_current_speed(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 172 | { |
| Davidroid | 1:bc265521eb00 | 173 | return (uint16_t) STSPIN820_GetCurrentSpeed((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 174 | } |
| Davidroid | 1:bc265521eb00 | 175 | |
| Davidroid | 1:bc265521eb00 | 176 | virtual uint16_t get_deceleration(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 177 | { |
| Davidroid | 1:bc265521eb00 | 178 | return (uint16_t) STSPIN820_GetDeceleration((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 179 | } |
| Davidroid | 1:bc265521eb00 | 180 | |
| Davidroid | 1:bc265521eb00 | 181 | virtual motor_state_t get_device_state(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 182 | { |
| Davidroid | 1:bc265521eb00 | 183 | return (motor_state_t) STSPIN820_GetDeviceState((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 184 | } |
| Davidroid | 1:bc265521eb00 | 185 | |
| Davidroid | 1:bc265521eb00 | 186 | virtual uint32_t get_fw_version(void) |
| Davidroid | 1:bc265521eb00 | 187 | { |
| Davidroid | 1:bc265521eb00 | 188 | return (uint32_t) STSPIN820_GetFwVersion(); |
| Davidroid | 1:bc265521eb00 | 189 | } |
| Davidroid | 1:bc265521eb00 | 190 | |
| Davidroid | 1:bc265521eb00 | 191 | virtual int32_t get_mark(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 192 | { |
| Davidroid | 1:bc265521eb00 | 193 | return (int32_t) STSPIN820_GetMark((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 194 | } |
| Davidroid | 1:bc265521eb00 | 195 | |
| Davidroid | 1:bc265521eb00 | 196 | virtual uint16_t get_max_speed(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 197 | { |
| Davidroid | 1:bc265521eb00 | 198 | return (uint16_t) STSPIN820_GetMaxSpeed((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 199 | } |
| Davidroid | 1:bc265521eb00 | 200 | |
| Davidroid | 1:bc265521eb00 | 201 | virtual uint16_t get_min_speed(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 202 | { |
| Davidroid | 1:bc265521eb00 | 203 | return (uint16_t) STSPIN820_GetMinSpeed((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 204 | } |
| Davidroid | 1:bc265521eb00 | 205 | |
| Davidroid | 1:bc265521eb00 | 206 | virtual int32_t get_position(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 207 | { |
| Davidroid | 1:bc265521eb00 | 208 | return (int32_t) STSPIN820_GetPosition((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 209 | } |
| Davidroid | 1:bc265521eb00 | 210 | |
| Davidroid | 1:bc265521eb00 | 211 | virtual void go_home(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 212 | { |
| Davidroid | 1:bc265521eb00 | 213 | STSPIN820_GoHome((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 214 | } |
| Davidroid | 1:bc265521eb00 | 215 | |
| Davidroid | 1:bc265521eb00 | 216 | virtual void go_mark(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 217 | { |
| Davidroid | 1:bc265521eb00 | 218 | STSPIN820_GoMark((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 219 | } |
| Davidroid | 1:bc265521eb00 | 220 | |
| Davidroid | 1:bc265521eb00 | 221 | virtual void go_to(uint8_t deviceId, int32_t targetPosition) |
| Davidroid | 1:bc265521eb00 | 222 | { |
| Davidroid | 1:bc265521eb00 | 223 | STSPIN820_GoTo((uint8_t) deviceId, (int32_t) targetPosition); |
| Davidroid | 1:bc265521eb00 | 224 | } |
| Davidroid | 1:bc265521eb00 | 225 | |
| Davidroid | 1:bc265521eb00 | 226 | virtual void hard_stop(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 227 | { |
| Davidroid | 1:bc265521eb00 | 228 | STSPIN820_HardStop((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 229 | } |
| Davidroid | 1:bc265521eb00 | 230 | |
| Davidroid | 1:bc265521eb00 | 231 | virtual void move(uint8_t deviceId, motor_direction_t direction, uint32_t stepCount) |
| Davidroid | 1:bc265521eb00 | 232 | { |
| Davidroid | 1:bc265521eb00 | 233 | STSPIN820_Move((uint8_t) deviceId, (motor_direction_t) direction, (uint32_t) stepCount); |
| Davidroid | 1:bc265521eb00 | 234 | } |
| Davidroid | 1:bc265521eb00 | 235 | |
| Davidroid | 1:bc265521eb00 | 236 | virtual void run(uint8_t deviceId, motor_direction_t direction) |
| Davidroid | 1:bc265521eb00 | 237 | { |
| Davidroid | 1:bc265521eb00 | 238 | STSPIN820_Run((uint8_t) deviceId, (motor_direction_t) direction); |
| Davidroid | 1:bc265521eb00 | 239 | } |
| Davidroid | 1:bc265521eb00 | 240 | |
| Davidroid | 1:bc265521eb00 | 241 | virtual bool set_acceleration(uint8_t deviceId, uint16_t newAcc) |
| Davidroid | 1:bc265521eb00 | 242 | { |
| Davidroid | 1:bc265521eb00 | 243 | return (bool) STSPIN820_SetAcceleration((uint8_t) deviceId, (uint16_t) newAcc); |
| Davidroid | 1:bc265521eb00 | 244 | } |
| Davidroid | 1:bc265521eb00 | 245 | |
| Davidroid | 1:bc265521eb00 | 246 | virtual bool set_deceleration(uint8_t deviceId, uint16_t newDec) |
| Davidroid | 1:bc265521eb00 | 247 | { |
| Davidroid | 1:bc265521eb00 | 248 | return (bool) STSPIN820_SetDeceleration((uint8_t) deviceId, (uint16_t) newDec); |
| Davidroid | 1:bc265521eb00 | 249 | } |
| Davidroid | 1:bc265521eb00 | 250 | |
| Davidroid | 1:bc265521eb00 | 251 | virtual void set_home(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 252 | { |
| Davidroid | 1:bc265521eb00 | 253 | STSPIN820_SetHome((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 254 | } |
| Davidroid | 1:bc265521eb00 | 255 | |
| Davidroid | 1:bc265521eb00 | 256 | virtual void set_mark(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 257 | { |
| Davidroid | 1:bc265521eb00 | 258 | STSPIN820_SetMark((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 259 | } |
| Davidroid | 1:bc265521eb00 | 260 | |
| Davidroid | 1:bc265521eb00 | 261 | virtual bool set_max_speed(uint8_t deviceId, uint16_t newMaxSpeed) |
| Davidroid | 1:bc265521eb00 | 262 | { |
| Davidroid | 1:bc265521eb00 | 263 | return (bool) STSPIN820_SetMaxSpeed((uint8_t) deviceId, (uint16_t) newMaxSpeed); |
| Davidroid | 1:bc265521eb00 | 264 | } |
| Davidroid | 1:bc265521eb00 | 265 | |
| Davidroid | 1:bc265521eb00 | 266 | virtual bool set_min_speed(uint8_t deviceId, uint16_t newMinSpeed) |
| Davidroid | 1:bc265521eb00 | 267 | { |
| Davidroid | 1:bc265521eb00 | 268 | return (bool) STSPIN820_SetMinSpeed((uint8_t) deviceId, (uint16_t) newMinSpeed); |
| Davidroid | 1:bc265521eb00 | 269 | } |
| Davidroid | 1:bc265521eb00 | 270 | |
| Davidroid | 1:bc265521eb00 | 271 | virtual bool soft_stop(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 272 | { |
| Davidroid | 1:bc265521eb00 | 273 | return (bool) STSPIN820_SoftStop((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 274 | } |
| Davidroid | 1:bc265521eb00 | 275 | |
| Davidroid | 1:bc265521eb00 | 276 | virtual void step_clock_handler(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 277 | { |
| Davidroid | 1:bc265521eb00 | 278 | STSPIN820_StepClockHandler((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 279 | } |
| Davidroid | 1:bc265521eb00 | 280 | |
| Davidroid | 1:bc265521eb00 | 281 | virtual void wait_while_active(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 282 | { |
| Davidroid | 1:bc265521eb00 | 283 | STSPIN820_WaitWhileActive((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 284 | } |
| Davidroid | 1:bc265521eb00 | 285 | |
| Davidroid | 1:bc265521eb00 | 286 | virtual void cmd_disable(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 287 | { |
| Davidroid | 1:bc265521eb00 | 288 | STSPIN820_Disable((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 289 | } |
| Davidroid | 1:bc265521eb00 | 290 | |
| Davidroid | 1:bc265521eb00 | 291 | virtual void cmd_enable(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 292 | { |
| Davidroid | 1:bc265521eb00 | 293 | STSPIN820_Enable((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 294 | } |
| Davidroid | 1:bc265521eb00 | 295 | |
| Davidroid | 1:bc265521eb00 | 296 | virtual bool select_step_mode(uint8_t deviceId, motor_step_mode_t stepMode) |
| Davidroid | 1:bc265521eb00 | 297 | { |
| Davidroid | 1:bc265521eb00 | 298 | return (bool) STSPIN820_SetStepMode((uint8_t) deviceId, (motor_step_mode_t) stepMode); |
| Davidroid | 1:bc265521eb00 | 299 | } |
| Davidroid | 1:bc265521eb00 | 300 | |
| Davidroid | 1:bc265521eb00 | 301 | virtual void set_direction(uint8_t deviceId, motor_direction_t direction) |
| Davidroid | 1:bc265521eb00 | 302 | { |
| Davidroid | 1:bc265521eb00 | 303 | STSPIN820_SetDirection((uint8_t) deviceId, (motor_direction_t) direction); |
| Davidroid | 1:bc265521eb00 | 304 | } |
| Davidroid | 1:bc265521eb00 | 305 | |
| Davidroid | 1:bc265521eb00 | 306 | virtual void cmd_go_to_dir(uint8_t deviceId, motor_direction_t direction, int32_t targetPosition) |
| Davidroid | 1:bc265521eb00 | 307 | { |
| Davidroid | 1:bc265521eb00 | 308 | STSPIN820_GoToDir((uint8_t) deviceId, (motor_direction_t) direction, (int32_t) targetPosition); |
| Davidroid | 1:bc265521eb00 | 309 | } |
| Davidroid | 1:bc265521eb00 | 310 | |
| Davidroid | 1:bc265521eb00 | 311 | virtual uint8_t check_status_hw(void) |
| Davidroid | 1:bc265521eb00 | 312 | { |
| Davidroid | 1:bc265521eb00 | 313 | return (uint8_t) STSPIN820_CheckStatusHw(); |
| Davidroid | 1:bc265521eb00 | 314 | } |
| Davidroid | 1:bc265521eb00 | 315 | |
| Davidroid | 1:bc265521eb00 | 316 | virtual void cmd_reset_device(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 317 | { |
| Davidroid | 1:bc265521eb00 | 318 | STSPIN820_PutDeviceInStandby((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 319 | } |
| Davidroid | 1:bc265521eb00 | 320 | |
| Davidroid | 1:bc265521eb00 | 321 | virtual uint8_t get_nb_devices(void) |
| Davidroid | 1:bc265521eb00 | 322 | { |
| Davidroid | 1:bc265521eb00 | 323 | return (uint8_t) STSPIN820_GetNbDevices(); |
| Davidroid | 1:bc265521eb00 | 324 | } |
| Davidroid | 1:bc265521eb00 | 325 | |
| Davidroid | 1:bc265521eb00 | 326 | virtual void error_handler(uint16_t error) |
| Davidroid | 1:bc265521eb00 | 327 | { |
| Davidroid | 1:bc265521eb00 | 328 | STSPIN820_ErrorHandler((uint16_t) error); |
| Davidroid | 1:bc265521eb00 | 329 | } |
| Davidroid | 1:bc265521eb00 | 330 | |
| Davidroid | 1:bc265521eb00 | 331 | virtual uint32_t get_bridge_input_pwm_freq(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 332 | { |
| Davidroid | 1:bc265521eb00 | 333 | return (uint32_t) STSPIN820_VrefPwmGetFreq((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 334 | } |
| Davidroid | 1:bc265521eb00 | 335 | |
| Davidroid | 1:bc265521eb00 | 336 | virtual void set_bridge_input_pwm_freq(uint8_t deviceId, uint32_t newFreq) |
| Davidroid | 1:bc265521eb00 | 337 | { |
| Davidroid | 1:bc265521eb00 | 338 | STSPIN820_VrefPwmSetFreq((uint8_t) deviceId, (uint32_t) newFreq); |
| Davidroid | 1:bc265521eb00 | 339 | } |
| Davidroid | 1:bc265521eb00 | 340 | |
| Davidroid | 1:bc265521eb00 | 341 | virtual void set_stop_mode(uint8_t deviceId, motor_stop_mode_t stopMode) |
| Davidroid | 1:bc265521eb00 | 342 | { |
| Davidroid | 1:bc265521eb00 | 343 | STSPIN820_SetStopMode((uint8_t) deviceId, (motor_stop_mode_t) stopMode); |
| Davidroid | 1:bc265521eb00 | 344 | } |
| Davidroid | 1:bc265521eb00 | 345 | |
| Davidroid | 1:bc265521eb00 | 346 | virtual motor_stop_mode_t get_stop_mode(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 347 | { |
| Davidroid | 1:bc265521eb00 | 348 | return (motor_stop_mode_t) STSPIN820_GetStopMode((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 349 | } |
| Davidroid | 1:bc265521eb00 | 350 | |
| Davidroid | 1:bc265521eb00 | 351 | virtual void set_decay_mode(uint8_t deviceId, motor_decay_mode_t decayMode) |
| Davidroid | 1:bc265521eb00 | 352 | { |
| Davidroid | 1:bc265521eb00 | 353 | STSPIN820_SetDecayMode((uint8_t) deviceId, (motor_decay_mode_t) decayMode); |
| Davidroid | 1:bc265521eb00 | 354 | } |
| Davidroid | 1:bc265521eb00 | 355 | |
| Davidroid | 1:bc265521eb00 | 356 | virtual motor_decay_mode_t get_decay_mode(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 357 | { |
| Davidroid | 1:bc265521eb00 | 358 | return (motor_decay_mode_t) STSPIN820_GetDecayMode((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 359 | } |
| Davidroid | 1:bc265521eb00 | 360 | |
| Davidroid | 1:bc265521eb00 | 361 | virtual motor_step_mode_t get_step_mode(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 362 | { |
| Davidroid | 1:bc265521eb00 | 363 | return (motor_step_mode_t) STSPIN820_GetStepMode((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 364 | } |
| Davidroid | 1:bc265521eb00 | 365 | |
| Davidroid | 1:bc265521eb00 | 366 | virtual motor_direction_t get_direction(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 367 | { |
| Davidroid | 1:bc265521eb00 | 368 | return (motor_direction_t) STSPIN820_GetDirection((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 369 | } |
| Davidroid | 1:bc265521eb00 | 370 | |
| Davidroid | 1:bc265521eb00 | 371 | virtual void exit_device_from_reset(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 372 | { |
| Davidroid | 1:bc265521eb00 | 373 | STSPIN820_ExitDeviceFromStandby((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 374 | } |
| Davidroid | 1:bc265521eb00 | 375 | |
| Davidroid | 1:bc265521eb00 | 376 | virtual void set_torque(uint8_t deviceId, motor_torque_mode_t torqueMode, uint8_t torqueValue) |
| Davidroid | 1:bc265521eb00 | 377 | { |
| Davidroid | 1:bc265521eb00 | 378 | STSPIN820_SetTorque((uint8_t) deviceId, (motor_torque_mode_t) torqueMode, (uint8_t) torqueValue); |
| Davidroid | 1:bc265521eb00 | 379 | } |
| Davidroid | 1:bc265521eb00 | 380 | |
| Davidroid | 1:bc265521eb00 | 381 | virtual uint8_t get_torque(uint8_t deviceId, motor_torque_mode_t torqueMode) |
| Davidroid | 1:bc265521eb00 | 382 | { |
| Davidroid | 1:bc265521eb00 | 383 | return (uint8_t) STSPIN820_GetTorque((uint8_t) deviceId, (motor_torque_mode_t) torqueMode); |
| Davidroid | 1:bc265521eb00 | 384 | } |
| Davidroid | 1:bc265521eb00 | 385 | |
| Davidroid | 1:bc265521eb00 | 386 | virtual bool set_nb_devices(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 387 | { |
| Davidroid | 1:bc265521eb00 | 388 | return (bool) STSPIN820_SetNbDevices((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 389 | } |
| Davidroid | 1:bc265521eb00 | 390 | |
| Davidroid | 1:bc265521eb00 | 391 | virtual void set_torque_boost_enable(uint8_t deviceId, bool enable) |
| Davidroid | 1:bc265521eb00 | 392 | { |
| Davidroid | 1:bc265521eb00 | 393 | STSPIN820_SetTorqueBoostEnable((uint8_t) deviceId, (bool) enable); |
| Davidroid | 1:bc265521eb00 | 394 | } |
| Davidroid | 1:bc265521eb00 | 395 | |
| Davidroid | 1:bc265521eb00 | 396 | virtual bool get_torque_boost_enable(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 397 | { |
| Davidroid | 1:bc265521eb00 | 398 | return (bool) STSPIN820_GetTorqueBoostEnable((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 399 | } |
| Davidroid | 1:bc265521eb00 | 400 | |
| Davidroid | 1:bc265521eb00 | 401 | virtual void set_torque_boost_threshold(uint8_t deviceId, uint16_t speedThreshold) |
| Davidroid | 1:bc265521eb00 | 402 | { |
| Davidroid | 1:bc265521eb00 | 403 | STSPIN820_SetTorqueBoostThreshold((uint8_t) deviceId, (uint16_t) speedThreshold); |
| Davidroid | 1:bc265521eb00 | 404 | } |
| Davidroid | 1:bc265521eb00 | 405 | |
| Davidroid | 1:bc265521eb00 | 406 | virtual uint16_t get_torque_boost_threshold(uint8_t deviceId) |
| Davidroid | 1:bc265521eb00 | 407 | { |
| Davidroid | 1:bc265521eb00 | 408 | return (uint16_t) STSPIN820_GetTorqueBoostThreshold((uint8_t) deviceId); |
| Davidroid | 1:bc265521eb00 | 409 | } |
| Davidroid | 1:bc265521eb00 | 410 | |
| Davidroid | 1:bc265521eb00 | 411 | |
| Davidroid | 1:bc265521eb00 | 412 | /*** Public Interrupt Related Methods ***/ |
| Davidroid | 1:bc265521eb00 | 413 | |
| Davidroid | 1:bc265521eb00 | 414 | /* ACTION 6 --------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 415 | * Implement here interrupt related methods, if any. * |
| Davidroid | 1:bc265521eb00 | 416 | * Note that interrupt handling is platform dependent, e.g.: * |
| Davidroid | 1:bc265521eb00 | 417 | * + mbed: * |
| Davidroid | 1:bc265521eb00 | 418 | * InterruptIn feature_irq(pin); //Interrupt object. * |
| Davidroid | 1:bc265521eb00 | 419 | * feature_irq.rise(callback); //Attach a callback. * |
| Davidroid | 1:bc265521eb00 | 420 | * feature_irq.mode(PullNone); //Set interrupt mode. * |
| Davidroid | 1:bc265521eb00 | 421 | * feature_irq.enable_irq(); //Enable interrupt. * |
| Davidroid | 1:bc265521eb00 | 422 | * feature_irq.disable_irq(); //Disable interrupt. * |
| Davidroid | 1:bc265521eb00 | 423 | * + Arduino: * |
| Davidroid | 1:bc265521eb00 | 424 | * attachInterrupt(pin, callback, RISING); //Attach a callback. * |
| Davidroid | 1:bc265521eb00 | 425 | * detachInterrupt(pin); //Detach a callback. * |
| Davidroid | 1:bc265521eb00 | 426 | * * |
| Davidroid | 1:bc265521eb00 | 427 | * Example (mbed): * |
| Davidroid | 1:bc265521eb00 | 428 | * void attach_feature_irq(void (*fptr) (void)) * |
| Davidroid | 1:bc265521eb00 | 429 | * { * |
| Davidroid | 1:bc265521eb00 | 430 | * feature_irq.rise(fptr); * |
| Davidroid | 1:bc265521eb00 | 431 | * } * |
| Davidroid | 1:bc265521eb00 | 432 | * * |
| Davidroid | 1:bc265521eb00 | 433 | * void enable_feature_irq(void) * |
| Davidroid | 1:bc265521eb00 | 434 | * { * |
| Davidroid | 1:bc265521eb00 | 435 | * feature_irq.enable_irq(); * |
| Davidroid | 1:bc265521eb00 | 436 | * } * |
| Davidroid | 1:bc265521eb00 | 437 | * * |
| Davidroid | 1:bc265521eb00 | 438 | * void disable_feature_irq(void) * |
| Davidroid | 1:bc265521eb00 | 439 | * { * |
| Davidroid | 1:bc265521eb00 | 440 | * feature_irq.disable_irq(); * |
| Davidroid | 1:bc265521eb00 | 441 | * } * |
| Davidroid | 1:bc265521eb00 | 442 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 443 | |
| Davidroid | 1:bc265521eb00 | 444 | |
| Davidroid | 1:bc265521eb00 | 445 | protected: |
| Davidroid | 1:bc265521eb00 | 446 | |
| Davidroid | 1:bc265521eb00 | 447 | /*** Protected Component Related Methods ***/ |
| Davidroid | 1:bc265521eb00 | 448 | |
| Davidroid | 1:bc265521eb00 | 449 | /* ACTION 7 --------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 450 | * Declare here the component's specific methods. * |
| Davidroid | 1:bc265521eb00 | 451 | * They should be: * |
| Davidroid | 1:bc265521eb00 | 452 | * + Methods with the same name of the C component's virtual table's * |
| Davidroid | 1:bc265521eb00 | 453 | * functions (1); * |
| Davidroid | 1:bc265521eb00 | 454 | * + Methods with the same name of the C component's extended virtual * |
| Davidroid | 1:bc265521eb00 | 455 | * table's functions, if any (2); * |
| Davidroid | 1:bc265521eb00 | 456 | * + Helper methods, if any, like functions declared in the component's * |
| Davidroid | 1:bc265521eb00 | 457 | * source files but not pointed by the component's virtual table (3). * |
| Davidroid | 1:bc265521eb00 | 458 | * * |
| Davidroid | 1:bc265521eb00 | 459 | * Example: * |
| Davidroid | 1:bc265521eb00 | 460 | * status_t COMPONENT_get_value(float *f); //(1) * |
| Davidroid | 1:bc265521eb00 | 461 | * status_t COMPONENT_enable_feature(void); //(2) * |
| Davidroid | 1:bc265521eb00 | 462 | * status_t COMPONENT_compute_average(void); //(3) * |
| Davidroid | 1:bc265521eb00 | 463 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 464 | void STSPIN820_ApplySpeed(uint8_t pwmId, uint16_t newSpeed); |
| Davidroid | 1:bc265521eb00 | 465 | void STSPIN820_ApplyTorque(uint8_t deviceId, motor_torque_mode_t torqueMode); |
| Davidroid | 1:bc265521eb00 | 466 | void STSPIN820_ComputeSpeedProfile(uint8_t deviceId, uint32_t nbSteps); |
| Davidroid | 1:bc265521eb00 | 467 | void STSPIN820_FlagInterruptHandler(void); |
| Davidroid | 1:bc265521eb00 | 468 | void STSPIN820_SetDeviceParamsOtherValues(void); |
| Davidroid | 1:bc265521eb00 | 469 | void STSPIN820_SetDeviceParamsToGivenValues(STSPIN820_init_t* initDevicePrm); |
| Davidroid | 1:bc265521eb00 | 470 | void STSPIN820_SetDeviceParamsToPredefinedValues(void); |
| Davidroid | 1:bc265521eb00 | 471 | void STSPIN820_StartMovement(uint8_t deviceId); |
| Davidroid | 1:bc265521eb00 | 472 | void STSPIN820_StepClockHandler(uint8_t deviceId); |
| Davidroid | 1:bc265521eb00 | 473 | MOTOR_vt_t* STSPIN820_GetMotorHandle(void); //Return handle of the motor driver handle |
| Davidroid | 1:bc265521eb00 | 474 | void STSPIN820_Init(void* pInit); //Start the STSPIN820 library |
| Davidroid | 1:bc265521eb00 | 475 | uint16_t STSPIN820_ReadId(void); //Read Id to get driver instance |
| Davidroid | 1:bc265521eb00 | 476 | void STSPIN820_AttachErrorHandler(void (*callback)(uint16_t)); //Attach a user callback to the error handler |
| Davidroid | 1:bc265521eb00 | 477 | void STSPIN820_AttachFlagInterrupt(void (*callback)(void)); //Attach a user callback to the flag Interrupt |
| Davidroid | 1:bc265521eb00 | 478 | uint8_t STSPIN820_CheckStatusHw(void); //Check if STSPIN820 has a fault by reading EN pin position |
| Davidroid | 1:bc265521eb00 | 479 | void STSPIN820_Disable(uint8_t deviceId); //Disable the power stage of the specified device |
| Davidroid | 1:bc265521eb00 | 480 | void STSPIN820_Enable(uint8_t deviceId); //Enable the power stage of the specified device |
| Davidroid | 1:bc265521eb00 | 481 | void STSPIN820_ErrorHandler(uint16_t error); //Error handler which calls the user callback |
| Davidroid | 1:bc265521eb00 | 482 | void STSPIN820_ExitDeviceFromStandby(uint8_t deviceId); //Exit STSPIN820 device from standby |
| Davidroid | 1:bc265521eb00 | 483 | uint16_t STSPIN820_GetAcceleration(uint8_t deviceId); //Return the acceleration in pps^2 |
| Davidroid | 1:bc265521eb00 | 484 | uint16_t STSPIN820_GetCurrentSpeed(uint8_t deviceId); //Return the current speed in pps |
| Davidroid | 1:bc265521eb00 | 485 | motor_decay_mode_t STSPIN820_GetDecayMode(uint8_t deviceId); //Return the device decay mode |
| Davidroid | 1:bc265521eb00 | 486 | uint16_t STSPIN820_GetDeceleration(uint8_t deviceId); //Return the deceleration in pps^2 |
| Davidroid | 1:bc265521eb00 | 487 | motor_state_t STSPIN820_GetDeviceState(uint8_t deviceId); //Return the device state |
| Davidroid | 1:bc265521eb00 | 488 | motor_direction_t STSPIN820_GetDirection(uint8_t deviceId); //Get the motor current direction |
| Davidroid | 1:bc265521eb00 | 489 | uint32_t STSPIN820_GetFwVersion(void); //Return the FW version |
| Davidroid | 1:bc265521eb00 | 490 | int32_t STSPIN820_GetMark(uint8_t deviceId); //Return the mark position |
| Davidroid | 1:bc265521eb00 | 491 | uint16_t STSPIN820_GetMaxSpeed(uint8_t deviceId); //Return the max speed in pps |
| Davidroid | 1:bc265521eb00 | 492 | uint16_t STSPIN820_GetMinSpeed(uint8_t deviceId); //Return the min speed in pps |
| Davidroid | 1:bc265521eb00 | 493 | uint8_t STSPIN820_GetNbDevices(void); //Return the nupber of devices |
| Davidroid | 1:bc265521eb00 | 494 | int32_t STSPIN820_GetPosition(uint8_t deviceId); //Return the ABS_POSITION (32b signed) |
| Davidroid | 1:bc265521eb00 | 495 | motor_step_mode_t STSPIN820_GetStepMode(uint8_t deviceId); //Get the motor step mode |
| Davidroid | 1:bc265521eb00 | 496 | motor_stop_mode_t STSPIN820_GetStopMode(uint8_t deviceId); //Get the selected mode to stop the motor |
| Davidroid | 1:bc265521eb00 | 497 | uint8_t STSPIN820_GetTorque(uint8_t deviceId, motor_torque_mode_t torqueMode); |
| Davidroid | 1:bc265521eb00 | 498 | bool STSPIN820_GetTorqueBoostEnable(uint8_t deviceId); //Get the torque boost feature status |
| Davidroid | 1:bc265521eb00 | 499 | uint16_t STSPIN820_GetTorqueBoostThreshold(uint8_t deviceId); //Get the torque boost threshold |
| Davidroid | 1:bc265521eb00 | 500 | void STSPIN820_GoHome(uint8_t deviceId); //Move to the home position |
| Davidroid | 1:bc265521eb00 | 501 | void STSPIN820_GoMark(uint8_t deviceId); //Move to the Mark position |
| Davidroid | 1:bc265521eb00 | 502 | void STSPIN820_GoTo(uint8_t deviceId, int32_t targetPosition); //Go to the specified position |
| Davidroid | 1:bc265521eb00 | 503 | void STSPIN820_GoToDir(uint8_t deviceId, motor_direction_t direction, int32_t targetPosition); //Go to the specified position using the specified direction |
| Davidroid | 1:bc265521eb00 | 504 | void STSPIN820_HardStop(uint8_t deviceId); //Stop the motor and keep holding torque |
| Davidroid | 1:bc265521eb00 | 505 | void STSPIN820_HardHiZ(uint8_t deviceId); //Stop the motor and disable the power bridge |
| Davidroid | 1:bc265521eb00 | 506 | void STSPIN820_Move(uint8_t deviceId, motor_direction_t direction, uint32_t stepCount); //Move the motor of the specified number of steps |
| Davidroid | 1:bc265521eb00 | 507 | void STSPIN820_PutDeviceInStandby(uint8_t deviceId); //Put STSPIN820 device in standby (low power consumption) |
| Davidroid | 1:bc265521eb00 | 508 | void STSPIN820_Run(uint8_t deviceId, motor_direction_t direction); //Run the motor |
| Davidroid | 1:bc265521eb00 | 509 | bool STSPIN820_SetAcceleration(uint8_t deviceId,uint16_t newAcc); //Set the acceleration in pps^2 |
| Davidroid | 1:bc265521eb00 | 510 | bool STSPIN820_SetDeceleration(uint8_t deviceId,uint16_t newDec); //Set the deceleration in pps^2 |
| Davidroid | 1:bc265521eb00 | 511 | void STSPIN820_SetDecayMode(uint8_t deviceId, motor_decay_mode_t decay); //Set the STSPIN820 decay mode pin |
| Davidroid | 1:bc265521eb00 | 512 | void STSPIN820_SetDirection(uint8_t deviceId, motor_direction_t direction); //Set the STSPIN820 direction pin |
| Davidroid | 1:bc265521eb00 | 513 | void STSPIN820_SetHome(uint8_t deviceId); //Set current position to be the home position |
| Davidroid | 1:bc265521eb00 | 514 | void STSPIN820_SetMark(uint8_t deviceId); //Set current position to be the Markposition |
| Davidroid | 1:bc265521eb00 | 515 | bool STSPIN820_SetMaxSpeed(uint8_t deviceId,uint16_t newMaxSpeed);//Set the max speed in pps |
| Davidroid | 1:bc265521eb00 | 516 | bool STSPIN820_SetMinSpeed(uint8_t deviceId,uint16_t newMinSpeed);//Set the min speed in pps |
| Davidroid | 1:bc265521eb00 | 517 | bool STSPIN820_SetNbDevices(uint8_t nbDevices); |
| Davidroid | 1:bc265521eb00 | 518 | bool STSPIN820_SetStepMode(uint8_t deviceId, motor_step_mode_t stepMode); // Step mode selection |
| Davidroid | 1:bc265521eb00 | 519 | void STSPIN820_SetStopMode(uint8_t deviceId, motor_stop_mode_t stopMode); //Select the mode to stop the motor |
| Davidroid | 1:bc265521eb00 | 520 | void STSPIN820_SetTorque(uint8_t deviceId, motor_torque_mode_t torqueMode, uint8_t torqueValue); |
| Davidroid | 1:bc265521eb00 | 521 | void STSPIN820_SetTorqueBoostEnable(uint8_t deviceId, bool enable); // Enable or disable the torque boost feature |
| Davidroid | 1:bc265521eb00 | 522 | void STSPIN820_SetTorqueBoostThreshold(uint8_t deviceId, uint16_t speedThreshold); //Set the torque boost threshold |
| Davidroid | 1:bc265521eb00 | 523 | bool STSPIN820_SoftStop(uint8_t deviceId); //Progressively stop the motor by using the device deceleration and set deceleration torque |
| Davidroid | 1:bc265521eb00 | 524 | uint32_t STSPIN820_VrefPwmGetFreq(uint8_t deviceId); //Get the frequency of REF PWM of the specified device |
| Davidroid | 1:bc265521eb00 | 525 | void STSPIN820_VrefPwmSetFreq(uint8_t deviceId, uint32_t newFreq);//Set the frequency of REF PWM of the specified device |
| Davidroid | 1:bc265521eb00 | 526 | void STSPIN820_WaitWhileActive(uint8_t deviceId); //Wait for the device state becomes Inactive |
| Davidroid | 1:bc265521eb00 | 527 | |
| Davidroid | 1:bc265521eb00 | 528 | |
| Davidroid | 1:bc265521eb00 | 529 | /*** Component's I/O Methods ***/ |
| Davidroid | 1:bc265521eb00 | 530 | |
| Davidroid | 1:bc265521eb00 | 531 | /** |
| Davidroid | 1:bc265521eb00 | 532 | * @brief Utility function to read data from STSPIN820. |
| Davidroid | 1:bc265521eb00 | 533 | * @param[out] pBuffer pointer to the buffer to read data into. |
| Davidroid | 1:bc265521eb00 | 534 | * @param[in] NumBytesToRead number of bytes to read. |
| Davidroid | 1:bc265521eb00 | 535 | * @retval COMPONENT_OK in case of success, COMPONENT_ERROR otherwise. |
| Davidroid | 1:bc265521eb00 | 536 | */ |
| Davidroid | 1:bc265521eb00 | 537 | status_t read(uint8_t* pBuffer, uint16_t NumBytesToRead) |
| Davidroid | 1:bc265521eb00 | 538 | { |
| Davidroid | 1:bc265521eb00 | 539 | if (dev_spi.spi_read(pBuffer, ssel, NumBytesToRead) != 0) |
| Davidroid | 1:bc265521eb00 | 540 | return COMPONENT_ERROR; |
| Davidroid | 1:bc265521eb00 | 541 | return COMPONENT_OK; |
| Davidroid | 1:bc265521eb00 | 542 | } |
| Davidroid | 1:bc265521eb00 | 543 | |
| Davidroid | 1:bc265521eb00 | 544 | /** |
| Davidroid | 1:bc265521eb00 | 545 | * @brief Utility function to write data to STSPIN820. |
| Davidroid | 1:bc265521eb00 | 546 | * @param[in] pBuffer pointer to the buffer of data to send. |
| Davidroid | 1:bc265521eb00 | 547 | * @param[in] NumBytesToWrite number of bytes to write. |
| Davidroid | 1:bc265521eb00 | 548 | * @retval COMPONENT_OK in case of success, COMPONENT_ERROR otherwise. |
| Davidroid | 1:bc265521eb00 | 549 | */ |
| Davidroid | 1:bc265521eb00 | 550 | status_t write(uint8_t* pBuffer, uint16_t NumBytesToWrite) |
| Davidroid | 1:bc265521eb00 | 551 | { |
| Davidroid | 1:bc265521eb00 | 552 | if (dev_spi.spi_write(pBuffer, ssel, NumBytesToWrite) != 0) |
| Davidroid | 1:bc265521eb00 | 553 | return COMPONENT_ERROR; |
| Davidroid | 1:bc265521eb00 | 554 | return COMPONENT_OK; |
| Davidroid | 1:bc265521eb00 | 555 | } |
| Davidroid | 1:bc265521eb00 | 556 | |
| Davidroid | 1:bc265521eb00 | 557 | /** |
| Davidroid | 1:bc265521eb00 | 558 | * @brief Utility function to read and write data from/to STSPIN820 at the same time. |
| Davidroid | 1:bc265521eb00 | 559 | * @param[out] pBufferToRead pointer to the buffer to read data into. |
| Davidroid | 1:bc265521eb00 | 560 | * @param[in] pBufferToWrite pointer to the buffer of data to send. |
| Davidroid | 1:bc265521eb00 | 561 | * @param[in] NumBytes number of bytes to read and write. |
| Davidroid | 1:bc265521eb00 | 562 | * @retval COMPONENT_OK in case of success, COMPONENT_ERROR otherwise. |
| Davidroid | 1:bc265521eb00 | 563 | */ |
| Davidroid | 1:bc265521eb00 | 564 | status_t read_write(uint8_t* pBufferToRead, uint8_t* pBufferToWrite, uint16_t NumBytes) |
| Davidroid | 1:bc265521eb00 | 565 | { |
| Davidroid | 1:bc265521eb00 | 566 | if (dev_spi.spi_read_write(pBufferToRead, pBufferToWrite, ssel, NumBytes) != 0) |
| Davidroid | 1:bc265521eb00 | 567 | return COMPONENT_ERROR; |
| Davidroid | 1:bc265521eb00 | 568 | return COMPONENT_OK; |
| Davidroid | 1:bc265521eb00 | 569 | } |
| Davidroid | 1:bc265521eb00 | 570 | |
| Davidroid | 1:bc265521eb00 | 571 | /* ACTION 8 --------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 572 | * Implement here other I/O methods beyond those already implemented * |
| Davidroid | 1:bc265521eb00 | 573 | * above, which are declared extern within the component's header file. * |
| Davidroid | 1:bc265521eb00 | 574 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 575 | void STSPIN820_Board_Delay(uint32_t delay) |
| Davidroid | 1:bc265521eb00 | 576 | { |
| Davidroid | 1:bc265521eb00 | 577 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 578 | } |
| Davidroid | 1:bc265521eb00 | 579 | |
| Davidroid | 1:bc265521eb00 | 580 | void STSPIN820_Board_Disable(void) |
| Davidroid | 1:bc265521eb00 | 581 | { |
| Davidroid | 1:bc265521eb00 | 582 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 583 | } |
| Davidroid | 1:bc265521eb00 | 584 | |
| Davidroid | 1:bc265521eb00 | 585 | void STSPIN820_Board_DisableIrq(void) |
| Davidroid | 1:bc265521eb00 | 586 | { |
| Davidroid | 1:bc265521eb00 | 587 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 588 | } |
| Davidroid | 1:bc265521eb00 | 589 | |
| Davidroid | 1:bc265521eb00 | 590 | uint32_t STSPIN820_Board_EN_AND_FAULT_PIN_GetState(void) |
| Davidroid | 1:bc265521eb00 | 591 | { |
| Davidroid | 1:bc265521eb00 | 592 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 593 | return (uint32_t) 0; |
| Davidroid | 1:bc265521eb00 | 594 | } |
| Davidroid | 1:bc265521eb00 | 595 | |
| Davidroid | 1:bc265521eb00 | 596 | void STSPIN820_Board_Enable(void) |
| Davidroid | 1:bc265521eb00 | 597 | { |
| Davidroid | 1:bc265521eb00 | 598 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 599 | } |
| Davidroid | 1:bc265521eb00 | 600 | |
| Davidroid | 1:bc265521eb00 | 601 | void STSPIN820_Board_EnableIrq(void) |
| Davidroid | 1:bc265521eb00 | 602 | { |
| Davidroid | 1:bc265521eb00 | 603 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 604 | } |
| Davidroid | 1:bc265521eb00 | 605 | |
| Davidroid | 1:bc265521eb00 | 606 | void STSPIN820_Board_GpioInit(void) |
| Davidroid | 1:bc265521eb00 | 607 | { |
| Davidroid | 1:bc265521eb00 | 608 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 609 | } |
| Davidroid | 1:bc265521eb00 | 610 | |
| Davidroid | 1:bc265521eb00 | 611 | void STSPIN820_Board_PwmRefInit(void) |
| Davidroid | 1:bc265521eb00 | 612 | { |
| Davidroid | 1:bc265521eb00 | 613 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 614 | } |
| Davidroid | 1:bc265521eb00 | 615 | |
| Davidroid | 1:bc265521eb00 | 616 | void STSPIN820_Board_PwmRefSetFreqAndDutyCycle(uint32_t newFreq, uint8_t dutyCycle) |
| Davidroid | 1:bc265521eb00 | 617 | { |
| Davidroid | 1:bc265521eb00 | 618 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 619 | } |
| Davidroid | 1:bc265521eb00 | 620 | |
| Davidroid | 1:bc265521eb00 | 621 | void STSPIN820_Board_PwmRefStart(void) |
| Davidroid | 1:bc265521eb00 | 622 | { |
| Davidroid | 1:bc265521eb00 | 623 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 624 | } |
| Davidroid | 1:bc265521eb00 | 625 | |
| Davidroid | 1:bc265521eb00 | 626 | void STSPIN820_Board_PwmRefStop(void) |
| Davidroid | 1:bc265521eb00 | 627 | { |
| Davidroid | 1:bc265521eb00 | 628 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 629 | } |
| Davidroid | 1:bc265521eb00 | 630 | |
| Davidroid | 1:bc265521eb00 | 631 | void STSPIN820_Board_ReleaseReset(void) |
| Davidroid | 1:bc265521eb00 | 632 | { |
| Davidroid | 1:bc265521eb00 | 633 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 634 | } |
| Davidroid | 1:bc265521eb00 | 635 | |
| Davidroid | 1:bc265521eb00 | 636 | void STSPIN820_Board_Reset(void) |
| Davidroid | 1:bc265521eb00 | 637 | { |
| Davidroid | 1:bc265521eb00 | 638 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 639 | } |
| Davidroid | 1:bc265521eb00 | 640 | |
| Davidroid | 1:bc265521eb00 | 641 | void STSPIN820_Board_SetDecayGpio(uint8_t gpioState) |
| Davidroid | 1:bc265521eb00 | 642 | { |
| Davidroid | 1:bc265521eb00 | 643 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 644 | } |
| Davidroid | 1:bc265521eb00 | 645 | |
| Davidroid | 1:bc265521eb00 | 646 | uint8_t STSPIN820_Board_GetDecayGpio(void) |
| Davidroid | 1:bc265521eb00 | 647 | { |
| Davidroid | 1:bc265521eb00 | 648 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 649 | return (uint8_t) 0; |
| Davidroid | 1:bc265521eb00 | 650 | } |
| Davidroid | 1:bc265521eb00 | 651 | |
| Davidroid | 1:bc265521eb00 | 652 | void STSPIN820_Board_SetDirectionGpio(uint8_t gpioState) |
| Davidroid | 1:bc265521eb00 | 653 | { |
| Davidroid | 1:bc265521eb00 | 654 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 655 | } |
| Davidroid | 1:bc265521eb00 | 656 | |
| Davidroid | 1:bc265521eb00 | 657 | void STSPIN820_Board_SetFullStep(void) |
| Davidroid | 1:bc265521eb00 | 658 | { |
| Davidroid | 1:bc265521eb00 | 659 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 660 | } |
| Davidroid | 1:bc265521eb00 | 661 | |
| Davidroid | 1:bc265521eb00 | 662 | bool STSPIN820_Board_SetModePins(uint8_t modePin1Level, uint8_t modePin2Level, uint8_t modePin3Level) |
| Davidroid | 1:bc265521eb00 | 663 | { |
| Davidroid | 1:bc265521eb00 | 664 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 665 | return (bool) 0; |
| Davidroid | 1:bc265521eb00 | 666 | } |
| Davidroid | 1:bc265521eb00 | 667 | |
| Davidroid | 1:bc265521eb00 | 668 | void STSPIN820_Board_TimStckCompareInit(void) |
| Davidroid | 1:bc265521eb00 | 669 | { |
| Davidroid | 1:bc265521eb00 | 670 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 671 | } |
| Davidroid | 1:bc265521eb00 | 672 | |
| Davidroid | 1:bc265521eb00 | 673 | void STSPIN820_Board_TimStckDeInit(void) |
| Davidroid | 1:bc265521eb00 | 674 | { |
| Davidroid | 1:bc265521eb00 | 675 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 676 | } |
| Davidroid | 1:bc265521eb00 | 677 | |
| Davidroid | 1:bc265521eb00 | 678 | void STSPIN820_Board_TimStckInit(void) |
| Davidroid | 1:bc265521eb00 | 679 | { |
| Davidroid | 1:bc265521eb00 | 680 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 681 | } |
| Davidroid | 1:bc265521eb00 | 682 | |
| Davidroid | 1:bc265521eb00 | 683 | void STSPIN820_Board_TimStckSetFreq(uint16_t newFreq) |
| Davidroid | 1:bc265521eb00 | 684 | { |
| Davidroid | 1:bc265521eb00 | 685 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 686 | } |
| Davidroid | 1:bc265521eb00 | 687 | |
| Davidroid | 1:bc265521eb00 | 688 | void STSPIN820_Board_TimStckStart(void) |
| Davidroid | 1:bc265521eb00 | 689 | { |
| Davidroid | 1:bc265521eb00 | 690 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 691 | } |
| Davidroid | 1:bc265521eb00 | 692 | |
| Davidroid | 1:bc265521eb00 | 693 | uint8_t STSPIN820_Board_TimStckStop(uint8_t *pToggleOdd) |
| Davidroid | 1:bc265521eb00 | 694 | { |
| Davidroid | 1:bc265521eb00 | 695 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 696 | return (uint8_t) 0; |
| Davidroid | 1:bc265521eb00 | 697 | } |
| Davidroid | 1:bc265521eb00 | 698 | |
| Davidroid | 1:bc265521eb00 | 699 | void STSPIN820_Board_UnsetFullStep(void) |
| Davidroid | 1:bc265521eb00 | 700 | { |
| Davidroid | 1:bc265521eb00 | 701 | /* TO BE IMPLEMENTED BY USING TARGET PLATFORM'S APIs. */ |
| Davidroid | 1:bc265521eb00 | 702 | } |
| Davidroid | 1:bc265521eb00 | 703 | |
| Davidroid | 1:bc265521eb00 | 704 | |
| Davidroid | 1:bc265521eb00 | 705 | /*** Component's Instance Variables ***/ |
| Davidroid | 1:bc265521eb00 | 706 | |
| Davidroid | 1:bc265521eb00 | 707 | /* ACTION 9 --------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 708 | * Declare here interrupt related variables, if needed. * |
| Davidroid | 1:bc265521eb00 | 709 | * Note that interrupt handling is platform dependent, see * |
| Davidroid | 1:bc265521eb00 | 710 | * "Interrupt Related Methods" above. * |
| Davidroid | 1:bc265521eb00 | 711 | * * |
| Davidroid | 1:bc265521eb00 | 712 | * Example: * |
| Davidroid | 1:bc265521eb00 | 713 | * + mbed: * |
| Davidroid | 1:bc265521eb00 | 714 | * InterruptIn feature_irq; * |
| Davidroid | 1:bc265521eb00 | 715 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 716 | |
| Davidroid | 1:bc265521eb00 | 717 | /* ACTION 10 -------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 718 | * Declare here other pin related variables, if needed. * |
| Davidroid | 1:bc265521eb00 | 719 | * * |
| Davidroid | 1:bc265521eb00 | 720 | * Example: * |
| Davidroid | 1:bc265521eb00 | 721 | * + mbed: * |
| Davidroid | 1:bc265521eb00 | 722 | * DigitalOut standby_reset; * |
| Davidroid | 1:bc265521eb00 | 723 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 724 | |
| Davidroid | 1:bc265521eb00 | 725 | /* ACTION 11 -------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 726 | * Declare here communication related variables, if needed. * |
| Davidroid | 1:bc265521eb00 | 727 | * * |
| Davidroid | 1:bc265521eb00 | 728 | * Example: * |
| Davidroid | 1:bc265521eb00 | 729 | * + mbed: * |
| Davidroid | 1:bc265521eb00 | 730 | * DigitalOut ssel; * |
| Davidroid | 1:bc265521eb00 | 731 | * DevSPI &dev_spi; * |
| Davidroid | 1:bc265521eb00 | 732 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 733 | /* Configuration. */ |
| Davidroid | 1:bc265521eb00 | 734 | DigitalOut ssel; |
| Davidroid | 1:bc265521eb00 | 735 | |
| Davidroid | 1:bc265521eb00 | 736 | /* IO Device. */ |
| Davidroid | 1:bc265521eb00 | 737 | DevSPI &dev_spi; |
| Davidroid | 1:bc265521eb00 | 738 | |
| Davidroid | 1:bc265521eb00 | 739 | /* ACTION 12 -------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 740 | * Declare here identity related variables, if needed. * |
| Davidroid | 1:bc265521eb00 | 741 | * Note that there should be only a unique identifier for each component, * |
| Davidroid | 1:bc265521eb00 | 742 | * which should be the "who_am_i" parameter. * |
| Davidroid | 1:bc265521eb00 | 743 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 744 | /* Identity */ |
| Davidroid | 1:bc265521eb00 | 745 | uint8_t who_am_i; |
| Davidroid | 1:bc265521eb00 | 746 | |
| Davidroid | 1:bc265521eb00 | 747 | /* ACTION 13 -------------------------------------------------------------* |
| Davidroid | 1:bc265521eb00 | 748 | * Declare here the component's static and non-static data, one variable * |
| Davidroid | 1:bc265521eb00 | 749 | * per line. * |
| Davidroid | 1:bc265521eb00 | 750 | * * |
| Davidroid | 1:bc265521eb00 | 751 | * Example: * |
| Davidroid | 1:bc265521eb00 | 752 | * float measure; * |
| Davidroid | 1:bc265521eb00 | 753 | * int instance_id; * |
| Davidroid | 1:bc265521eb00 | 754 | * static int number_of_instances; * |
| Davidroid | 1:bc265521eb00 | 755 | *------------------------------------------------------------------------*/ |
| Davidroid | 1:bc265521eb00 | 756 | void (*flag_interrupt_callback)(void); |
| Davidroid | 1:bc265521eb00 | 757 | void (*error_handler_callback)(uint16_t error); |
| Davidroid | 1:bc265521eb00 | 758 | uint8_t toggle_odd; |
| Davidroid | 1:bc265521eb00 | 759 | device_params_t device_prm; |
| Davidroid | 1:bc265521eb00 | 760 | uint8_t number_of_devices; |
| Davidroid | 1:bc265521eb00 | 761 | uint8_t device_instance; |
| Davidroid | 1:bc265521eb00 | 762 | }; |
| Davidroid | 1:bc265521eb00 | 763 | |
| Davidroid | 1:bc265521eb00 | 764 | #endif /* __STSPIN820_CLASS_H */ |
| Davidroid | 1:bc265521eb00 | 765 | |
| Davidroid | 1:bc265521eb00 | 766 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |