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@0:2887415a46cd, 2015-10-14 (annotated)

Committer:
Davidroid
Date:
Wed Oct 14 15:12:18 2015 +0000
Revision:
0:2887415a46cd
Child:
1:b38ebb8ea286
Library to handle the X_NUCLEO_IHM01A1 Motor Control Expansion Board.

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