Arkadi Rafalovich / X_NUCLEO_IHM01A1_Disabled_Control

Personal fork of the library for direct control instead of library control

Dependencies:   X_NUCLEO_COMMON

Dependents:   Thesis_Rotating_Platform

Fork of X_NUCLEO_IHM01A1 by Arkadi Rafalovich

Components/l6474/l6474_class.cpp@7:f7e0c3621f77, 2015-11-20 (annotated)

Committer:
Davidroid
Date:
Fri Nov 20 18:00:03 2015 +0000
Revision:
7:f7e0c3621f77
Parent:
6:a47569fc7534
Child:
13:ba2728afe4c2
+ FLAG interrupt handling added.; + Doxygen documentation ongoing.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Davidroid 0:2887415a46cd 1 /**
Davidroid 0:2887415a46cd 2 ******************************************************************************
Davidroid 0:2887415a46cd 3 * @file l6474_class.cpp
Davidroid 0:2887415a46cd 4 * @author IPC Rennes
Davidroid 0:2887415a46cd 5 * @version V1.5.0
Davidroid 0:2887415a46cd 6 * @date November 12, 2014
Davidroid 0:2887415a46cd 7 * @brief L6474 driver (fully integrated microstepping motor driver)
Davidroid 0:2887415a46cd 8 * @note (C) COPYRIGHT 2014 STMicroelectronics
Davidroid 0:2887415a46cd 9 ******************************************************************************
Davidroid 0:2887415a46cd 10 * @attention
Davidroid 0:2887415a46cd 11 *
Davidroid 0:2887415a46cd 12 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
Davidroid 0:2887415a46cd 13 *
Davidroid 0:2887415a46cd 14 * Redistribution and use in source and binary forms, with or without modification,
Davidroid 0:2887415a46cd 15 * are permitted provided that the following conditions are met:
Davidroid 0:2887415a46cd 16 * 1. Redistributions of source code must retain the above copyright notice,
Davidroid 0:2887415a46cd 17 * this list of conditions and the following disclaimer.
Davidroid 0:2887415a46cd 18 * 2. Redistributions in binary form must reproduce the above copyright notice,
Davidroid 0:2887415a46cd 19 * this list of conditions and the following disclaimer in the documentation
Davidroid 0:2887415a46cd 20 * and/or other materials provided with the distribution.
Davidroid 0:2887415a46cd 21 * 3. Neither the name of STMicroelectronics nor the names of its contributors
Davidroid 0:2887415a46cd 22 * may be used to endorse or promote products derived from this software
Davidroid 0:2887415a46cd 23 * without specific prior written permission.
Davidroid 0:2887415a46cd 24 *
Davidroid 0:2887415a46cd 25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
Davidroid 0:2887415a46cd 26 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
Davidroid 0:2887415a46cd 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
Davidroid 0:2887415a46cd 28 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
Davidroid 0:2887415a46cd 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
Davidroid 0:2887415a46cd 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
Davidroid 0:2887415a46cd 31 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
Davidroid 0:2887415a46cd 32 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
Davidroid 0:2887415a46cd 33 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
Davidroid 0:2887415a46cd 34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Davidroid 0:2887415a46cd 35 *
Davidroid 0:2887415a46cd 36 ******************************************************************************
Davidroid 0:2887415a46cd 37 */
Davidroid 0:2887415a46cd 38
Davidroid 0:2887415a46cd 39
Davidroid 0:2887415a46cd 40 /* Generated with Stm32CubeTOO -----------------------------------------------*/
Davidroid 0:2887415a46cd 41
Davidroid 0:2887415a46cd 42
Davidroid 0:2887415a46cd 43 /* Revision ------------------------------------------------------------------*/
Davidroid 0:2887415a46cd 44 /*
Davidroid 0:2887415a46cd 45 Repository: http://svn.x-nucleodev.codex.cro.st.com/svnroot/X-NucleoDev
Davidroid 0:2887415a46cd 46 Branch/Trunk/Tag: trunk
Davidroid 0:2887415a46cd 47 Based on: X-CUBE-SPN1/trunk/Drivers/BSP/Components/l6474/l6474.c
Davidroid 1:b38ebb8ea286 48 Revision: :0
Davidroid 0:2887415a46cd 49 */
Davidroid 0:2887415a46cd 50
Davidroid 0:2887415a46cd 51
Davidroid 0:2887415a46cd 52 /* Includes ------------------------------------------------------------------*/
Davidroid 0:2887415a46cd 53
Davidroid 0:2887415a46cd 54 #include "l6474_class.h"
Davidroid 0:2887415a46cd 55 #include "l6474.h"
Davidroid 0:2887415a46cd 56
Davidroid 1:b38ebb8ea286 57
Davidroid 1:b38ebb8ea286 58 /* Private constants ---------------------------------------------------------*/
Davidroid 0:2887415a46cd 59
Davidroid 0:2887415a46cd 60 /// Error while initialising the SPI
Davidroid 5:d3c78f12a78d 61 #define L6474_ERROR_0 (0x8000)
Davidroid 0:2887415a46cd 62 /// Error: Bad SPI transaction
Davidroid 5:d3c78f12a78d 63 #define L6474_ERROR_1 (0x8001)
Davidroid 0:2887415a46cd 64
Davidroid 0:2887415a46cd 65 /// Maximum number of steps
Davidroid 5:d3c78f12a78d 66 #define MAX_STEPS (0x7FFFFFFF)
Davidroid 0:2887415a46cd 67
Davidroid 0:2887415a46cd 68 /// Maximum frequency of the PWMs in Hz
Davidroid 0:2887415a46cd 69 #define L6474_MAX_PWM_FREQ (10000)
Davidroid 0:2887415a46cd 70
Davidroid 0:2887415a46cd 71 /// Minimum frequency of the PWMs in Hz
Davidroid 0:2887415a46cd 72 #define L6474_MIN_PWM_FREQ (2)
Davidroid 0:2887415a46cd 73
Davidroid 0:2887415a46cd 74
Davidroid 0:2887415a46cd 75 /* Private variables --------------------------------------------------------*/
Davidroid 0:2887415a46cd 76
Davidroid 0:2887415a46cd 77 /* Number of devices. */
Davidroid 0:2887415a46cd 78 uint8_t L6474::numberOfDevices = 0;
Davidroid 0:2887415a46cd 79
Davidroid 6:a47569fc7534 80 /* ISR flags used to restart an interrupted SPI transfer when an error is reported. */
Davidroid 6:a47569fc7534 81 bool L6474::spiPreemtionByIsr = FALSE;
Davidroid 6:a47569fc7534 82 bool L6474::isrFlag = FALSE;
Davidroid 6:a47569fc7534 83
Davidroid 5:d3c78f12a78d 84 /* SPI Transmission for Daisy-Chain Configuration. */
Davidroid 5:d3c78f12a78d 85 uint8_t L6474::spiTxBursts[L6474_CMD_ARG_MAX_NB_BYTES][MAX_NUMBER_OF_DEVICES];
Davidroid 5:d3c78f12a78d 86 uint8_t L6474::spiRxBursts[L6474_CMD_ARG_MAX_NB_BYTES][MAX_NUMBER_OF_DEVICES];
Davidroid 5:d3c78f12a78d 87
Davidroid 0:2887415a46cd 88
Davidroid 1:b38ebb8ea286 89 /* Methods -------------------------------------------------------------------*/
Davidroid 0:2887415a46cd 90
Davidroid 5:d3c78f12a78d 91 /**********************************************************
Davidroid 0:2887415a46cd 92 * @brief Attaches a user callback to the error Handler.
Davidroid 0:2887415a46cd 93 * The call back will be then called each time the library
Davidroid 0:2887415a46cd 94 * detects an error
Davidroid 0:2887415a46cd 95 * @param[in] callback Name of the callback to attach
Davidroid 0:2887415a46cd 96 * to the error Hanlder
Davidroid 0:2887415a46cd 97 * @retval None
Davidroid 0:2887415a46cd 98 **********************************************************/
Davidroid 0:2887415a46cd 99 void L6474::L6474_AttachErrorHandler(void (*callback)(uint16_t error))
Davidroid 0:2887415a46cd 100 {
Davidroid 0:2887415a46cd 101 errorHandlerCallback = (void (*)(uint16_t error)) callback;
Davidroid 0:2887415a46cd 102 }
Davidroid 0:2887415a46cd 103
Davidroid 5:d3c78f12a78d 104 /**********************************************************
Davidroid 0:2887415a46cd 105 * @brief Starts the L6474 library
Davidroid 0:2887415a46cd 106 * @retval COMPONENT_OK in case of success
Davidroid 0:2887415a46cd 107 **********************************************************/
Davidroid 0:2887415a46cd 108 DrvStatusTypeDef L6474::L6474_Init(MOTOR_InitTypeDef *L6474_Init)
Davidroid 0:2887415a46cd 109 {
Davidroid 0:2887415a46cd 110 /* Initialise the PWMs used for the Step clocks ----------------------------*/
Davidroid 0:2887415a46cd 111 L6474_PwmInit();
Davidroid 0:2887415a46cd 112
Davidroid 0:2887415a46cd 113 /* Initialise the L6474s ------------------------------------------------*/
Davidroid 0:2887415a46cd 114
Davidroid 0:2887415a46cd 115 /* Standby-reset deactivation */
Davidroid 0:2887415a46cd 116 L6474_ReleaseReset();
Davidroid 0:2887415a46cd 117
Davidroid 0:2887415a46cd 118 /* Let a delay after reset */
Davidroid 0:2887415a46cd 119 L6474_Delay(1);
Davidroid 0:2887415a46cd 120
Davidroid 0:2887415a46cd 121 /* Set all registers and context variables to the predefined values from l6474_target_config.h */
Davidroid 0:2887415a46cd 122 L6474_SetDeviceParamsToPredefinedValues();
Davidroid 0:2887415a46cd 123
Davidroid 0:2887415a46cd 124 /* Disable L6474 powerstage */
Davidroid 0:2887415a46cd 125 L6474_CmdDisable();
Davidroid 0:2887415a46cd 126
Davidroid 0:2887415a46cd 127 /* Get Status to clear flags after start up */
Davidroid 0:2887415a46cd 128 L6474_CmdGetStatus();
Davidroid 0:2887415a46cd 129
Davidroid 0:2887415a46cd 130 return COMPONENT_OK;
Davidroid 0:2887415a46cd 131 }
Davidroid 0:2887415a46cd 132
Davidroid 5:d3c78f12a78d 133 /**********************************************************
Davidroid 0:2887415a46cd 134 * @brief Read id
Davidroid 0:2887415a46cd 135 * @param id pointer to the identifier to be read.
Davidroid 0:2887415a46cd 136 * @retval COMPONENT_OK in case of success
Davidroid 0:2887415a46cd 137 **********************************************************/
Davidroid 0:2887415a46cd 138 DrvStatusTypeDef L6474::L6474_ReadID(uint8_t *id)
Davidroid 0:2887415a46cd 139 {
Davidroid 1:b38ebb8ea286 140 *id = deviceInstance;
Davidroid 0:2887415a46cd 141
Davidroid 0:2887415a46cd 142 return COMPONENT_OK;
Davidroid 0:2887415a46cd 143 }
Davidroid 0:2887415a46cd 144
Davidroid 5:d3c78f12a78d 145 /**********************************************************
Davidroid 0:2887415a46cd 146 * @brief Returns the acceleration of the specified device
Davidroid 0:2887415a46cd 147 * @retval Acceleration in pps^2
Davidroid 0:2887415a46cd 148 **********************************************************/
Davidroid 0:2887415a46cd 149 uint16_t L6474::L6474_GetAcceleration(void)
Davidroid 0:2887415a46cd 150 {
Davidroid 0:2887415a46cd 151 return (devicePrm.acceleration);
Davidroid 0:2887415a46cd 152 }
Davidroid 0:2887415a46cd 153
Davidroid 5:d3c78f12a78d 154 /**********************************************************
Davidroid 0:2887415a46cd 155 * @brief Returns the current speed of the specified device
Davidroid 0:2887415a46cd 156 * @retval Speed in pps
Davidroid 0:2887415a46cd 157 **********************************************************/
Davidroid 0:2887415a46cd 158 uint16_t L6474::L6474_GetCurrentSpeed(void)
Davidroid 0:2887415a46cd 159 {
Davidroid 0:2887415a46cd 160 return devicePrm.speed;
Davidroid 0:2887415a46cd 161 }
Davidroid 0:2887415a46cd 162
Davidroid 5:d3c78f12a78d 163 /**********************************************************
Davidroid 0:2887415a46cd 164 * @brief Returns the deceleration of the specified device
Davidroid 0:2887415a46cd 165 * @retval Deceleration in pps^2
Davidroid 0:2887415a46cd 166 **********************************************************/
Davidroid 0:2887415a46cd 167 uint16_t L6474::L6474_GetDeceleration(void)
Davidroid 0:2887415a46cd 168 {
Davidroid 0:2887415a46cd 169 return (devicePrm.deceleration);
Davidroid 0:2887415a46cd 170 }
Davidroid 0:2887415a46cd 171
Davidroid 5:d3c78f12a78d 172 /**********************************************************
Davidroid 0:2887415a46cd 173 * @brief Returns the device state
Davidroid 0:2887415a46cd 174 * @retval State (ACCELERATING, DECELERATING, STEADY or INACTIVE)
Davidroid 0:2887415a46cd 175 **********************************************************/
Davidroid 0:2887415a46cd 176 motorState_t L6474::L6474_GetDeviceState(void)
Davidroid 0:2887415a46cd 177 {
Davidroid 0:2887415a46cd 178 return devicePrm.motionState;
Davidroid 0:2887415a46cd 179 }
Davidroid 0:2887415a46cd 180
Davidroid 5:d3c78f12a78d 181 /**********************************************************
Davidroid 0:2887415a46cd 182 * @brief Returns the FW version of the library
Davidroid 0:2887415a46cd 183 * @param None
Davidroid 0:2887415a46cd 184 * @retval L6474_FW_VERSION
Davidroid 0:2887415a46cd 185 **********************************************************/
Davidroid 0:2887415a46cd 186 uint8_t L6474::L6474_GetFwVersion(void)
Davidroid 0:2887415a46cd 187 {
Davidroid 0:2887415a46cd 188 return (L6474_FW_VERSION);
Davidroid 0:2887415a46cd 189 }
Davidroid 0:2887415a46cd 190
Davidroid 5:d3c78f12a78d 191 /**********************************************************
Davidroid 0:2887415a46cd 192 * @brief Returns the mark position of the specified device
Davidroid 0:2887415a46cd 193 * @retval Mark register value converted in a 32b signed integer
Davidroid 0:2887415a46cd 194 **********************************************************/
Davidroid 0:2887415a46cd 195 int32_t L6474::L6474_GetMark(void)
Davidroid 0:2887415a46cd 196 {
Davidroid 0:2887415a46cd 197 return L6474_ConvertPosition(L6474_CmdGetParam(L6474_MARK));
Davidroid 0:2887415a46cd 198 }
Davidroid 0:2887415a46cd 199
Davidroid 5:d3c78f12a78d 200 /**********************************************************
Davidroid 0:2887415a46cd 201 * @brief Returns the max speed of the specified device
Davidroid 0:2887415a46cd 202 * @retval maxSpeed in pps
Davidroid 0:2887415a46cd 203 **********************************************************/
Davidroid 0:2887415a46cd 204 uint16_t L6474::L6474_GetMaxSpeed(void)
Davidroid 0:2887415a46cd 205 {
Davidroid 0:2887415a46cd 206 return (devicePrm.maxSpeed);
Davidroid 0:2887415a46cd 207 }
Davidroid 0:2887415a46cd 208
Davidroid 5:d3c78f12a78d 209 /**********************************************************
Davidroid 0:2887415a46cd 210 * @brief Returns the min speed of the specified device
Davidroid 0:2887415a46cd 211 * @retval minSpeed in pps
Davidroid 0:2887415a46cd 212 **********************************************************/
Davidroid 0:2887415a46cd 213 uint16_t L6474::L6474_GetMinSpeed(void)
Davidroid 0:2887415a46cd 214 {
Davidroid 0:2887415a46cd 215 return (devicePrm.minSpeed);
Davidroid 0:2887415a46cd 216 }
Davidroid 0:2887415a46cd 217
Davidroid 5:d3c78f12a78d 218 /**********************************************************
Davidroid 0:2887415a46cd 219 * @brief Returns the ABS_POSITION of the specified device
Davidroid 0:2887415a46cd 220 * @retval ABS_POSITION register value converted in a 32b signed integer
Davidroid 0:2887415a46cd 221 **********************************************************/
Davidroid 0:2887415a46cd 222 int32_t L6474::L6474_GetPosition(void)
Davidroid 0:2887415a46cd 223 {
Davidroid 0:2887415a46cd 224 return L6474_ConvertPosition(L6474_CmdGetParam(L6474_ABS_POS));
Davidroid 0:2887415a46cd 225 }
Davidroid 0:2887415a46cd 226
Davidroid 5:d3c78f12a78d 227 /**********************************************************
Davidroid 0:2887415a46cd 228 * @brief Requests the motor to move to the home position (ABS_POSITION = 0)
Davidroid 0:2887415a46cd 229 * @retval None
Davidroid 0:2887415a46cd 230 **********************************************************/
Davidroid 0:2887415a46cd 231 void L6474::L6474_GoHome(void)
Davidroid 0:2887415a46cd 232 {
Davidroid 0:2887415a46cd 233 L6474_GoTo(0);
Davidroid 0:2887415a46cd 234 }
Davidroid 0:2887415a46cd 235
Davidroid 5:d3c78f12a78d 236 /**********************************************************
Davidroid 0:2887415a46cd 237 * @brief Requests the motor to move to the mark position
Davidroid 0:2887415a46cd 238 * @retval None
Davidroid 0:2887415a46cd 239 **********************************************************/
Davidroid 0:2887415a46cd 240 void L6474::L6474_GoMark(void)
Davidroid 0:2887415a46cd 241 {
Davidroid 0:2887415a46cd 242 uint32_t mark;
Davidroid 0:2887415a46cd 243
Davidroid 0:2887415a46cd 244 mark = L6474_ConvertPosition(L6474_CmdGetParam(L6474_MARK));
Davidroid 0:2887415a46cd 245 L6474_GoTo(mark);
Davidroid 0:2887415a46cd 246 }
Davidroid 0:2887415a46cd 247
Davidroid 5:d3c78f12a78d 248 /**********************************************************
Davidroid 0:2887415a46cd 249 * @brief Requests the motor to move to the specified position
Davidroid 0:2887415a46cd 250 * @param[in] targetPosition absolute position in steps
Davidroid 0:2887415a46cd 251 * @retval None
Davidroid 0:2887415a46cd 252 **********************************************************/
Davidroid 0:2887415a46cd 253 void L6474::L6474_GoTo(int32_t targetPosition)
Davidroid 0:2887415a46cd 254 {
Davidroid 5:d3c78f12a78d 255 motorDir_t direction;
Davidroid 0:2887415a46cd 256 int32_t steps;
Davidroid 0:2887415a46cd 257
Davidroid 0:2887415a46cd 258 /* Eventually deactivate motor */
Davidroid 0:2887415a46cd 259 if (devicePrm.motionState != INACTIVE)
Davidroid 0:2887415a46cd 260 {
Davidroid 0:2887415a46cd 261 L6474_HardStop();
Davidroid 0:2887415a46cd 262 }
Davidroid 0:2887415a46cd 263
Davidroid 0:2887415a46cd 264 /* Get current position */
Davidroid 0:2887415a46cd 265 devicePrm.currentPosition = L6474_ConvertPosition(L6474_CmdGetParam(L6474_ABS_POS));
Davidroid 0:2887415a46cd 266
Davidroid 0:2887415a46cd 267 /* Compute the number of steps to perform */
Davidroid 0:2887415a46cd 268 steps = targetPosition - devicePrm.currentPosition;
Davidroid 0:2887415a46cd 269
Davidroid 0:2887415a46cd 270 if (steps >= 0)
Davidroid 0:2887415a46cd 271 {
Davidroid 0:2887415a46cd 272 devicePrm.stepsToTake = steps;
Davidroid 5:d3c78f12a78d 273 direction = FORWARD;
Davidroid 0:2887415a46cd 274 }
Davidroid 0:2887415a46cd 275 else
Davidroid 0:2887415a46cd 276 {
Davidroid 0:2887415a46cd 277 devicePrm.stepsToTake = -steps;
Davidroid 5:d3c78f12a78d 278 direction = BACKWARD;
Davidroid 0:2887415a46cd 279 }
Davidroid 0:2887415a46cd 280
Davidroid 0:2887415a46cd 281 if (steps != 0)
Davidroid 0:2887415a46cd 282 {
Davidroid 0:2887415a46cd 283 devicePrm.commandExecuted = MOVE_CMD;
Davidroid 0:2887415a46cd 284
Davidroid 0:2887415a46cd 285 /* Direction setup */
Davidroid 0:2887415a46cd 286 L6474_SetDirection(direction);
Davidroid 0:2887415a46cd 287
Davidroid 0:2887415a46cd 288 L6474_ComputeSpeedProfile(devicePrm.stepsToTake);
Davidroid 0:2887415a46cd 289
Davidroid 0:2887415a46cd 290 /* Motor activation */
Davidroid 0:2887415a46cd 291 L6474_StartMovement();
Davidroid 0:2887415a46cd 292 }
Davidroid 0:2887415a46cd 293 }
Davidroid 0:2887415a46cd 294
Davidroid 5:d3c78f12a78d 295 /**********************************************************
Davidroid 0:2887415a46cd 296 * @brief Immediatly stops the motor and disable the power bridge
Davidroid 0:2887415a46cd 297 * @retval None
Davidroid 0:2887415a46cd 298 **********************************************************/
Davidroid 0:2887415a46cd 299 void L6474::L6474_HardStop(void)
Davidroid 0:2887415a46cd 300 {
Davidroid 0:2887415a46cd 301 /* Disable corresponding PWM */
Davidroid 0:2887415a46cd 302 L6474_PwmStop();
Davidroid 0:2887415a46cd 303
Davidroid 0:2887415a46cd 304 /* Disable power stage */
Davidroid 0:2887415a46cd 305 L6474_CmdDisable();
Davidroid 0:2887415a46cd 306
Davidroid 0:2887415a46cd 307 /* Set inactive state */
Davidroid 0:2887415a46cd 308 devicePrm.motionState = INACTIVE;
Davidroid 0:2887415a46cd 309 devicePrm.commandExecuted = NO_CMD;
Davidroid 0:2887415a46cd 310 devicePrm.stepsToTake = MAX_STEPS;
Davidroid 0:2887415a46cd 311 }
Davidroid 0:2887415a46cd 312
Davidroid 5:d3c78f12a78d 313 /**********************************************************
Davidroid 0:2887415a46cd 314 * @brief Moves the motor of the specified number of steps
Davidroid 0:2887415a46cd 315 * @param[in] direction FORWARD or BACKWARD
Davidroid 0:2887415a46cd 316 * @param[in] stepCount Number of steps to perform
Davidroid 0:2887415a46cd 317 * @retval None
Davidroid 0:2887415a46cd 318 **********************************************************/
Davidroid 5:d3c78f12a78d 319 void L6474::L6474_Move(motorDir_t direction, uint32_t stepCount)
Davidroid 0:2887415a46cd 320 {
Davidroid 0:2887415a46cd 321 /* Eventually deactivate motor */
Davidroid 0:2887415a46cd 322 if (devicePrm.motionState != INACTIVE)
Davidroid 0:2887415a46cd 323 {
Davidroid 0:2887415a46cd 324 L6474_HardStop();
Davidroid 0:2887415a46cd 325 }
Davidroid 0:2887415a46cd 326
Davidroid 0:2887415a46cd 327 if (stepCount != 0)
Davidroid 0:2887415a46cd 328 {
Davidroid 0:2887415a46cd 329 devicePrm.stepsToTake = stepCount;
Davidroid 0:2887415a46cd 330
Davidroid 0:2887415a46cd 331 devicePrm.commandExecuted = MOVE_CMD;
Davidroid 0:2887415a46cd 332
Davidroid 0:2887415a46cd 333 devicePrm.currentPosition = L6474_ConvertPosition(L6474_CmdGetParam(L6474_ABS_POS));
Davidroid 0:2887415a46cd 334
Davidroid 0:2887415a46cd 335 /* Direction setup */
Davidroid 0:2887415a46cd 336 L6474_SetDirection(direction);
Davidroid 0:2887415a46cd 337
Davidroid 0:2887415a46cd 338 L6474_ComputeSpeedProfile(stepCount);
Davidroid 0:2887415a46cd 339
Davidroid 0:2887415a46cd 340 /* Motor activation */
Davidroid 0:2887415a46cd 341 L6474_StartMovement();
Davidroid 0:2887415a46cd 342 }
Davidroid 0:2887415a46cd 343 }
Davidroid 0:2887415a46cd 344
Davidroid 5:d3c78f12a78d 345 /**********************************************************
Davidroid 0:2887415a46cd 346 * @brief Runs the motor. It will accelerate from the min
Davidroid 0:2887415a46cd 347 * speed up to the max speed by using the device acceleration.
Davidroid 0:2887415a46cd 348 * @param[in] direction FORWARD or BACKWARD
Davidroid 0:2887415a46cd 349 * @retval None
Davidroid 0:2887415a46cd 350 **********************************************************/
Davidroid 5:d3c78f12a78d 351 void L6474::L6474_Run(motorDir_t direction)
Davidroid 0:2887415a46cd 352 {
Davidroid 0:2887415a46cd 353 /* Eventually deactivate motor */
Davidroid 0:2887415a46cd 354 if (devicePrm.motionState != INACTIVE)
Davidroid 0:2887415a46cd 355 {
Davidroid 0:2887415a46cd 356 L6474_HardStop();
Davidroid 0:2887415a46cd 357 }
Davidroid 0:2887415a46cd 358
Davidroid 0:2887415a46cd 359 /* Direction setup */
Davidroid 0:2887415a46cd 360 L6474_SetDirection(direction);
Davidroid 0:2887415a46cd 361
Davidroid 0:2887415a46cd 362 devicePrm.commandExecuted = RUN_CMD;
Davidroid 0:2887415a46cd 363
Davidroid 0:2887415a46cd 364 /* Motor activation */
Davidroid 0:2887415a46cd 365 L6474_StartMovement();
Davidroid 0:2887415a46cd 366 }
Davidroid 0:2887415a46cd 367
Davidroid 5:d3c78f12a78d 368 /**********************************************************
Davidroid 0:2887415a46cd 369 * @brief Changes the acceleration of the specified device
Davidroid 0:2887415a46cd 370 * @param[in] newAcc New acceleration to apply in pps^2
Davidroid 0:2887415a46cd 371 * @retval true if the command is successfully executed, else false
Davidroid 0:2887415a46cd 372 * @note The command is not performed is the device is executing
Davidroid 0:2887415a46cd 373 * a MOVE or GOTO command (but it can be used during a RUN command)
Davidroid 0:2887415a46cd 374 **********************************************************/
Davidroid 0:2887415a46cd 375 bool L6474::L6474_SetAcceleration(uint16_t newAcc)
Davidroid 0:2887415a46cd 376 {
Davidroid 0:2887415a46cd 377 bool cmdExecuted = FALSE;
Davidroid 0:2887415a46cd 378 if ((newAcc != 0)&&
Davidroid 0:2887415a46cd 379 ((devicePrm.motionState == INACTIVE)||
Davidroid 0:2887415a46cd 380 (devicePrm.commandExecuted == RUN_CMD)))
Davidroid 0:2887415a46cd 381 {
Davidroid 0:2887415a46cd 382 devicePrm.acceleration = newAcc;
Davidroid 0:2887415a46cd 383 cmdExecuted = TRUE;
Davidroid 0:2887415a46cd 384 }
Davidroid 0:2887415a46cd 385 return cmdExecuted;
Davidroid 0:2887415a46cd 386 }
Davidroid 0:2887415a46cd 387
Davidroid 5:d3c78f12a78d 388 /**********************************************************
Davidroid 0:2887415a46cd 389 * @brief Changes the deceleration of the specified device
Davidroid 0:2887415a46cd 390 * @param[in] newDec New deceleration to apply in pps^2
Davidroid 0:2887415a46cd 391 * @retval true if the command is successfully executed, else false
Davidroid 0:2887415a46cd 392 * @note The command is not performed is the device is executing
Davidroid 0:2887415a46cd 393 * a MOVE or GOTO command (but it can be used during a RUN command)
Davidroid 0:2887415a46cd 394 **********************************************************/
Davidroid 0:2887415a46cd 395 bool L6474::L6474_SetDeceleration(uint16_t newDec)
Davidroid 0:2887415a46cd 396 {
Davidroid 0:2887415a46cd 397 bool cmdExecuted = FALSE;
Davidroid 0:2887415a46cd 398 if ((newDec != 0)&&
Davidroid 0:2887415a46cd 399 ((devicePrm.motionState == INACTIVE)||
Davidroid 0:2887415a46cd 400 (devicePrm.commandExecuted == RUN_CMD)))
Davidroid 0:2887415a46cd 401 {
Davidroid 0:2887415a46cd 402 devicePrm.deceleration = newDec;
Davidroid 0:2887415a46cd 403 cmdExecuted = TRUE;
Davidroid 0:2887415a46cd 404 }
Davidroid 0:2887415a46cd 405 return cmdExecuted;
Davidroid 0:2887415a46cd 406 }
Davidroid 0:2887415a46cd 407
Davidroid 5:d3c78f12a78d 408 /**********************************************************
Davidroid 0:2887415a46cd 409 * @brief Set current position to be the Home position (ABS pos set to 0)
Davidroid 0:2887415a46cd 410 * @retval None
Davidroid 0:2887415a46cd 411 **********************************************************/
Davidroid 0:2887415a46cd 412 void L6474::L6474_SetHome(void)
Davidroid 0:2887415a46cd 413 {
Davidroid 0:2887415a46cd 414 L6474_CmdSetParam(L6474_ABS_POS, 0);
Davidroid 0:2887415a46cd 415 }
Davidroid 0:2887415a46cd 416
Davidroid 5:d3c78f12a78d 417 /**********************************************************
Davidroid 0:2887415a46cd 418 * @brief Sets current position to be the Mark position
Davidroid 0:2887415a46cd 419 * @retval None
Davidroid 0:2887415a46cd 420 **********************************************************/
Davidroid 0:2887415a46cd 421 void L6474::L6474_SetMark(void)
Davidroid 0:2887415a46cd 422 {
Davidroid 0:2887415a46cd 423 uint32_t mark = L6474_CmdGetParam(L6474_ABS_POS);
Davidroid 0:2887415a46cd 424 L6474_CmdSetParam(L6474_MARK, mark);
Davidroid 0:2887415a46cd 425 }
Davidroid 0:2887415a46cd 426
Davidroid 5:d3c78f12a78d 427 /**********************************************************
Davidroid 0:2887415a46cd 428 * @brief Changes the max speed of the specified device
Davidroid 0:2887415a46cd 429 * @param[in] newMaxSpeed New max speed to apply in pps
Davidroid 0:2887415a46cd 430 * @retval true if the command is successfully executed, else false
Davidroid 0:2887415a46cd 431 * @note The command is not performed is the device is executing
Davidroid 0:2887415a46cd 432 * a MOVE or GOTO command (but it can be used during a RUN command).
Davidroid 0:2887415a46cd 433 **********************************************************/
Davidroid 0:2887415a46cd 434 bool L6474::L6474_SetMaxSpeed(uint16_t newMaxSpeed)
Davidroid 0:2887415a46cd 435 {
Davidroid 0:2887415a46cd 436 bool cmdExecuted = FALSE;
Davidroid 0:2887415a46cd 437 if ((newMaxSpeed >= L6474_MIN_PWM_FREQ)&&
Davidroid 0:2887415a46cd 438 (newMaxSpeed <= L6474_MAX_PWM_FREQ) &&
Davidroid 0:2887415a46cd 439 (devicePrm.minSpeed <= newMaxSpeed) &&
Davidroid 0:2887415a46cd 440 ((devicePrm.motionState == INACTIVE)||
Davidroid 0:2887415a46cd 441 (devicePrm.commandExecuted == RUN_CMD)))
Davidroid 0:2887415a46cd 442 {
Davidroid 0:2887415a46cd 443 devicePrm.maxSpeed = newMaxSpeed;
Davidroid 0:2887415a46cd 444 cmdExecuted = TRUE;
Davidroid 0:2887415a46cd 445 }
Davidroid 0:2887415a46cd 446 return cmdExecuted;
Davidroid 0:2887415a46cd 447 }
Davidroid 0:2887415a46cd 448
Davidroid 5:d3c78f12a78d 449 /**********************************************************
Davidroid 0:2887415a46cd 450 * @brief Changes the min speed of the specified device
Davidroid 0:2887415a46cd 451 * @param[in] newMinSpeed New min speed to apply in pps
Davidroid 0:2887415a46cd 452 * @retval true if the command is successfully executed, else false
Davidroid 0:2887415a46cd 453 * @note The command is not performed is the device is executing
Davidroid 0:2887415a46cd 454 * a MOVE or GOTO command (but it can be used during a RUN command).
Davidroid 0:2887415a46cd 455 **********************************************************/
Davidroid 0:2887415a46cd 456 bool L6474::L6474_SetMinSpeed(uint16_t newMinSpeed)
Davidroid 0:2887415a46cd 457 {
Davidroid 0:2887415a46cd 458 bool cmdExecuted = FALSE;
Davidroid 0:2887415a46cd 459 if ((newMinSpeed >= L6474_MIN_PWM_FREQ)&&
Davidroid 0:2887415a46cd 460 (newMinSpeed <= L6474_MAX_PWM_FREQ) &&
Davidroid 0:2887415a46cd 461 (newMinSpeed <= devicePrm.maxSpeed) &&
Davidroid 0:2887415a46cd 462 ((devicePrm.motionState == INACTIVE)||
Davidroid 0:2887415a46cd 463 (devicePrm.commandExecuted == RUN_CMD)))
Davidroid 0:2887415a46cd 464 {
Davidroid 0:2887415a46cd 465 devicePrm.minSpeed = newMinSpeed;
Davidroid 0:2887415a46cd 466 cmdExecuted = TRUE;
Davidroid 0:2887415a46cd 467 }
Davidroid 0:2887415a46cd 468 return cmdExecuted;
Davidroid 0:2887415a46cd 469 }
Davidroid 0:2887415a46cd 470
Davidroid 5:d3c78f12a78d 471 /**********************************************************
Davidroid 0:2887415a46cd 472 * @brief Stops the motor by using the device deceleration
Davidroid 0:2887415a46cd 473 * @retval true if the command is successfully executed, else false
Davidroid 0:2887415a46cd 474 * @note The command is not performed is the device is in INACTIVE state.
Davidroid 0:2887415a46cd 475 **********************************************************/
Davidroid 0:2887415a46cd 476 bool L6474::L6474_SoftStop(void)
Davidroid 0:2887415a46cd 477 {
Davidroid 0:2887415a46cd 478 bool cmdExecuted = FALSE;
Davidroid 0:2887415a46cd 479 if (devicePrm.motionState != INACTIVE)
Davidroid 0:2887415a46cd 480 {
Davidroid 0:2887415a46cd 481 devicePrm.commandExecuted = SOFT_STOP_CMD;
Davidroid 0:2887415a46cd 482 cmdExecuted = TRUE;
Davidroid 0:2887415a46cd 483 }
Davidroid 0:2887415a46cd 484 return (cmdExecuted);
Davidroid 0:2887415a46cd 485 }
Davidroid 0:2887415a46cd 486
Davidroid 5:d3c78f12a78d 487 /**********************************************************
Davidroid 1:b38ebb8ea286 488 * @brief Locks until the device state becomes Inactive
Davidroid 1:b38ebb8ea286 489 * @retval None
Davidroid 1:b38ebb8ea286 490 **********************************************************/
Davidroid 1:b38ebb8ea286 491 void L6474::L6474_WaitWhileActive(void)
Davidroid 1:b38ebb8ea286 492 {
Davidroid 1:b38ebb8ea286 493 /* Wait while motor is running */
Davidroid 1:b38ebb8ea286 494 while (L6474_GetDeviceState() != INACTIVE);
Davidroid 1:b38ebb8ea286 495 }
Davidroid 1:b38ebb8ea286 496
Davidroid 5:d3c78f12a78d 497 /**********************************************************
Davidroid 0:2887415a46cd 498 * @brief Issue the Disable command to the L6474 of the specified device
Davidroid 0:2887415a46cd 499 * @retval None
Davidroid 0:2887415a46cd 500 **********************************************************/
Davidroid 0:2887415a46cd 501 void L6474::L6474_CmdDisable(void)
Davidroid 0:2887415a46cd 502 {
Davidroid 0:2887415a46cd 503 L6474_SendCommand(L6474_DISABLE);
Davidroid 0:2887415a46cd 504 }
Davidroid 0:2887415a46cd 505
Davidroid 5:d3c78f12a78d 506 /**********************************************************
Davidroid 0:2887415a46cd 507 * @brief Issues the Enable command to the L6474 of the specified device
Davidroid 0:2887415a46cd 508 * @retval None
Davidroid 0:2887415a46cd 509 **********************************************************/
Davidroid 0:2887415a46cd 510 void L6474::L6474_CmdEnable(void)
Davidroid 0:2887415a46cd 511 {
Davidroid 0:2887415a46cd 512 L6474_SendCommand(L6474_ENABLE);
Davidroid 0:2887415a46cd 513 }
Davidroid 0:2887415a46cd 514
Davidroid 5:d3c78f12a78d 515 /**********************************************************
Davidroid 0:2887415a46cd 516 * @brief Issues the GetParam command to the L6474 of the specified device
Davidroid 7:f7e0c3621f77 517 * @param[in] parameter Register adress (L6474_ABS_POS, L6474_MARK,...)
Davidroid 0:2887415a46cd 518 * @retval Register value
Davidroid 0:2887415a46cd 519 **********************************************************/
Davidroid 7:f7e0c3621f77 520 uint32_t L6474::L6474_CmdGetParam(L6474_Registers_t parameter)
Davidroid 0:2887415a46cd 521 {
Davidroid 0:2887415a46cd 522 uint32_t i;
Davidroid 0:2887415a46cd 523 uint32_t spiRxData;
Davidroid 0:2887415a46cd 524 uint8_t maxArgumentNbBytes = 0;
Davidroid 5:d3c78f12a78d 525 uint8_t spiIndex = numberOfDevices - deviceInstance - 1;
Davidroid 0:2887415a46cd 526 bool itDisable = FALSE;
Davidroid 0:2887415a46cd 527
Davidroid 0:2887415a46cd 528 do
Davidroid 0:2887415a46cd 529 {
Davidroid 0:2887415a46cd 530 spiPreemtionByIsr = FALSE;
Davidroid 0:2887415a46cd 531 if (itDisable)
Davidroid 0:2887415a46cd 532 {
Davidroid 0:2887415a46cd 533 /* re-enable L6474_EnableIrq if disable in previous iteration */
Davidroid 0:2887415a46cd 534 L6474_EnableIrq();
Davidroid 0:2887415a46cd 535 itDisable = FALSE;
Davidroid 0:2887415a46cd 536 }
Davidroid 0:2887415a46cd 537
Davidroid 5:d3c78f12a78d 538 for (i = 0; i < numberOfDevices; i++)
Davidroid 5:d3c78f12a78d 539 {
Davidroid 5:d3c78f12a78d 540 spiTxBursts[0][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 541 spiTxBursts[1][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 542 spiTxBursts[2][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 543 spiTxBursts[3][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 544 spiRxBursts[1][i] = 0;
Davidroid 5:d3c78f12a78d 545 spiRxBursts[2][i] = 0;
Davidroid 5:d3c78f12a78d 546 spiRxBursts[3][i] = 0;
Davidroid 5:d3c78f12a78d 547 }
Davidroid 0:2887415a46cd 548
Davidroid 7:f7e0c3621f77 549 switch (parameter)
Davidroid 0:2887415a46cd 550 {
Davidroid 0:2887415a46cd 551 case L6474_ABS_POS: ;
Davidroid 0:2887415a46cd 552 case L6474_MARK:
Davidroid 7:f7e0c3621f77 553 spiTxBursts[0][spiIndex] = ((uint8_t)L6474_GET_PARAM )| (parameter);
Davidroid 0:2887415a46cd 554 maxArgumentNbBytes = 3;
Davidroid 0:2887415a46cd 555 break;
Davidroid 0:2887415a46cd 556 case L6474_EL_POS: ;
Davidroid 0:2887415a46cd 557 case L6474_CONFIG: ;
Davidroid 0:2887415a46cd 558 case L6474_STATUS:
Davidroid 7:f7e0c3621f77 559 spiTxBursts[1][spiIndex] = ((uint8_t)L6474_GET_PARAM )| (parameter);
Davidroid 0:2887415a46cd 560 maxArgumentNbBytes = 2;
Davidroid 0:2887415a46cd 561 break;
Davidroid 0:2887415a46cd 562 default:
Davidroid 7:f7e0c3621f77 563 spiTxBursts[2][spiIndex] = ((uint8_t)L6474_GET_PARAM )| (parameter);
Davidroid 0:2887415a46cd 564 maxArgumentNbBytes = 1;
Davidroid 0:2887415a46cd 565 }
Davidroid 0:2887415a46cd 566
Davidroid 0:2887415a46cd 567 /* Disable interruption before checking */
Davidroid 0:2887415a46cd 568 /* pre-emption by ISR and SPI transfers*/
Davidroid 0:2887415a46cd 569 L6474_DisableIrq();
Davidroid 0:2887415a46cd 570 itDisable = TRUE;
Davidroid 0:2887415a46cd 571 } while (spiPreemtionByIsr); // check pre-emption by ISR
Davidroid 0:2887415a46cd 572
Davidroid 0:2887415a46cd 573 for (i = L6474_CMD_ARG_MAX_NB_BYTES-1-maxArgumentNbBytes;
Davidroid 0:2887415a46cd 574 i < L6474_CMD_ARG_MAX_NB_BYTES;
Davidroid 0:2887415a46cd 575 i++)
Davidroid 0:2887415a46cd 576 {
Davidroid 5:d3c78f12a78d 577 L6474_WriteBytes(&spiTxBursts[i][0], &spiRxBursts[i][0]);
Davidroid 0:2887415a46cd 578 }
Davidroid 0:2887415a46cd 579
Davidroid 5:d3c78f12a78d 580 spiRxData = ((uint32_t)spiRxBursts[1][spiIndex] << 16) |
Davidroid 5:d3c78f12a78d 581 (spiRxBursts[2][spiIndex] << 8) |
Davidroid 5:d3c78f12a78d 582 (spiRxBursts[3][spiIndex]);
Davidroid 0:2887415a46cd 583
Davidroid 0:2887415a46cd 584 /* re-enable L6474_EnableIrq after SPI transfers*/
Davidroid 0:2887415a46cd 585 L6474_EnableIrq();
Davidroid 0:2887415a46cd 586
Davidroid 0:2887415a46cd 587 return (spiRxData);
Davidroid 0:2887415a46cd 588 }
Davidroid 0:2887415a46cd 589
Davidroid 5:d3c78f12a78d 590 /**********************************************************
Davidroid 0:2887415a46cd 591 * @brief Issues the GetStatus command to the L6474 of the specified device
Davidroid 0:2887415a46cd 592 * @retval Status Register value
Davidroid 0:2887415a46cd 593 * @note Once the GetStatus command is performed, the flags of the status register
Davidroid 0:2887415a46cd 594 * are reset. This is not the case when the status register is read with the
Davidroid 7:f7e0c3621f77 595 * GetParam command (via the functions L6474ReadStatusRegister or L6474_CmdGetParam).
Davidroid 0:2887415a46cd 596 **********************************************************/
Davidroid 0:2887415a46cd 597 uint16_t L6474::L6474_CmdGetStatus(void)
Davidroid 0:2887415a46cd 598 {
Davidroid 0:2887415a46cd 599 uint32_t i;
Davidroid 0:2887415a46cd 600 uint16_t status;
Davidroid 5:d3c78f12a78d 601 uint8_t spiIndex = numberOfDevices - deviceInstance - 1;
Davidroid 0:2887415a46cd 602 bool itDisable = FALSE;
Davidroid 0:2887415a46cd 603
Davidroid 0:2887415a46cd 604 do
Davidroid 0:2887415a46cd 605 {
Davidroid 0:2887415a46cd 606 spiPreemtionByIsr = FALSE;
Davidroid 0:2887415a46cd 607 if (itDisable)
Davidroid 0:2887415a46cd 608 {
Davidroid 0:2887415a46cd 609 /* re-enable L6474_EnableIrq if disable in previous iteration */
Davidroid 0:2887415a46cd 610 L6474_EnableIrq();
Davidroid 0:2887415a46cd 611 itDisable = FALSE;
Davidroid 0:2887415a46cd 612 }
Davidroid 0:2887415a46cd 613
Davidroid 5:d3c78f12a78d 614 for (i = 0; i < numberOfDevices; i++)
Davidroid 5:d3c78f12a78d 615 {
Davidroid 5:d3c78f12a78d 616 spiTxBursts[0][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 617 spiTxBursts[1][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 618 spiTxBursts[2][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 619 spiRxBursts[1][i] = 0;
Davidroid 5:d3c78f12a78d 620 spiRxBursts[2][i] = 0;
Davidroid 5:d3c78f12a78d 621 }
Davidroid 5:d3c78f12a78d 622 spiTxBursts[0][spiIndex] = L6474_GET_STATUS;
Davidroid 0:2887415a46cd 623
Davidroid 0:2887415a46cd 624 /* Disable interruption before checking */
Davidroid 0:2887415a46cd 625 /* pre-emption by ISR and SPI transfers*/
Davidroid 0:2887415a46cd 626 L6474_DisableIrq();
Davidroid 0:2887415a46cd 627 itDisable = TRUE;
Davidroid 0:2887415a46cd 628 } while (spiPreemtionByIsr); // check pre-emption by ISR
Davidroid 0:2887415a46cd 629
Davidroid 0:2887415a46cd 630 for (i = 0; i < L6474_CMD_ARG_NB_BYTES_GET_STATUS + L6474_RSP_NB_BYTES_GET_STATUS; i++)
Davidroid 0:2887415a46cd 631 {
Davidroid 5:d3c78f12a78d 632 L6474_WriteBytes(&spiTxBursts[i][0], &spiRxBursts[i][0]);
Davidroid 0:2887415a46cd 633 }
Davidroid 5:d3c78f12a78d 634 status = (spiRxBursts[1][spiIndex] << 8) | (spiRxBursts[2][spiIndex]);
Davidroid 0:2887415a46cd 635
Davidroid 0:2887415a46cd 636 /* re-enable L6474_EnableIrq after SPI transfers*/
Davidroid 0:2887415a46cd 637 L6474_EnableIrq();
Davidroid 0:2887415a46cd 638
Davidroid 0:2887415a46cd 639 return (status);
Davidroid 0:2887415a46cd 640 }
Davidroid 0:2887415a46cd 641
Davidroid 5:d3c78f12a78d 642 /**********************************************************
Davidroid 0:2887415a46cd 643 * @brief Issues the Nop command to the L6474 of the specified device
Davidroid 0:2887415a46cd 644 * @retval None
Davidroid 0:2887415a46cd 645 **********************************************************/
Davidroid 0:2887415a46cd 646 void L6474::L6474_CmdNop(void)
Davidroid 0:2887415a46cd 647 {
Davidroid 0:2887415a46cd 648 L6474_SendCommand(L6474_NOP);
Davidroid 0:2887415a46cd 649 }
Davidroid 0:2887415a46cd 650
Davidroid 5:d3c78f12a78d 651 /**********************************************************
Davidroid 0:2887415a46cd 652 * @brief Issues the SetParam command to the L6474 of the specified device
Davidroid 7:f7e0c3621f77 653 * @param[in] parameter Register adress (L6474_ABS_POS, L6474_MARK,...)
Davidroid 0:2887415a46cd 654 * @param[in] value Value to set in the register
Davidroid 0:2887415a46cd 655 * @retval None
Davidroid 0:2887415a46cd 656 **********************************************************/
Davidroid 7:f7e0c3621f77 657 void L6474::L6474_CmdSetParam(L6474_Registers_t parameter, uint32_t value)
Davidroid 0:2887415a46cd 658 {
Davidroid 0:2887415a46cd 659 uint32_t i;
Davidroid 0:2887415a46cd 660 uint8_t maxArgumentNbBytes = 0;
Davidroid 5:d3c78f12a78d 661 uint8_t spiIndex = numberOfDevices - deviceInstance - 1;
Davidroid 0:2887415a46cd 662 bool itDisable = FALSE;
Davidroid 0:2887415a46cd 663 do
Davidroid 0:2887415a46cd 664 {
Davidroid 0:2887415a46cd 665 spiPreemtionByIsr = FALSE;
Davidroid 0:2887415a46cd 666 if (itDisable)
Davidroid 0:2887415a46cd 667 {
Davidroid 0:2887415a46cd 668 /* re-enable L6474_EnableIrq if disable in previous iteration */
Davidroid 0:2887415a46cd 669 L6474_EnableIrq();
Davidroid 0:2887415a46cd 670 itDisable = FALSE;
Davidroid 0:2887415a46cd 671 }
Davidroid 0:2887415a46cd 672
Davidroid 5:d3c78f12a78d 673 for (i = 0; i < numberOfDevices; i++)
Davidroid 5:d3c78f12a78d 674 {
Davidroid 5:d3c78f12a78d 675 spiTxBursts[0][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 676 spiTxBursts[1][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 677 spiTxBursts[2][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 678 spiTxBursts[3][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 679 }
Davidroid 0:2887415a46cd 680
Davidroid 7:f7e0c3621f77 681 switch (parameter)
Davidroid 0:2887415a46cd 682 {
Davidroid 0:2887415a46cd 683 case L6474_ABS_POS: ;
Davidroid 0:2887415a46cd 684 case L6474_MARK:
Davidroid 7:f7e0c3621f77 685 spiTxBursts[0][spiIndex] = parameter;
Davidroid 5:d3c78f12a78d 686 spiTxBursts[1][spiIndex] = (uint8_t)(value >> 16);
Davidroid 5:d3c78f12a78d 687 spiTxBursts[2][spiIndex] = (uint8_t)(value >> 8);
Davidroid 0:2887415a46cd 688 maxArgumentNbBytes = 3;
Davidroid 0:2887415a46cd 689 break;
Davidroid 0:2887415a46cd 690 case L6474_EL_POS: ;
Davidroid 0:2887415a46cd 691 case L6474_CONFIG:
Davidroid 7:f7e0c3621f77 692 spiTxBursts[1][spiIndex] = parameter;
Davidroid 5:d3c78f12a78d 693 spiTxBursts[2][spiIndex] = (uint8_t)(value >> 8);
Davidroid 0:2887415a46cd 694 maxArgumentNbBytes = 2;
Davidroid 0:2887415a46cd 695 break;
Davidroid 0:2887415a46cd 696 default:
Davidroid 7:f7e0c3621f77 697 spiTxBursts[2][spiIndex] = parameter;
Davidroid 0:2887415a46cd 698 maxArgumentNbBytes = 1;
Davidroid 0:2887415a46cd 699 break;
Davidroid 0:2887415a46cd 700 }
Davidroid 5:d3c78f12a78d 701 spiTxBursts[3][spiIndex] = (uint8_t)(value);
Davidroid 0:2887415a46cd 702
Davidroid 0:2887415a46cd 703 /* Disable interruption before checking */
Davidroid 0:2887415a46cd 704 /* pre-emption by ISR and SPI transfers*/
Davidroid 0:2887415a46cd 705 L6474_DisableIrq();
Davidroid 0:2887415a46cd 706 itDisable = TRUE;
Davidroid 0:2887415a46cd 707 } while (spiPreemtionByIsr); // check pre-emption by ISR
Davidroid 0:2887415a46cd 708
Davidroid 0:2887415a46cd 709 /* SPI transfer */
Davidroid 0:2887415a46cd 710 for (i = L6474_CMD_ARG_MAX_NB_BYTES-1-maxArgumentNbBytes;
Davidroid 0:2887415a46cd 711 i < L6474_CMD_ARG_MAX_NB_BYTES;
Davidroid 0:2887415a46cd 712 i++)
Davidroid 0:2887415a46cd 713 {
Davidroid 5:d3c78f12a78d 714 L6474_WriteBytes(&spiTxBursts[i][0],&spiRxBursts[i][0]);
Davidroid 0:2887415a46cd 715 }
Davidroid 0:2887415a46cd 716 /* re-enable L6474_EnableIrq after SPI transfers*/
Davidroid 0:2887415a46cd 717 L6474_EnableIrq();
Davidroid 0:2887415a46cd 718 }
Davidroid 0:2887415a46cd 719
Davidroid 5:d3c78f12a78d 720 /**********************************************************
Davidroid 0:2887415a46cd 721 * @brief Reads the Status Register value
Davidroid 0:2887415a46cd 722 * @retval Status register valued
Davidroid 0:2887415a46cd 723 * @note The status register flags are not cleared
Davidroid 0:2887415a46cd 724 * at the difference with L6474CmdGetStatus()
Davidroid 0:2887415a46cd 725 **********************************************************/
Davidroid 0:2887415a46cd 726 uint16_t L6474::L6474_ReadStatusRegister(void)
Davidroid 0:2887415a46cd 727 {
Davidroid 0:2887415a46cd 728 return (L6474_CmdGetParam(L6474_STATUS));
Davidroid 0:2887415a46cd 729 }
Davidroid 0:2887415a46cd 730
Davidroid 5:d3c78f12a78d 731 /**********************************************************
Davidroid 0:2887415a46cd 732 * @brief Set the stepping mode
Davidroid 0:2887415a46cd 733 * @param[in] stepMod from full step to 1/16 microstep as specified in enum motorStepMode_t
Davidroid 0:2887415a46cd 734 * @retval None
Davidroid 0:2887415a46cd 735 **********************************************************/
Davidroid 0:2887415a46cd 736 void L6474::L6474_SelectStepMode(motorStepMode_t stepMod)
Davidroid 0:2887415a46cd 737 {
Davidroid 0:2887415a46cd 738 uint8_t stepModeRegister;
Davidroid 0:2887415a46cd 739 L6474_STEP_SEL_t l6474StepMod;
Davidroid 0:2887415a46cd 740
Davidroid 0:2887415a46cd 741 switch (stepMod)
Davidroid 0:2887415a46cd 742 {
Davidroid 0:2887415a46cd 743 case STEP_MODE_FULL:
Davidroid 0:2887415a46cd 744 l6474StepMod = L6474_STEP_SEL_1;
Davidroid 0:2887415a46cd 745 break;
Davidroid 0:2887415a46cd 746 case STEP_MODE_HALF:
Davidroid 0:2887415a46cd 747 l6474StepMod = L6474_STEP_SEL_1_2;
Davidroid 0:2887415a46cd 748 break;
Davidroid 0:2887415a46cd 749 case STEP_MODE_1_4:
Davidroid 0:2887415a46cd 750 l6474StepMod = L6474_STEP_SEL_1_4;
Davidroid 0:2887415a46cd 751 break;
Davidroid 0:2887415a46cd 752 case STEP_MODE_1_8:
Davidroid 0:2887415a46cd 753 l6474StepMod = L6474_STEP_SEL_1_8;
Davidroid 0:2887415a46cd 754 break;
Davidroid 0:2887415a46cd 755 case STEP_MODE_1_16:
Davidroid 0:2887415a46cd 756 default:
Davidroid 0:2887415a46cd 757 l6474StepMod = L6474_STEP_SEL_1_16;
Davidroid 0:2887415a46cd 758 break;
Davidroid 0:2887415a46cd 759 }
Davidroid 0:2887415a46cd 760
Davidroid 0:2887415a46cd 761 /* Eventually deactivate motor */
Davidroid 0:2887415a46cd 762 if (devicePrm.motionState != INACTIVE)
Davidroid 0:2887415a46cd 763 {
Davidroid 0:2887415a46cd 764 L6474_HardStop();
Davidroid 0:2887415a46cd 765 }
Davidroid 0:2887415a46cd 766
Davidroid 0:2887415a46cd 767 /* Read Step mode register and clear STEP_SEL field */
Davidroid 0:2887415a46cd 768 stepModeRegister = (uint8_t)(0xF8 & L6474_CmdGetParam(L6474_STEP_MODE)) ;
Davidroid 0:2887415a46cd 769
Davidroid 0:2887415a46cd 770 /* Apply new step mode */
Davidroid 0:2887415a46cd 771 L6474_CmdSetParam(L6474_STEP_MODE, stepModeRegister | (uint8_t)l6474StepMod);
Davidroid 0:2887415a46cd 772
Davidroid 0:2887415a46cd 773 /* Reset abs pos register */
Davidroid 0:2887415a46cd 774 L6474_SetHome();
Davidroid 0:2887415a46cd 775 }
Davidroid 0:2887415a46cd 776
Davidroid 5:d3c78f12a78d 777 /**********************************************************
Davidroid 5:d3c78f12a78d 778 * @brief Get the direction
Davidroid 5:d3c78f12a78d 779 * @param None
Davidroid 5:d3c78f12a78d 780 * @retval direction FORWARD or BACKWARD
Davidroid 4:83a1eb397a65 781 **********************************************************/
Davidroid 5:d3c78f12a78d 782 motorDir_t L6474::L6474_GetDirection(void)
Davidroid 4:83a1eb397a65 783 {
Davidroid 5:d3c78f12a78d 784 return devicePrm.direction;
Davidroid 4:83a1eb397a65 785 }
Davidroid 4:83a1eb397a65 786
Davidroid 5:d3c78f12a78d 787 /**********************************************************
Davidroid 0:2887415a46cd 788 * @brief Specifies the direction
Davidroid 0:2887415a46cd 789 * @param[in] dir FORWARD or BACKWARD
Davidroid 0:2887415a46cd 790 * @note The direction change is only applied if the device
Davidroid 0:2887415a46cd 791 * is in INACTIVE state
Davidroid 0:2887415a46cd 792 * @retval None
Davidroid 0:2887415a46cd 793 **********************************************************/
Davidroid 5:d3c78f12a78d 794 void L6474::L6474_SetDirection(motorDir_t direction)
Davidroid 0:2887415a46cd 795 {
Davidroid 0:2887415a46cd 796 if (devicePrm.motionState == INACTIVE)
Davidroid 0:2887415a46cd 797 {
Davidroid 5:d3c78f12a78d 798 devicePrm.direction = direction;
Davidroid 5:d3c78f12a78d 799 L6474_SetDirectionGpio(direction);
Davidroid 0:2887415a46cd 800 }
Davidroid 0:2887415a46cd 801 }
Davidroid 0:2887415a46cd 802
Davidroid 5:d3c78f12a78d 803 /**********************************************************
Davidroid 0:2887415a46cd 804 * @brief Updates the current speed of the device
Davidroid 0:2887415a46cd 805 * @param[in] newSpeed in pps
Davidroid 0:2887415a46cd 806 * @retval None
Davidroid 0:2887415a46cd 807 **********************************************************/
Davidroid 0:2887415a46cd 808 void L6474::L6474_ApplySpeed(uint16_t newSpeed)
Davidroid 0:2887415a46cd 809 {
Davidroid 0:2887415a46cd 810 if (newSpeed < L6474_MIN_PWM_FREQ)
Davidroid 0:2887415a46cd 811 {
Davidroid 0:2887415a46cd 812 newSpeed = L6474_MIN_PWM_FREQ;
Davidroid 0:2887415a46cd 813 }
Davidroid 0:2887415a46cd 814 if (newSpeed > L6474_MAX_PWM_FREQ)
Davidroid 0:2887415a46cd 815 {
Davidroid 0:2887415a46cd 816 newSpeed = L6474_MAX_PWM_FREQ;
Davidroid 0:2887415a46cd 817 }
Davidroid 0:2887415a46cd 818
Davidroid 0:2887415a46cd 819 devicePrm.speed = newSpeed;
Davidroid 0:2887415a46cd 820
Davidroid 0:2887415a46cd 821 L6474_PwmSetFreq(newSpeed);
Davidroid 0:2887415a46cd 822 }
Davidroid 0:2887415a46cd 823
Davidroid 5:d3c78f12a78d 824 /**********************************************************
Davidroid 0:2887415a46cd 825 * @brief Computes the speed profile according to the number of steps to move
Davidroid 0:2887415a46cd 826 * @param[in] nbSteps number of steps to perform
Davidroid 0:2887415a46cd 827 * @retval None
Davidroid 0:2887415a46cd 828 * @note Using the acceleration and deceleration of the device,
Davidroid 0:2887415a46cd 829 * this function determines the duration in steps of the acceleration,
Davidroid 0:2887415a46cd 830 * steady and deceleration phases.
Davidroid 0:2887415a46cd 831 * If the total number of steps to perform is big enough, a trapezoidal move
Davidroid 0:2887415a46cd 832 * is performed (i.e. there is a steady phase where the motor runs at the maximum
Davidroid 0:2887415a46cd 833 * speed.
Davidroid 0:2887415a46cd 834 * Else, a triangular move is performed (no steady phase: the maximum speed is never
Davidroid 0:2887415a46cd 835 * reached.
Davidroid 0:2887415a46cd 836 **********************************************************/
Davidroid 0:2887415a46cd 837 void L6474::L6474_ComputeSpeedProfile(uint32_t nbSteps)
Davidroid 0:2887415a46cd 838 {
Davidroid 0:2887415a46cd 839 uint32_t reqAccSteps;
Davidroid 0:2887415a46cd 840 uint32_t reqDecSteps;
Davidroid 0:2887415a46cd 841
Davidroid 0:2887415a46cd 842 /* compute the number of steps to get the targeted speed */
Davidroid 0:2887415a46cd 843 uint16_t minSpeed = devicePrm.minSpeed;
Davidroid 0:2887415a46cd 844 reqAccSteps = (devicePrm.maxSpeed - minSpeed);
Davidroid 0:2887415a46cd 845 reqAccSteps *= (devicePrm.maxSpeed + minSpeed);
Davidroid 0:2887415a46cd 846 reqDecSteps = reqAccSteps;
Davidroid 0:2887415a46cd 847 reqAccSteps /= (uint32_t)devicePrm.acceleration;
Davidroid 0:2887415a46cd 848 reqAccSteps /= 2;
Davidroid 0:2887415a46cd 849
Davidroid 0:2887415a46cd 850 /* compute the number of steps to stop */
Davidroid 0:2887415a46cd 851 reqDecSteps /= (uint32_t)devicePrm.deceleration;
Davidroid 0:2887415a46cd 852 reqDecSteps /= 2;
Davidroid 0:2887415a46cd 853
Davidroid 0:2887415a46cd 854 if(( reqAccSteps + reqDecSteps ) > nbSteps)
Davidroid 0:2887415a46cd 855 {
Davidroid 0:2887415a46cd 856 /* Triangular move */
Davidroid 0:2887415a46cd 857 /* reqDecSteps = (Pos * Dec) /(Dec+Acc) */
Davidroid 0:2887415a46cd 858 uint32_t dec = devicePrm.deceleration;
Davidroid 0:2887415a46cd 859 uint32_t acc = devicePrm.acceleration;
Davidroid 0:2887415a46cd 860
Davidroid 0:2887415a46cd 861 reqDecSteps = ((uint32_t) dec * nbSteps) / (acc + dec);
Davidroid 0:2887415a46cd 862 if (reqDecSteps > 1)
Davidroid 0:2887415a46cd 863 {
Davidroid 0:2887415a46cd 864 reqAccSteps = reqDecSteps - 1;
Davidroid 0:2887415a46cd 865 if(reqAccSteps == 0)
Davidroid 0:2887415a46cd 866 {
Davidroid 0:2887415a46cd 867 reqAccSteps = 1;
Davidroid 0:2887415a46cd 868 }
Davidroid 0:2887415a46cd 869 }
Davidroid 0:2887415a46cd 870 else
Davidroid 0:2887415a46cd 871 {
Davidroid 0:2887415a46cd 872 reqAccSteps = 0;
Davidroid 0:2887415a46cd 873 }
Davidroid 0:2887415a46cd 874 devicePrm.endAccPos = reqAccSteps;
Davidroid 0:2887415a46cd 875 devicePrm.startDecPos = reqDecSteps;
Davidroid 0:2887415a46cd 876 }
Davidroid 0:2887415a46cd 877 else
Davidroid 0:2887415a46cd 878 {
Davidroid 0:2887415a46cd 879 /* Trapezoidal move */
Davidroid 0:2887415a46cd 880 /* accelerating phase to endAccPos */
Davidroid 0:2887415a46cd 881 /* steady phase from endAccPos to startDecPos */
Davidroid 0:2887415a46cd 882 /* decelerating from startDecPos to stepsToTake*/
Davidroid 0:2887415a46cd 883 devicePrm.endAccPos = reqAccSteps;
Davidroid 0:2887415a46cd 884 devicePrm.startDecPos = nbSteps - reqDecSteps - 1;
Davidroid 0:2887415a46cd 885 }
Davidroid 0:2887415a46cd 886 }
Davidroid 0:2887415a46cd 887
Davidroid 5:d3c78f12a78d 888 /**********************************************************
Davidroid 0:2887415a46cd 889 * @brief Converts the ABS_POSITION register value to a 32b signed integer
Davidroid 0:2887415a46cd 890 * @param[in] abs_position_reg value of the ABS_POSITION register
Davidroid 0:2887415a46cd 891 * @retval operation_result 32b signed integer corresponding to the absolute position
Davidroid 0:2887415a46cd 892 **********************************************************/
Davidroid 0:2887415a46cd 893 int32_t L6474::L6474_ConvertPosition(uint32_t abs_position_reg)
Davidroid 0:2887415a46cd 894 {
Davidroid 0:2887415a46cd 895 int32_t operation_result;
Davidroid 0:2887415a46cd 896
Davidroid 0:2887415a46cd 897 if (abs_position_reg & L6474_ABS_POS_SIGN_BIT_MASK)
Davidroid 0:2887415a46cd 898 {
Davidroid 0:2887415a46cd 899 /* Negative register value */
Davidroid 0:2887415a46cd 900 abs_position_reg = ~abs_position_reg;
Davidroid 0:2887415a46cd 901 abs_position_reg += 1;
Davidroid 0:2887415a46cd 902
Davidroid 0:2887415a46cd 903 operation_result = (int32_t) (abs_position_reg & L6474_ABS_POS_VALUE_MASK);
Davidroid 0:2887415a46cd 904 operation_result = -operation_result;
Davidroid 0:2887415a46cd 905 }
Davidroid 0:2887415a46cd 906 else
Davidroid 0:2887415a46cd 907 {
Davidroid 0:2887415a46cd 908 operation_result = (int32_t) abs_position_reg;
Davidroid 0:2887415a46cd 909 }
Davidroid 5:d3c78f12a78d 910
Davidroid 0:2887415a46cd 911 return operation_result;
Davidroid 0:2887415a46cd 912 }
Davidroid 0:2887415a46cd 913
Davidroid 5:d3c78f12a78d 914 /**********************************************************
Davidroid 0:2887415a46cd 915 * @brief Error handler which calls the user callback (if defined)
Davidroid 0:2887415a46cd 916 * @param[in] error Number of the error
Davidroid 0:2887415a46cd 917 * @retval None
Davidroid 0:2887415a46cd 918 **********************************************************/
Davidroid 0:2887415a46cd 919 void L6474::L6474_ErrorHandler(uint16_t error)
Davidroid 0:2887415a46cd 920 {
Davidroid 0:2887415a46cd 921 if (errorHandlerCallback != 0)
Davidroid 0:2887415a46cd 922 {
Davidroid 0:2887415a46cd 923 (void) errorHandlerCallback(error);
Davidroid 0:2887415a46cd 924 }
Davidroid 0:2887415a46cd 925 else
Davidroid 0:2887415a46cd 926 {
Davidroid 7:f7e0c3621f77 927 /* Aborting the program. */
Davidroid 7:f7e0c3621f77 928 exit(EXIT_FAILURE);
Davidroid 0:2887415a46cd 929 }
Davidroid 0:2887415a46cd 930 }
Davidroid 0:2887415a46cd 931
Davidroid 5:d3c78f12a78d 932 /**********************************************************
Davidroid 0:2887415a46cd 933 * @brief Sends a command without arguments to the L6474 via the SPI
Davidroid 0:2887415a46cd 934 * @param[in] param Command to send
Davidroid 0:2887415a46cd 935 * @retval None
Davidroid 0:2887415a46cd 936 **********************************************************/
Davidroid 0:2887415a46cd 937 void L6474::L6474_SendCommand(uint8_t param)
Davidroid 0:2887415a46cd 938 {
Davidroid 5:d3c78f12a78d 939 uint32_t i;
Davidroid 5:d3c78f12a78d 940 bool itDisable = FALSE;
Davidroid 5:d3c78f12a78d 941 uint8_t spiIndex = numberOfDevices - deviceInstance - 1;
Davidroid 0:2887415a46cd 942
Davidroid 0:2887415a46cd 943 do
Davidroid 0:2887415a46cd 944 {
Davidroid 0:2887415a46cd 945 spiPreemtionByIsr = FALSE;
Davidroid 0:2887415a46cd 946 if (itDisable)
Davidroid 0:2887415a46cd 947 {
Davidroid 0:2887415a46cd 948 /* re-enable L6474_EnableIrq if disable in previous iteration */
Davidroid 0:2887415a46cd 949 L6474_EnableIrq();
Davidroid 0:2887415a46cd 950 itDisable = FALSE;
Davidroid 0:2887415a46cd 951 }
Davidroid 0:2887415a46cd 952
Davidroid 5:d3c78f12a78d 953 for (i = 0; i < numberOfDevices; i++)
Davidroid 5:d3c78f12a78d 954 {
Davidroid 5:d3c78f12a78d 955 spiTxBursts[3][i] = L6474_NOP;
Davidroid 5:d3c78f12a78d 956 }
Davidroid 5:d3c78f12a78d 957 spiTxBursts[3][spiIndex] = param;
Davidroid 0:2887415a46cd 958
Davidroid 0:2887415a46cd 959 /* Disable interruption before checking */
Davidroid 0:2887415a46cd 960 /* pre-emption by ISR and SPI transfers*/
Davidroid 0:2887415a46cd 961 L6474_DisableIrq();
Davidroid 0:2887415a46cd 962 itDisable = TRUE;
Davidroid 0:2887415a46cd 963 } while (spiPreemtionByIsr); // check pre-emption by ISR
Davidroid 0:2887415a46cd 964
Davidroid 5:d3c78f12a78d 965 L6474_WriteBytes(&spiTxBursts[3][0], &spiRxBursts[3][0]);
Davidroid 0:2887415a46cd 966
Davidroid 0:2887415a46cd 967 /* re-enable L6474_EnableIrq after SPI transfers*/
Davidroid 0:2887415a46cd 968 L6474_EnableIrq();
Davidroid 0:2887415a46cd 969 }
Davidroid 0:2887415a46cd 970
Davidroid 5:d3c78f12a78d 971 /**********************************************************
Davidroid 0:2887415a46cd 972 * @brief Sets the registers of the L6474 to their predefined values
Davidroid 0:2887415a46cd 973 * from l6474_target_config.h
Davidroid 0:2887415a46cd 974 * @retval None
Davidroid 0:2887415a46cd 975 **********************************************************/
Davidroid 0:2887415a46cd 976 void L6474::L6474_SetRegisterToPredefinedValues(void)
Davidroid 0:2887415a46cd 977 {
Davidroid 0:2887415a46cd 978 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 979 L6474_ABS_POS,
Davidroid 0:2887415a46cd 980 0);
Davidroid 0:2887415a46cd 981 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 982 L6474_EL_POS,
Davidroid 0:2887415a46cd 983 0);
Davidroid 0:2887415a46cd 984 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 985 L6474_MARK,
Davidroid 0:2887415a46cd 986 0);
Davidroid 0:2887415a46cd 987 switch (deviceInstance)
Davidroid 0:2887415a46cd 988 {
Davidroid 0:2887415a46cd 989 case 0:
Davidroid 0:2887415a46cd 990 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 991 L6474_TVAL,
Davidroid 0:2887415a46cd 992 L6474_Tval_Current_to_Par(L6474_CONF_PARAM_TVAL_DEVICE_0));
Davidroid 0:2887415a46cd 993 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 994 L6474_T_FAST,
Davidroid 0:2887415a46cd 995 (uint8_t)L6474_CONF_PARAM_TOFF_FAST_DEVICE_0 |
Davidroid 0:2887415a46cd 996 (uint8_t)L6474_CONF_PARAM_FAST_STEP_DEVICE_0);
Davidroid 0:2887415a46cd 997 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 998 L6474_TON_MIN,
Davidroid 0:2887415a46cd 999 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TON_MIN_DEVICE_0)
Davidroid 0:2887415a46cd 1000 );
Davidroid 0:2887415a46cd 1001 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1002 L6474_TOFF_MIN,
Davidroid 0:2887415a46cd 1003 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TOFF_MIN_DEVICE_0));
Davidroid 0:2887415a46cd 1004 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1005 L6474_OCD_TH,
Davidroid 0:2887415a46cd 1006 L6474_CONF_PARAM_OCD_TH_DEVICE_0);
Davidroid 0:2887415a46cd 1007 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1008 L6474_STEP_MODE,
Davidroid 0:2887415a46cd 1009 (uint8_t)L6474_CONF_PARAM_STEP_SEL_DEVICE_0 |
Davidroid 0:2887415a46cd 1010 (uint8_t)L6474_CONF_PARAM_SYNC_SEL_DEVICE_0);
Davidroid 0:2887415a46cd 1011 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1012 L6474_ALARM_EN,
Davidroid 0:2887415a46cd 1013 L6474_CONF_PARAM_ALARM_EN_DEVICE_0);
Davidroid 0:2887415a46cd 1014 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1015 L6474_CONFIG,
Davidroid 0:2887415a46cd 1016 (uint16_t)L6474_CONF_PARAM_CLOCK_SETTING_DEVICE_0 |
Davidroid 0:2887415a46cd 1017 (uint16_t)L6474_CONF_PARAM_TQ_REG_DEVICE_0 |
Davidroid 0:2887415a46cd 1018 (uint16_t)L6474_CONF_PARAM_OC_SD_DEVICE_0 |
Davidroid 0:2887415a46cd 1019 (uint16_t)L6474_CONF_PARAM_SR_DEVICE_0 |
Davidroid 0:2887415a46cd 1020 (uint16_t)L6474_CONF_PARAM_TOFF_DEVICE_0);
Davidroid 0:2887415a46cd 1021 break;
Davidroid 0:2887415a46cd 1022 case 1:
Davidroid 0:2887415a46cd 1023 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1024 L6474_TVAL,
Davidroid 0:2887415a46cd 1025 L6474_Tval_Current_to_Par(L6474_CONF_PARAM_TVAL_DEVICE_1));
Davidroid 0:2887415a46cd 1026 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1027 L6474_T_FAST,
Davidroid 0:2887415a46cd 1028 (uint8_t)L6474_CONF_PARAM_TOFF_FAST_DEVICE_1 |
Davidroid 0:2887415a46cd 1029 (uint8_t)L6474_CONF_PARAM_FAST_STEP_DEVICE_1);
Davidroid 0:2887415a46cd 1030 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1031 L6474_TON_MIN,
Davidroid 0:2887415a46cd 1032 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TON_MIN_DEVICE_1));
Davidroid 0:2887415a46cd 1033 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1034 L6474_TOFF_MIN,
Davidroid 0:2887415a46cd 1035 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TOFF_MIN_DEVICE_1));
Davidroid 0:2887415a46cd 1036 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1037 L6474_OCD_TH,
Davidroid 0:2887415a46cd 1038 L6474_CONF_PARAM_OCD_TH_DEVICE_1);
Davidroid 0:2887415a46cd 1039 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1040 L6474_STEP_MODE,
Davidroid 0:2887415a46cd 1041 (uint8_t)L6474_CONF_PARAM_STEP_SEL_DEVICE_1 |
Davidroid 0:2887415a46cd 1042 (uint8_t)L6474_CONF_PARAM_SYNC_SEL_DEVICE_1);
Davidroid 0:2887415a46cd 1043 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1044 L6474_ALARM_EN,
Davidroid 0:2887415a46cd 1045 L6474_CONF_PARAM_ALARM_EN_DEVICE_1);
Davidroid 0:2887415a46cd 1046 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1047 L6474_CONFIG,
Davidroid 0:2887415a46cd 1048 (uint16_t)L6474_CONF_PARAM_CLOCK_SETTING_DEVICE_1 |
Davidroid 0:2887415a46cd 1049 (uint16_t)L6474_CONF_PARAM_TQ_REG_DEVICE_1 |
Davidroid 0:2887415a46cd 1050 (uint16_t)L6474_CONF_PARAM_OC_SD_DEVICE_1 |
Davidroid 0:2887415a46cd 1051 (uint16_t)L6474_CONF_PARAM_SR_DEVICE_1 |
Davidroid 0:2887415a46cd 1052 (uint16_t)L6474_CONF_PARAM_TOFF_DEVICE_1);
Davidroid 0:2887415a46cd 1053 break;
Davidroid 0:2887415a46cd 1054 case 2:
Davidroid 0:2887415a46cd 1055 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1056 L6474_TVAL,
Davidroid 0:2887415a46cd 1057 L6474_Tval_Current_to_Par(L6474_CONF_PARAM_TVAL_DEVICE_2));
Davidroid 0:2887415a46cd 1058 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1059 L6474_T_FAST,
Davidroid 0:2887415a46cd 1060 (uint8_t)L6474_CONF_PARAM_TOFF_FAST_DEVICE_2 |
Davidroid 0:2887415a46cd 1061 (uint8_t)L6474_CONF_PARAM_FAST_STEP_DEVICE_2);
Davidroid 0:2887415a46cd 1062 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1063 L6474_TON_MIN,
Davidroid 0:2887415a46cd 1064 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TON_MIN_DEVICE_2));
Davidroid 0:2887415a46cd 1065 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1066 L6474_TOFF_MIN,
Davidroid 0:2887415a46cd 1067 L6474_Tmin_Time_to_Par(L6474_CONF_PARAM_TOFF_MIN_DEVICE_2));
Davidroid 0:2887415a46cd 1068 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1069 L6474_OCD_TH,
Davidroid 0:2887415a46cd 1070 L6474_CONF_PARAM_OCD_TH_DEVICE_2);
Davidroid 0:2887415a46cd 1071 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1072 L6474_STEP_MODE,
Davidroid 0:2887415a46cd 1073 (uint8_t)L6474_CONF_PARAM_STEP_SEL_DEVICE_2 |
Davidroid 0:2887415a46cd 1074 (uint8_t)L6474_CONF_PARAM_SYNC_SEL_DEVICE_2);
Davidroid 0:2887415a46cd 1075 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1076 L6474_ALARM_EN,
Davidroid 0:2887415a46cd 1077 L6474_CONF_PARAM_ALARM_EN_DEVICE_2);
Davidroid 0:2887415a46cd 1078 L6474_CmdSetParam(
Davidroid 0:2887415a46cd 1079 L6474_CONFIG,
Davidroid 0:2887415a46cd 1080 (uint16_t)L6474_CONF_PARAM_CLOCK_SETTING_DEVICE_2 |
Davidroid 0:2887415a46cd 1081 (uint16_t)L6474_CONF_PARAM_TQ_REG_DEVICE_2 |
Davidroid 0:2887415a46cd 1082 (uint16_t)L6474_CONF_PARAM_OC_SD_DEVICE_2 |
Davidroid 0:2887415a46cd 1083 (uint16_t)L6474_CONF_PARAM_SR_DEVICE_2 |
Davidroid 0:2887415a46cd 1084 (uint16_t)L6474_CONF_PARAM_TOFF_DEVICE_2);
Davidroid 0:2887415a46cd 1085 break;
Davidroid 0:2887415a46cd 1086 default: ;
Davidroid 0:2887415a46cd 1087 }
Davidroid 0:2887415a46cd 1088 }
Davidroid 0:2887415a46cd 1089
Davidroid 5:d3c78f12a78d 1090 /**********************************************************
Davidroid 0:2887415a46cd 1091 * @brief Sets the parameters of the device to predefined values
Davidroid 0:2887415a46cd 1092 * from l6474_target_config.h
Davidroid 0:2887415a46cd 1093 * @param None
Davidroid 0:2887415a46cd 1094 * @retval None
Davidroid 0:2887415a46cd 1095 **********************************************************/
Davidroid 0:2887415a46cd 1096 void L6474::L6474_SetDeviceParamsToPredefinedValues(void)
Davidroid 0:2887415a46cd 1097 {
Davidroid 0:2887415a46cd 1098 switch (deviceInstance)
Davidroid 0:2887415a46cd 1099 {
Davidroid 0:2887415a46cd 1100 case 0:
Davidroid 0:2887415a46cd 1101 devicePrm.acceleration = L6474_CONF_PARAM_ACC_DEVICE_0;
Davidroid 0:2887415a46cd 1102 devicePrm.deceleration = L6474_CONF_PARAM_DEC_DEVICE_0;
Davidroid 0:2887415a46cd 1103 devicePrm.maxSpeed = L6474_CONF_PARAM_MAX_SPEED_DEVICE_0;
Davidroid 0:2887415a46cd 1104 devicePrm.minSpeed = L6474_CONF_PARAM_MIN_SPEED_DEVICE_0;
Davidroid 0:2887415a46cd 1105 break;
Davidroid 0:2887415a46cd 1106
Davidroid 0:2887415a46cd 1107 case 1:
Davidroid 0:2887415a46cd 1108 devicePrm.acceleration = L6474_CONF_PARAM_ACC_DEVICE_1;
Davidroid 0:2887415a46cd 1109 devicePrm.deceleration = L6474_CONF_PARAM_DEC_DEVICE_1;
Davidroid 0:2887415a46cd 1110 devicePrm.maxSpeed = L6474_CONF_PARAM_MAX_SPEED_DEVICE_1;
Davidroid 0:2887415a46cd 1111 devicePrm.minSpeed = L6474_CONF_PARAM_MIN_SPEED_DEVICE_1;
Davidroid 0:2887415a46cd 1112 break;
Davidroid 0:2887415a46cd 1113
Davidroid 0:2887415a46cd 1114 case 2:
Davidroid 0:2887415a46cd 1115 devicePrm.acceleration = L6474_CONF_PARAM_ACC_DEVICE_2;
Davidroid 0:2887415a46cd 1116 devicePrm.deceleration = L6474_CONF_PARAM_DEC_DEVICE_2;
Davidroid 0:2887415a46cd 1117 devicePrm.maxSpeed = L6474_CONF_PARAM_MAX_SPEED_DEVICE_2;
Davidroid 0:2887415a46cd 1118 devicePrm.minSpeed = L6474_CONF_PARAM_MIN_SPEED_DEVICE_2;
Davidroid 0:2887415a46cd 1119 break;
Davidroid 0:2887415a46cd 1120 }
Davidroid 0:2887415a46cd 1121
Davidroid 0:2887415a46cd 1122 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1123 devicePrm.currentPosition = 0;
Davidroid 0:2887415a46cd 1124 devicePrm.endAccPos = 0;
Davidroid 0:2887415a46cd 1125 devicePrm.relativePos = 0;
Davidroid 0:2887415a46cd 1126 devicePrm.startDecPos = 0;
Davidroid 0:2887415a46cd 1127 devicePrm.stepsToTake = 0;
Davidroid 0:2887415a46cd 1128 devicePrm.speed = 0;
Davidroid 0:2887415a46cd 1129 devicePrm.commandExecuted = NO_CMD;
Davidroid 0:2887415a46cd 1130 devicePrm.direction = FORWARD;
Davidroid 0:2887415a46cd 1131 devicePrm.motionState = INACTIVE;
Davidroid 0:2887415a46cd 1132
Davidroid 0:2887415a46cd 1133 L6474_SetRegisterToPredefinedValues();
Davidroid 0:2887415a46cd 1134 }
Davidroid 0:2887415a46cd 1135
Davidroid 5:d3c78f12a78d 1136 /**********************************************************
Davidroid 0:2887415a46cd 1137 * @brief Initialises the bridge parameters to start the movement
Davidroid 0:2887415a46cd 1138 * and enable the power bridge
Davidroid 0:2887415a46cd 1139 * @retval None
Davidroid 0:2887415a46cd 1140 **********************************************************/
Davidroid 0:2887415a46cd 1141 void L6474::L6474_StartMovement(void)
Davidroid 0:2887415a46cd 1142 {
Davidroid 0:2887415a46cd 1143 /* Enable L6474 powerstage */
Davidroid 0:2887415a46cd 1144 L6474_CmdEnable();
Davidroid 0:2887415a46cd 1145 if (devicePrm.endAccPos != 0)
Davidroid 0:2887415a46cd 1146 {
Davidroid 0:2887415a46cd 1147 devicePrm.motionState = ACCELERATING;
Davidroid 0:2887415a46cd 1148 }
Davidroid 0:2887415a46cd 1149 else
Davidroid 0:2887415a46cd 1150 {
Davidroid 0:2887415a46cd 1151 devicePrm.motionState = DECELERATING;
Davidroid 0:2887415a46cd 1152 }
Davidroid 0:2887415a46cd 1153 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1154 devicePrm.relativePos = 0;
Davidroid 0:2887415a46cd 1155 L6474_ApplySpeed(devicePrm.minSpeed);
Davidroid 0:2887415a46cd 1156 }
Davidroid 0:2887415a46cd 1157
Davidroid 5:d3c78f12a78d 1158 /**********************************************************
Davidroid 0:2887415a46cd 1159 * @brief Handles the device state machine at each ste
Davidroid 0:2887415a46cd 1160 * @retval None
Davidroid 0:2887415a46cd 1161 * @note Must only be called by the timer ISR
Davidroid 0:2887415a46cd 1162 **********************************************************/
Davidroid 0:2887415a46cd 1163 void L6474::L6474_StepClockHandler(void)
Davidroid 0:2887415a46cd 1164 {
Davidroid 0:2887415a46cd 1165 /* Set isr flag */
Davidroid 0:2887415a46cd 1166 isrFlag = TRUE;
Davidroid 0:2887415a46cd 1167
Davidroid 0:2887415a46cd 1168 /* Incrementation of the relative position */
Davidroid 0:2887415a46cd 1169 devicePrm.relativePos++;
Davidroid 0:2887415a46cd 1170
Davidroid 0:2887415a46cd 1171 switch (devicePrm.motionState)
Davidroid 0:2887415a46cd 1172 {
Davidroid 0:2887415a46cd 1173 case ACCELERATING:
Davidroid 0:2887415a46cd 1174 {
Davidroid 0:2887415a46cd 1175 uint32_t relPos = devicePrm.relativePos;
Davidroid 0:2887415a46cd 1176 uint32_t endAccPos = devicePrm.endAccPos;
Davidroid 0:2887415a46cd 1177 uint16_t speed = devicePrm.speed;
Davidroid 0:2887415a46cd 1178 uint32_t acc = ((uint32_t)devicePrm.acceleration << 16);
Davidroid 0:2887415a46cd 1179
Davidroid 0:2887415a46cd 1180 if ((devicePrm.commandExecuted == SOFT_STOP_CMD)||
Davidroid 0:2887415a46cd 1181 ((devicePrm.commandExecuted != RUN_CMD)&&
Davidroid 0:2887415a46cd 1182 (relPos == devicePrm.startDecPos)))
Davidroid 0:2887415a46cd 1183 {
Davidroid 0:2887415a46cd 1184 devicePrm.motionState = DECELERATING;
Davidroid 0:2887415a46cd 1185 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1186 }
Davidroid 0:2887415a46cd 1187 else if ((speed >= devicePrm.maxSpeed)||
Davidroid 0:2887415a46cd 1188 ((devicePrm.commandExecuted != RUN_CMD)&&
Davidroid 0:2887415a46cd 1189 (relPos == endAccPos)))
Davidroid 0:2887415a46cd 1190 {
Davidroid 0:2887415a46cd 1191 devicePrm.motionState = STEADY;
Davidroid 0:2887415a46cd 1192 }
Davidroid 0:2887415a46cd 1193 else
Davidroid 0:2887415a46cd 1194 {
Davidroid 0:2887415a46cd 1195 bool speedUpdated = FALSE;
Davidroid 0:2887415a46cd 1196 /* Go on accelerating */
Davidroid 0:2887415a46cd 1197 if (speed == 0) speed =1;
Davidroid 0:2887415a46cd 1198 devicePrm.accu += acc / speed;
Davidroid 0:2887415a46cd 1199 while (devicePrm.accu >= (0X10000L))
Davidroid 0:2887415a46cd 1200 {
Davidroid 0:2887415a46cd 1201 devicePrm.accu -= (0X10000L);
Davidroid 0:2887415a46cd 1202 speed +=1;
Davidroid 0:2887415a46cd 1203 speedUpdated = TRUE;
Davidroid 0:2887415a46cd 1204 }
Davidroid 0:2887415a46cd 1205
Davidroid 0:2887415a46cd 1206 if (speedUpdated)
Davidroid 0:2887415a46cd 1207 {
Davidroid 0:2887415a46cd 1208 if (speed > devicePrm.maxSpeed)
Davidroid 0:2887415a46cd 1209 {
Davidroid 0:2887415a46cd 1210 speed = devicePrm.maxSpeed;
Davidroid 0:2887415a46cd 1211 }
Davidroid 0:2887415a46cd 1212 devicePrm.speed = speed;
Davidroid 0:2887415a46cd 1213 L6474_ApplySpeed(devicePrm.speed);
Davidroid 0:2887415a46cd 1214 }
Davidroid 0:2887415a46cd 1215 }
Davidroid 0:2887415a46cd 1216 break;
Davidroid 0:2887415a46cd 1217 }
Davidroid 0:2887415a46cd 1218 case STEADY:
Davidroid 0:2887415a46cd 1219 {
Davidroid 0:2887415a46cd 1220 uint16_t maxSpeed = devicePrm.maxSpeed;
Davidroid 0:2887415a46cd 1221 uint32_t relativePos = devicePrm.relativePos;
Davidroid 0:2887415a46cd 1222 if ((devicePrm.commandExecuted == SOFT_STOP_CMD)||
Davidroid 0:2887415a46cd 1223 ((devicePrm.commandExecuted != RUN_CMD)&&
Davidroid 0:2887415a46cd 1224 (relativePos >= (devicePrm.startDecPos))) ||
Davidroid 0:2887415a46cd 1225 ((devicePrm.commandExecuted == RUN_CMD)&&
Davidroid 0:2887415a46cd 1226 (devicePrm.speed > maxSpeed)))
Davidroid 0:2887415a46cd 1227 {
Davidroid 0:2887415a46cd 1228 devicePrm.motionState = DECELERATING;
Davidroid 0:2887415a46cd 1229 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1230 }
Davidroid 0:2887415a46cd 1231 else if ((devicePrm.commandExecuted == RUN_CMD)&&
Davidroid 0:2887415a46cd 1232 (devicePrm.speed < maxSpeed))
Davidroid 0:2887415a46cd 1233 {
Davidroid 0:2887415a46cd 1234 devicePrm.motionState = ACCELERATING;
Davidroid 0:2887415a46cd 1235 devicePrm.accu = 0;
Davidroid 0:2887415a46cd 1236 }
Davidroid 0:2887415a46cd 1237 break;
Davidroid 0:2887415a46cd 1238 }
Davidroid 0:2887415a46cd 1239 case DECELERATING:
Davidroid 0:2887415a46cd 1240 {
Davidroid 0:2887415a46cd 1241 uint32_t relativePos = devicePrm.relativePos;
Davidroid 0:2887415a46cd 1242 uint16_t speed = devicePrm.speed;
Davidroid 0:2887415a46cd 1243 uint32_t deceleration = ((uint32_t)devicePrm.deceleration << 16);
Davidroid 0:2887415a46cd 1244 if (((devicePrm.commandExecuted == SOFT_STOP_CMD)&&(speed <= devicePrm.minSpeed))||
Davidroid 0:2887415a46cd 1245 ((devicePrm.commandExecuted != RUN_CMD)&&
Davidroid 0:2887415a46cd 1246 (relativePos >= devicePrm.stepsToTake)))
Davidroid 0:2887415a46cd 1247 {
Davidroid 0:2887415a46cd 1248 /* Motion process complete */
Davidroid 0:2887415a46cd 1249 L6474_HardStop();
Davidroid 0:2887415a46cd 1250 }
Davidroid 0:2887415a46cd 1251 else if ((devicePrm.commandExecuted == RUN_CMD)&&
Davidroid 0:2887415a46cd 1252 (speed <= devicePrm.maxSpeed))
Davidroid 0:2887415a46cd 1253 {
Davidroid 0:2887415a46cd 1254 devicePrm.motionState = STEADY;
Davidroid 0:2887415a46cd 1255 }
Davidroid 0:2887415a46cd 1256 else
Davidroid 0:2887415a46cd 1257 {
Davidroid 0:2887415a46cd 1258 /* Go on decelerating */
Davidroid 0:2887415a46cd 1259 if (speed > devicePrm.minSpeed)
Davidroid 0:2887415a46cd 1260 {
Davidroid 0:2887415a46cd 1261 bool speedUpdated = FALSE;
Davidroid 0:2887415a46cd 1262 if (speed == 0) speed =1;
Davidroid 0:2887415a46cd 1263 devicePrm.accu += deceleration / speed;
Davidroid 0:2887415a46cd 1264 while (devicePrm.accu >= (0X10000L))
Davidroid 0:2887415a46cd 1265 {
Davidroid 0:2887415a46cd 1266 devicePrm.accu -= (0X10000L);
Davidroid 0:2887415a46cd 1267 if (speed > 1)
Davidroid 0:2887415a46cd 1268 {
Davidroid 0:2887415a46cd 1269 speed -=1;
Davidroid 0:2887415a46cd 1270 }
Davidroid 0:2887415a46cd 1271 speedUpdated = TRUE;
Davidroid 0:2887415a46cd 1272 }
Davidroid 0:2887415a46cd 1273
Davidroid 0:2887415a46cd 1274 if (speedUpdated)
Davidroid 0:2887415a46cd 1275 {
Davidroid 0:2887415a46cd 1276 if (speed < devicePrm.minSpeed)
Davidroid 0:2887415a46cd 1277 {
Davidroid 0:2887415a46cd 1278 speed = devicePrm.minSpeed;
Davidroid 0:2887415a46cd 1279 }
Davidroid 0:2887415a46cd 1280 devicePrm.speed = speed;
Davidroid 0:2887415a46cd 1281 L6474_ApplySpeed(devicePrm.speed);
Davidroid 0:2887415a46cd 1282 }
Davidroid 0:2887415a46cd 1283 }
Davidroid 0:2887415a46cd 1284 }
Davidroid 0:2887415a46cd 1285 break;
Davidroid 0:2887415a46cd 1286 }
Davidroid 0:2887415a46cd 1287 default:
Davidroid 0:2887415a46cd 1288 {
Davidroid 0:2887415a46cd 1289 break;
Davidroid 0:2887415a46cd 1290 }
Davidroid 0:2887415a46cd 1291 }
Davidroid 0:2887415a46cd 1292 /* Set isr flag */
Davidroid 0:2887415a46cd 1293 isrFlag = FALSE;
Davidroid 0:2887415a46cd 1294 }
Davidroid 0:2887415a46cd 1295
Davidroid 5:d3c78f12a78d 1296 /**********************************************************
Davidroid 0:2887415a46cd 1297 * @brief Converts mA in compatible values for TVAL register
Davidroid 0:2887415a46cd 1298 * @param[in] Tval
Davidroid 0:2887415a46cd 1299 * @retval TVAL values
Davidroid 0:2887415a46cd 1300 **********************************************************/
Davidroid 0:2887415a46cd 1301 uint8_t L6474::L6474_Tval_Current_to_Par(double Tval)
Davidroid 0:2887415a46cd 1302 {
Davidroid 0:2887415a46cd 1303 return ((uint8_t)(((Tval - 31.25)/31.25)+0.5));
Davidroid 0:2887415a46cd 1304 }
Davidroid 0:2887415a46cd 1305
Davidroid 5:d3c78f12a78d 1306 /**********************************************************
Davidroid 0:2887415a46cd 1307 * @brief Convert time in us in compatible values
Davidroid 0:2887415a46cd 1308 * for TON_MIN register
Davidroid 0:2887415a46cd 1309 * @param[in] Tmin
Davidroid 0:2887415a46cd 1310 * @retval TON_MIN values
Davidroid 0:2887415a46cd 1311 **********************************************************/
Davidroid 0:2887415a46cd 1312 uint8_t L6474::L6474_Tmin_Time_to_Par(double Tmin)
Davidroid 0:2887415a46cd 1313 {
Davidroid 0:2887415a46cd 1314 return ((uint8_t)(((Tmin - 0.5)*2)+0.5));
Davidroid 0:2887415a46cd 1315 }
Davidroid 0:2887415a46cd 1316
Davidroid 5:d3c78f12a78d 1317 /**********************************************************
Davidroid 0:2887415a46cd 1318 * @brief Write and receive a byte via SPI
Davidroid 0:2887415a46cd 1319 * @param[in] pByteToTransmit pointer to the byte to transmit
Davidroid 0:2887415a46cd 1320 * @param[in] pReceivedByte pointer to the received byte
Davidroid 0:2887415a46cd 1321 * @retval None
Davidroid 0:2887415a46cd 1322 **********************************************************/
Davidroid 0:2887415a46cd 1323 void L6474::L6474_WriteBytes(uint8_t *pByteToTransmit, uint8_t *pReceivedByte)
Davidroid 0:2887415a46cd 1324 {
Davidroid 0:2887415a46cd 1325 if (L6474_SpiWriteBytes(pByteToTransmit, pReceivedByte) != 0)
Davidroid 0:2887415a46cd 1326 {
Davidroid 0:2887415a46cd 1327 L6474_ErrorHandler(L6474_ERROR_1);
Davidroid 0:2887415a46cd 1328 }
Davidroid 0:2887415a46cd 1329
Davidroid 0:2887415a46cd 1330 if (isrFlag)
Davidroid 0:2887415a46cd 1331 {
Davidroid 0:2887415a46cd 1332 spiPreemtionByIsr = TRUE;
Davidroid 0:2887415a46cd 1333 }
Davidroid 0:2887415a46cd 1334 }
Davidroid 0:2887415a46cd 1335
Davidroid 0:2887415a46cd 1336 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/